BigInteger.Remainder(BigInteger, BigInteger) Méthode

Référence

Définition

Espace de noms:: System.Numerics

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Effectue une division entière sur deux valeurs BigInteger et retourne le modulo.

public:
 static System::Numerics::BigInteger Remainder(System::Numerics::BigInteger dividend, System::Numerics::BigInteger divisor);

public static System.Numerics.BigInteger Remainder (System.Numerics.BigInteger dividend, System.Numerics.BigInteger divisor);

static member Remainder : System.Numerics.BigInteger * System.Numerics.BigInteger -> System.Numerics.BigInteger

Public Shared Function Remainder (dividend As BigInteger, divisor As BigInteger) As BigInteger

Paramètres

dividend: BigInteger

Valeur à diviser.

divisor: BigInteger

Valeur par laquelle diviser.

Retours

BigInteger

Reste de la division de dividend par divisor.

Exceptions

DivideByZeroException

divisor est égal à 0 (zéro).

Exemples

L’exemple suivant compare le reste de la DivRem méthode avec le reste retourné par la Remainder méthode pour établir que les deux méthodes calculent des restes identiques.

using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      BigInteger dividend1 = BigInteger.Pow(Int64.MaxValue, 3);
      BigInteger dividend2 = dividend1 * BigInteger.MinusOne;
      BigInteger divisor1 = Int32.MaxValue;
      BigInteger divisor2 = divisor1 * BigInteger.MinusOne;
      BigInteger remainder1, remainder2;
      BigInteger divRem1 = BigInteger.Zero;
      BigInteger divRem2 = BigInteger.Zero;

      remainder1 = BigInteger.Remainder(dividend1, divisor1);
      remainder2 = BigInteger.Remainder(dividend2, divisor1);

      BigInteger.DivRem(dividend1, divisor1, out divRem1);
      Console.WriteLine("BigInteger.Remainder({0}, {1}) = {2}",
                        dividend1, divisor1, remainder1);
      Console.WriteLine("BigInteger.DivRem({0}, {1}) = {2}",
                        dividend1, divisor1, divRem1);
      if (remainder1.Equals(divRem1))
         Console.WriteLine("The remainders are equal.\n");

      BigInteger.DivRem(dividend2, divisor2, out divRem2);
      Console.WriteLine("BigInteger.Remainder({0}, {1}) = {2}",
                        dividend2, divisor2, remainder2);
      Console.WriteLine("BigInteger.DivRem({0}, {1}) = {2}",
                        dividend2, divisor2, divRem2);
      if (remainder2.Equals(divRem2))
         Console.WriteLine("The remainders are equal.\n");
   }
}
// The example displays the following output:
//    BigInteger.Remainder(784637716923335095224261902710254454442933591094742482943, 2147483647) = 1
//    BigInteger.DivRem(784637716923335095224261902710254454442933591094742482943, 2147483647) = 1
//    The remainders are equal.
//
//    BigInteger.Remainder(-784637716923335095224261902710254454442933591094742482943, -2147483647) = -1
//    BigInteger.DivRem(-784637716923335095224261902710254454442933591094742482943, -2147483647) = -1
//    The remainders are equal.

open System
open System.Numerics

let dividend1 = BigInteger.Pow(Int64.MaxValue, 3)
let dividend2 = dividend1 * BigInteger.MinusOne
let divisor1 = bigint Int32.MaxValue
let divisor2 = divisor1 * BigInteger.MinusOne

let remainder1 = BigInteger.Remainder(dividend1, divisor1)
let remainder2 = BigInteger.Remainder(dividend2, divisor1)

let mutable divRem1 = BigInteger.Zero
let mutable divRem2 = BigInteger.Zero

BigInteger.DivRem(dividend1, divisor1, &divRem1) |> ignore

printfn $"BigInteger.Remainder({dividend1}, {divisor1}) = {remainder1}"

printfn $"BigInteger.DivRem({dividend1}, {divisor1}) = {divRem1}"


if remainder1.Equals divRem1 then
    printfn $"The remainders are equal.\n"

BigInteger.DivRem(dividend2, divisor2, &divRem2) |> ignore

printfn $"BigInteger.Remainder({dividend2}, {divisor2}) = {remainder2}"
printfn $"BigInteger.DivRem({dividend2}, {divisor2}) = {divRem2}"

if remainder2.Equals divRem2 then
    printfn $"The remainders are equal.\n"

// The example displays the following output:
//    BigInteger.Remainder(784637716923335095224261902710254454442933591094742482943, 2147483647) = 1
//    BigInteger.DivRem(784637716923335095224261902710254454442933591094742482943, 2147483647) = 1
//    The remainders are equal.
//
//    BigInteger.Remainder(-784637716923335095224261902710254454442933591094742482943, -2147483647) = -1
//    BigInteger.DivRem(-784637716923335095224261902710254454442933591094742482943, -2147483647) = -1
//    The remainders are equal.

Imports System.Numerics

Module Example
   Public Sub Main()
      Dim dividend1 As BigInteger = BigInteger.Pow(Int64.MaxValue, 3)
      Dim dividend2 As BigInteger = dividend1 * BigInteger.MinusOne
      Dim divisor1 As BigInteger = Int32.MaxValue
      Dim divisor2 As BigInteger = divisor1 * BigInteger.MinusOne
      Dim remainder1, remainder2 As BigInteger
      Dim divRem1 As BigInteger = BigInteger.Zero
      Dim divRem2 As BigInteger = BigInteger.Zero

      remainder1 = BigInteger.Remainder(dividend1, divisor1)
      remainder2 = BigInteger.Remainder(dividend2, divisor1)

      BigInteger.DivRem(dividend1, divisor1, divRem1)
      Console.WriteLine("BigInteger.Remainder({0}, {1}) = {2}",
                        dividend1, divisor1, remainder1)
      Console.WriteLine("BigInteger.DivRem({0}, {1}) = {2}",
                        dividend1, divisor1, divRem1)
      If remainder1.Equals(divRem1) Then Console.WriteLine("The remainders are equal.")
      Console.WriteLine()

      BigInteger.DivRem(dividend2, divisor2, divRem2)
      Console.WriteLine("BigInteger.Remainder({0}, {1}) = {2}",
                        dividend2, divisor2, remainder2)
      Console.WriteLine("BigInteger.DivRem({0}, {1}) = {2}",
                        dividend2, divisor2, divRem2)
      If remainder2.Equals(divRem2) Then Console.WriteLine("The remainders are equal.")
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'    BigInteger.Remainder(784637716923335095224261902710254454442933591094742482943, 2147483647) = 1
'    BigInteger.DivRem(784637716923335095224261902710254454442933591094742482943, 2147483647) = 1
'    The remainders are equal.
'
'    BigInteger.Remainder(-784637716923335095224261902710254454442933591094742482943, -2147483647) = -1
'    BigInteger.DivRem(-784637716923335095224261902710254454442933591094742482943, -2147483647) = -1
'    The remainders are equal.

Remarques

Le signe du reste est le signe du dividend paramètre.

La Remainder méthode est implémentée pour les langages qui ne prennent pas en charge les opérateurs personnalisés. Son comportement est identique à la division à l’aide de l’opérateur de module.

Si nécessaire, la méthode effectue automatiquement la conversion implicite d’autres types intégraux en BigInteger objets avant d’effectuer l’opération de module.

S’applique à

Partager via