BigInteger.DivRem Méthode

Référence

Définition

Espace de noms:: System.Numerics

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

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.

Surcharges

DivRem(BigInteger, BigInteger)	Calcule le quotient et le reste de deux valeurs.
DivRem(BigInteger, BigInteger, BigInteger)	Divise une valeur BigInteger par une autre, retourne le résultat, puis retourne le modulo dans un paramètre de sortie.

DivRem(BigInteger, BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Calcule le quotient et le reste de deux valeurs.

public:
 static ValueTuple<System::Numerics::BigInteger, System::Numerics::BigInteger> DivRem(System::Numerics::BigInteger left, System::Numerics::BigInteger right) = System::Numerics::IBinaryInteger<System::Numerics::BigInteger>::DivRem;

public static (System.Numerics.BigInteger Quotient, System.Numerics.BigInteger Remainder) DivRem (System.Numerics.BigInteger left, System.Numerics.BigInteger right);

static member DivRem : System.Numerics.BigInteger * System.Numerics.BigInteger -> ValueTuple<System.Numerics.BigInteger, System.Numerics.BigInteger>

Public Shared Function DivRem (left As BigInteger, right As BigInteger) As ValueTuple(Of BigInteger, BigInteger)

Paramètres

left: BigInteger

Valeur qui right divise.

right: BigInteger

Valeur qui divise left.

Retours

ValueTuple<BigInteger,BigInteger>

Quotient et reste de left divisé par right.

Implémente

DivRem(TSelf, TSelf)

S’applique à

DivRem(BigInteger, BigInteger, BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Divise une valeur BigInteger par une autre, retourne le résultat, puis retourne le modulo dans un paramètre de sortie.

public:
 static System::Numerics::BigInteger DivRem(System::Numerics::BigInteger dividend, System::Numerics::BigInteger divisor, [Runtime::InteropServices::Out] System::Numerics::BigInteger % remainder);

public static System.Numerics.BigInteger DivRem (System.Numerics.BigInteger dividend, System.Numerics.BigInteger divisor, out System.Numerics.BigInteger remainder);

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

Public Shared Function DivRem (dividend As BigInteger, divisor As BigInteger, ByRef remainder As BigInteger) As BigInteger

Paramètres

dividend: BigInteger

Valeur à diviser.

divisor: BigInteger

Valeur par laquelle diviser.

remainder: BigInteger

Lorsque cette méthode est retournée, contient une valeur BigInteger qui représente le modulo de la division. Ce paramètre est passé sans être initialisé.

Retours

BigInteger

Quotient de la division.

Exceptions

DivideByZeroException

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

Exemples

L’exemple suivant crée un tableau de BigInteger valeurs. Il utilise ensuite chaque élément comme quotient dans une opération de division qui utilise la Divide méthode, l’opérateur de division (/) et la DivRem méthode.

using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      BigInteger divisor = BigInteger.Pow(Int64.MaxValue, 2);

      BigInteger[] dividends = { BigInteger.Multiply((BigInteger) Single.MaxValue, 2),
                                 BigInteger.Parse("90612345123875509091827560007100099"),
                                 BigInteger.One,
                                 BigInteger.Multiply(Int32.MaxValue, Int64.MaxValue),
                                 divisor + BigInteger.One };

      // Divide each dividend by divisor in three different ways.
      foreach (BigInteger dividend in dividends)
      {
         BigInteger quotient;
         BigInteger remainder = 0;

         Console.WriteLine("Dividend: {0:N0}", dividend);
         Console.WriteLine("Divisor:  {0:N0}", divisor);
         Console.WriteLine("Results:");
         Console.WriteLine("   Using Divide method:     {0:N0}",
                           BigInteger.Divide(dividend, divisor));
         Console.WriteLine("   Using Division operator: {0:N0}",
                           dividend / divisor);
         quotient = BigInteger.DivRem(dividend, divisor, out remainder);
         Console.WriteLine("   Using DivRem method:     {0:N0}, remainder {1:N0}",
                           quotient, remainder);

         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    Dividend: 680,564,693,277,057,719,623,408,366,969,033,850,880
//    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
//    Results:
//       Using Divide method:     7
//       Using Division operator: 7
//       Using DivRem method:     7, remainder 85,070,551,165,415,408,691,630,012,479,406,342,137
//
//    Dividend: 90,612,345,123,875,509,091,827,560,007,100,099
//    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
//    Results:
//       Using Divide method:     0
//       Using Division operator: 0
//       Using DivRem method:     0, remainder 90,612,345,123,875,509,091,827,560,007,100,099
//
//    Dividend: 1
//    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
//    Results:
//       Using Divide method:     0
//       Using Division operator: 0
//       Using DivRem method:     0, remainder 1
//
//    Dividend: 19,807,040,619,342,712,359,383,728,129
//    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
//    Results:
//       Using Divide method:     0
//       Using Division operator: 0
//       Using DivRem method:     0, remainder 19,807,040,619,342,712,359,383,728,129
//
//    Dividend: 85,070,591,730,234,615,847,396,907,784,232,501,250
//    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
//    Results:
//       Using Divide method:     1
//       Using Division operator: 1
//       Using DivRem method:     1, remainder 1

open System
open System.Numerics

let divisor = BigInteger.Pow(Int64.MaxValue, 2)

let dividends =
    [| BigInteger.Multiply(bigint Single.MaxValue, 2)
       BigInteger.Parse "90612345123875509091827560007100099"
       BigInteger.One
       BigInteger.Multiply(Int32.MaxValue, Int64.MaxValue)
       divisor + BigInteger.One |]

// Divide each dividend by divisor in three different ways.
for dividend in dividends do
    let mutable quotient = 0I
    let mutable remainder = 0I

    printfn $"Dividend: {dividend:N0}"
    printfn $"Divisor:  {divisor:N0}"
    printfn "Results:"
    printfn $"   Using Divide method:     {BigInteger.Divide(dividend, divisor):N0}"
    printfn $"   Using Division operator: {dividend / divisor:N0}"
    quotient <- BigInteger.DivRem(dividend, divisor, &remainder)
    printfn $"   Using DivRem method:     {quotient:N0}, remainder {remainder:N0}"
    printfn ""
// The example displays the following output:
//    Dividend: 680,564,693,277,057,719,623,408,366,969,033,850,880
//    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
//    Results:
//       Using Divide method:     7
//       Using Division operator: 7
//       Using DivRem method:     7, remainder 85,070,551,165,415,408,691,630,012,479,406,342,137
//
//    Dividend: 90,612,345,123,875,509,091,827,560,007,100,099
//    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
//    Results:
//       Using Divide method:     0
//       Using Division operator: 0
//       Using DivRem method:     0, remainder 90,612,345,123,875,509,091,827,560,007,100,099
//
//    Dividend: 1
//    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
//    Results:
//       Using Divide method:     0
//       Using Division operator: 0
//       Using DivRem method:     0, remainder 1
//
//    Dividend: 19,807,040,619,342,712,359,383,728,129
//    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
//    Results:
//       Using Divide method:     0
//       Using Division operator: 0
//       Using DivRem method:     0, remainder 19,807,040,619,342,712,359,383,728,129
//
//    Dividend: 85,070,591,730,234,615,847,396,907,784,232,501,250
//    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
//    Results:
//       Using Divide method:     1
//       Using Division operator: 1
//       Using DivRem method:     1, remainder 1

Imports System.Numerics

Module Example
   Public Sub Main()
      Dim divisor As BigInteger = BigInteger.Pow(Int64.MaxValue, 2)
      
      Dim dividends() As BigInteger = { BigInteger.Multiply(CType(Single.MaxValue, BigInteger), 2), 
                                        BigInteger.Parse("90612345123875509091827560007100099"), 
                                        BigInteger.One, 
                                        BigInteger.Multiply(Int32.MaxValue, Int64.MaxValue),
                                        divisor + BigInteger.One }

      ' Divide each dividend by divisor in three different ways.
      For Each dividend As BigInteger In dividends
         Dim quotient As BigInteger
         Dim remainder As BigInteger = 0
         
         ' Divide using division operator.
         Console.WriteLine("Dividend: {0:N0}", dividend)
         Console.WriteLine("Divisor:  {0:N0}", divisor)
         Console.WriteLine("Results:")
         Console.WriteLine("   Using Divide method:     {0:N0}", 
                           BigInteger.Divide(dividend, divisor))
         Console.WriteLine("   Using Division operator: {0:N0}", 
                           dividend / divisor)
         quotient = BigInteger.DivRem(dividend, divisor, remainder)
         Console.WriteLine("   Using DivRem method:     {0:N0}, remainder {1:N0}", 
                           quotient, remainder)
         
         Console.WriteLine()         
      Next                                        
   End Sub
End Module
' The example displays the following output:
'    Dividend: 680,564,693,277,057,719,623,408,366,969,033,850,880
'    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
'    Results:
'       Using Divide method:     7
'       Using Division operator: 7
'       Using DivRem method:     7, remainder 85,070,551,165,415,408,691,630,012,479,406,342,137
'    
'    Dividend: 90,612,345,123,875,509,091,827,560,007,100,099
'    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
'    Results:
'       Using Divide method:     0
'       Using Division operator: 0
'       Using DivRem method:     0, remainder 90,612,345,123,875,509,091,827,560,007,100,099
'    
'    Dividend: 1
'    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
'    Results:
'       Using Divide method:     0
'       Using Division operator: 0
'       Using DivRem method:     0, remainder 1
'    
'    Dividend: 19,807,040,619,342,712,359,383,728,129
'    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
'    Results:
'       Using Divide method:     0
'       Using Division operator: 0
'       Using DivRem method:     0, remainder 19,807,040,619,342,712,359,383,728,129
'    
'    Dividend: 85,070,591,730,234,615,847,396,907,784,232,501,250
'    Divisor:  85,070,591,730,234,615,847,396,907,784,232,501,249
'    Results:
'       Using Divide method:     1
'       Using Division operator: 1
'       Using DivRem method:     1, remainder 1

Remarques

Cette méthode conserve à la fois le quotient et le reste qui résulte de la division entière. Si vous n’êtes pas intéressé par le reste, utilisez la Divide méthode ou l’opérateur de division ; si vous n’êtes intéressé que par le reste, utilisez la Remainder méthode .

Le signe de la valeur retournée remainder est identique au signe du dividend paramètre.

Le comportement de la DivRem méthode est identique à celui de la Math.DivRem méthode .

S’applique à

Partager via

BigInteger.DivRem Méthode

Définition

Surcharges

DivRem(BigInteger, BigInteger)

Paramètres

Retours

Implémente

S’applique à

DivRem(BigInteger, BigInteger, BigInteger)

Paramètres

Retours

Exceptions

Exemples

Remarques

S’applique à

Ressources supplémentaires