BigInteger BigInteger BigInteger BigInteger Struct

Définition

Représente un entier signé arbitrairement grand.Represents an arbitrarily large signed integer.

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IFormattable
[System.Serializable]
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
type BigInteger = struct
    interface IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable
Héritage
BigIntegerBigIntegerBigIntegerBigInteger
Attributs
Implémente

Remarques

Le BigInteger type est un type immuable qui représente un entier arbitrairement grand dont la valeur en théorie n’a pas de limite supérieure ou inférieure.The BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. Les membres BigInteger du type sont étroitement parallèles à ceux d’autres types intégraux Int16(les Int64 Bytetypes SByte, UInt16 Int32, UInt32,, UInt64 ,, et).The members of the BigInteger type closely parallel those of other integral types (the Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, and UInt64 types). Ce type diffère des autres types intégraux dans .NET Framework.NET Framework, qui ont une plage indiquée par leurs MinValue propriétés et MaxValue .This type differs from the other integral types in the .NET Framework.NET Framework, which have a range indicated by their MinValue and MaxValue properties.

Notes

Étant donné BigInteger que le type est immuable (consultez mutabilité et structure BigInteger) et parce qu’il n’a pas de limite supérieure ou inférieure OutOfMemoryException , une exception peut être levée pour toute opération BigInteger qui entraîne une augmentation trop importante d’une valeur.Because the BigInteger type is immutable (see Mutability and the BigInteger Structure) and because it has no upper or lower bounds, an OutOfMemoryException can be thrown for any operation that causes a BigInteger value to grow too large.

Instanciation d’un objet BigIntegerInstantiating a BigInteger Object

Vous pouvez instancier BigInteger un objet de plusieurs façons:You can instantiate a BigInteger object in several ways:

  • Vous pouvez utiliser le new mot clé et fournir toute valeur intégrale ou à virgule flottante en tant BigInteger que paramètre au constructeur.You can use the new keyword and provide any integral or floating-point value as a parameter to the BigInteger constructor. (Les valeurs à virgule flottante sont tronquées avant d’être affectées à BigInteger.) L’exemple suivant illustre l’utilisation du mot clé new pour instancier BigInteger des valeurs.(Floating-point values are truncated before they are assigned to the BigInteger.) The following example illustrates how to use the new keyword to instantiate BigInteger values.

    BigInteger bigIntFromDouble = new BigInteger(179032.6541);
    Console.WriteLine(bigIntFromDouble);
    BigInteger bigIntFromInt64 = new BigInteger(934157136952);
    Console.WriteLine(bigIntFromInt64);
    // The example displays the following output:
    //   179032
    //   934157136952		
    
    Dim bigIntFromDouble As New BigInteger(179032.6541)
    Console.WriteLine(bigIntFromDouble)
    Dim bigIntFromInt64 As New BigInteger(934157136952)
    Console.WriteLine(bigIntFromInt64)
    ' The example displays the following output:
    '   179032
    '   934157136952		
    
  • Vous pouvez déclarer une BigInteger variable et lui assigner une valeur de la même façon que n’importe quel type numérique, à condition que cette valeur soit un type intégral.You can declare a BigInteger variable and assign it a value just as you would any numeric type, as long as that value is an integral type. L’exemple suivant utilise l’assignation pour créer BigInteger une valeur à Int64partir d’un.The following example uses assignment to create a BigInteger value from an Int64.

    long longValue = 6315489358112;      
    BigInteger assignedFromLong = longValue;
    Console.WriteLine(assignedFromLong);
    // The example displays the following output:
    //   6315489358112
    
    Dim longValue As Long = 6315489358112      
    Dim assignedFromLong As BigInteger = longValue
    Console.WriteLine(assignedFromLong)
    ' The example displays the following output:
    '   6315489358112
    
  • Vous pouvez assigner une valeur décimale ou à virgule BigInteger flottante à un objet si vous effectuez un cast de la valeur ou que vous la Convertissez en premier.You can assign a decimal or floating-point value to a BigInteger object if you cast the value or convert it first. L’exemple suivant effectue un cast explicite ( C#en) ou convertit (en Visual Basic Double ) un Decimal et BigIntegerune valeur en.The following example explicitly casts (in C#) or converts (in Visual Basic) a Double and a Decimal value to a BigInteger.

    BigInteger assignedFromDouble = (BigInteger) 179032.6541;
    Console.WriteLine(assignedFromDouble);   
    BigInteger assignedFromDecimal = (BigInteger) 64312.65m;      
    Console.WriteLine(assignedFromDecimal);
    // The example displays the following output:
    //   179032
    //   64312      
    
    Dim assignedFromDouble As BigInteger = CType(179032.6541, BigInteger)
    Console.WriteLine(assignedFromDouble)   
    Dim assignedFromDecimal As BigInteger = CType(64312.65d, BigInteger)      
    Console.WriteLine(assignedFromDecimal)
    ' The example displays the following output:
    '   179032
    '   64312      
    

Ces méthodes vous permettent d’instancier BigInteger un objet dont la valeur est comprise dans la plage de l’un des types numériques existants uniquement.These methods enable you to instantiate a BigInteger object whose value is in the range of one of the existing numeric types only. Vous pouvez instancier BigInteger un objet dont la valeur peut dépasser la plage des types numériques existants de l’une des trois façons suivantes:You can instantiate a BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

  • Vous pouvez utiliser le new mot clé et fournir un tableau d’octets de toute taille BigInteger.BigInteger au constructeur.You can use the new keyword and provide a byte array of any size to the BigInteger.BigInteger constructor. Par exemple :For example:

    byte[] byteArray = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
    BigInteger newBigInt = new BigInteger(byteArray);
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt);    
    // The example displays the following output:
    //   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
    Dim byteArray() As Byte = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
    Dim newBigInt As New BigInteger(byteArray)
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt)    
    ' The example displays the following output:
    '   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
  • Vous pouvez appeler les Parse méthodes TryParse ou pour convertir la représentation sous forme BigIntegerde chaîne d’un nombre en.You can call the Parse or TryParse methods to convert the string representation of a number to a BigInteger. Par exemple :For example:

    string positiveString = "91389681247993671255432112000000";
    string negativeString = "-90315837410896312071002088037140000";
    BigInteger posBigInt = 0;
    BigInteger negBigInt = 0;
    
    try {
       posBigInt = BigInteger.Parse(positiveString);
       Console.WriteLine(posBigInt);
    }
    catch (FormatException)
    {
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", 
                         positiveString);
    }
    
    if (BigInteger.TryParse(negativeString, out negBigInt))
      Console.WriteLine(negBigInt);
    else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", 
                          negativeString);
    
    // The example displays the following output:
    //   9.1389681247993671255432112E+31
    //   -9.0315837410896312071002088037E+34
    
    Dim positiveString As String = "91389681247993671255432112000000"
    Dim negativeString As string = "-90315837410896312071002088037140000"
    Dim posBigInt As BigInteger = 0
    Dim negBigInt As BigInteger = 0
    
    Try
       posBigInt = BigInteger.Parse(positiveString)
       Console.WriteLine(posBigInt)
    Catch e As FormatException
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                         positiveString)
    End Try
    
    If BigInteger.TryParse(negativeString, negBigInt) Then
      Console.WriteLine(negBigInt)
    Else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                          negativeString)
    End If         
    ' The example displays the following output:
    '   9.1389681247993671255432112E+31
    '   -9.0315837410896312071002088037E+34
    
  • Vous pouvez appeler une static méthodeShared (dans Visual Basic BigInteger ) qui effectue une opération sur une expression numérique et retourne un résultat BigInteger calculé.You can call a static (Shared in Visual Basic) BigInteger method that performs some operation on a numeric expression and returns a calculated BigInteger result. L’exemple suivant effectue cela en cubes UInt64.MaxValue et en assignant le résultat BigIntegerà un.The following example does this by cubing UInt64.MaxValue and assigning the result to a BigInteger.

    BigInteger number = BigInteger.Pow(UInt64.MaxValue, 3);
    Console.WriteLine(number);
    // The example displays the following output:
    //    6277101735386680762814942322444851025767571854389858533375
    
    Dim number As BigInteger = BigInteger.Pow(UInt64.MaxValue, 3)
    Console.WriteLine(number)
    ' The example displays the following output:
      ' 6277101735386680762814942322444851025767571854389858533375
    

La valeur non initialisée d’un BigInteger est Zero.The uninitialized value of a BigInteger is Zero.

Exécution d’opérations sur les valeurs BigIntegerPerforming Operations on BigInteger Values

Vous pouvez utiliser une BigInteger instance comme vous le feriez pour tout autre type intégral.You can use a BigInteger instance as you would use any other integral type. BigIntegersurcharge les opérateurs numériques standard pour vous permettre d’effectuer des opérations mathématiques de base, telles que l’addition, la soustraction, la Division, la multiplication, la soustraction, la négation et la négation unaire.BigInteger overloads the standard numeric operators to enable you to perform basic mathematical operations such as addition, subtraction, division, multiplication, subtraction, negation, and unary negation. Vous pouvez également utiliser les opérateurs numériques standard pour comparer deux BigInteger valeurs les unes avec les autres.You can also use the standard numeric operators to compare two BigInteger values with each other. À l’instar des autres BigInteger types intégraux, prend Orégalement XOren charge les opérateurs de bits And,,, de décalage vers la gauche et de décalage vers la droite.Like the other integral types, BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. Pour les langages qui ne prennent pas en charge BigInteger les opérateurs personnalisés, la structure fournit également des méthodes équivalentes pour effectuer des opérations mathématiques.For languages that do not support custom operators, the BigInteger structure also provides equivalent methods for performing mathematical operations. Celles- Addci Divideincluent Multiply, Negate,, ,Subtract, et plusieurs autres.These include Add, Divide, Multiply, Negate, Subtract, and several others.

De nombreux membres de BigInteger la structure correspondent directement aux membres des autres types intégraux.Many members of the BigInteger structure correspond directly to members of the other integral types. En outre, BigInteger ajoute des membres tels que les suivants:In addition, BigInteger adds members such as the following:

Un grand nombre de ces membres supplémentaires correspondent aux membres de Math la classe, qui fournit les fonctionnalités permettant d’utiliser les types numériques primitifs.Many of these additional members correspond to the members of the Math class, which provides the functionality to work with the primitive numeric types.

Mutabilité et structure BigIntegerMutability and the BigInteger Structure

L’exemple suivant instancie un BigInteger objet, puis incrémente sa valeur d’une unité.The following example instantiates a BigInteger object and then increments its value by one.

BigInteger number = BigInteger.Multiply(Int64.MaxValue, 3);
number++;
Console.WriteLine(number);
Dim number As BigInteger = BigInteger.Multiply(Int64.MaxValue, 3)
number += 1
Console.WriteLine(number)

Bien que cet exemple semble modifier la valeur de l’objet existant, ce n’est pas le cas.Although this example appears to modify the value of the existing object, this is not the case. BigIntegerles objets sont immuables, ce qui signifie qu’en interne, le Common Language Runtime crée en BigInteger fait un nouvel objet et lui attribue une valeur supérieure à sa valeur précédente.BigInteger objects are immutable, which means that internally, the common language runtime actually creates a new BigInteger object and assigns it a value one greater than its previous value. Ce nouvel objet est ensuite retourné à l’appelant.This new object is then returned to the caller.

Notes

Les autres types numériques de la .NET Framework sont également immuables.The other numeric types in the .NET Framework are also immutable. Toutefois, étant donné BigInteger que le type n’a pas de limite supérieure ou inférieure, ses valeurs peuvent croître extrêmement volumineuses et avoir un impact mesurable sur les performances.However, because the BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

Bien que ce processus soit transparent pour l’appelant, il entraîne une baisse des performances.Although this process is transparent to the caller, it does incur a performance penalty. Dans certains cas, en particulier lorsque des opérations répétées sont effectuées dans une boucle BigInteger sur des valeurs très élevées, cette altération des performances peut être importante.In some cases, especially when repeated operations are performed in a loop on very large BigInteger values, that performance penalty can be significant. Par exemple, dans l’exemple suivant, une opération est exécutée de façon répétée jusqu’à un million de BigInteger fois, et une valeur est incrémentée d’une unité chaque fois que l’opération est réussie.For example, in the following example, an operation is performed repetitively up to a million times, and a BigInteger value is incremented by one every time the operation succeeds.

BigInteger number = Int64.MaxValue ^ 5;
int repetitions = 1000000;
// Perform some repetitive operation 1 million times.
for (int ctr = 0; ctr <= repetitions; ctr++)
{
   // Perform some operation. If it fails, exit the loop.
   if (! SomeOperationSucceeds()) break;
   // The following code executes if the operation succeeds.
   number++;
}
Dim number As BigInteger = Int64.MaxValue ^ 5
Dim repetitions As Integer = 1000000
' Perform some repetitive operation 1 million times.
For ctr As Integer = 0 To repetitions
   ' Perform some operation. If it fails, exit the loop.
   If Not SomeOperationSucceeds() Then Exit For
   ' The following code executes if the operation succeeds.
   number += 1
Next

Dans ce cas, vous pouvez améliorer les performances en effectuant toutes les affectations Int32 intermédiaires à une variable.In such a case, you can improve performance by performing all intermediate assignments to an Int32 variable. La valeur finale de la variable peut ensuite être assignée BigInteger à l’objet lorsque la boucle se termine.The final value of the variable can then be assigned to the BigInteger object when the loop exits. L'exemple suivant illustre cette situation.The following example provides an illustration.

BigInteger number = Int64.MaxValue ^ 5;
int repetitions = 1000000;
int actualRepetitions = 0;
// Perform some repetitive operation 1 million times.
for (int ctr = 0; ctr <= repetitions; ctr++)
{
   // Perform some operation. If it fails, exit the loop.
   if (! SomeOperationSucceeds()) break;
   // The following code executes if the operation succeeds.
   actualRepetitions++;
}
number += actualRepetitions;
Dim number As BigInteger = Int64.MaxValue ^ 5
Dim repetitions As Integer = 1000000
Dim actualRepetitions As Integer = 0
' Perform some repetitive operation 1 million times.
For ctr As Integer = 0 To repetitions
   ' Perform some operation. If it fails, exit the loop.
   If Not SomeOperationSucceeds() Then Exit For
   ' The following code executes if the operation succeeds.
   actualRepetitions += 1
Next
number += actualRepetitions

Utilisation des tableaux d’octets et des chaînes hexadécimalesWorking with Byte Arrays and Hexadecimal Strings

Si vous convertissez BigInteger des valeurs en tableaux d’octets ou si vous convertissez des tableaux BigInteger d’octets en valeurs, vous devez tenir compte de l’ordre des octets.If you convert BigInteger values to byte arrays, or if you convert byte arrays to BigInteger values, you must consider the order of bytes. La BigInteger structure s’attend à ce que les octets individuels d’un tableau d’octets apparaissent dans l’ordre de primauté des octets de poids faible (autrement dit, les octets de poids faible de la valeur précèdent les octets d’ordre supérieur).The BigInteger structure expects the individual bytes in a byte array to appear in little-endian order (that is, the lower-order bytes of the value precede the higher-order bytes). Vous pouvez effectuer un aller- BigInteger retour d’une valeur ToByteArray en appelant la méthode, puis en passant le tableau BigInteger(Byte[]) d’octets résultant au constructeur, comme le montre l’exemple suivant.You can round-trip a BigInteger value by calling the ToByteArray method and then passing the resulting byte array to the BigInteger(Byte[]) constructor, as the following example shows.

BigInteger number = BigInteger.Pow(Int64.MaxValue, 2);     
Console.WriteLine(number);

// Write the BigInteger value to a byte array.
byte[] bytes = number.ToByteArray();

// Display the byte array.
foreach (byte byteValue in bytes)
   Console.Write("0x{0:X2} ", byteValue);
Console.WriteLine();

// Restore the BigInteger value from a Byte array.
BigInteger newNumber = new BigInteger(bytes);
Console.WriteLine(newNumber);
// The example displays the following output:
//    8.5070591730234615847396907784E+37
//    0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x3F
//    
//    8.5070591730234615847396907784E+37
Dim number As BigInteger = BigInteger.Pow(Int64.MaxValue, 2)     
Console.WriteLine(number)

' Write the BigInteger value to a byte array.
Dim bytes() As Byte = number.ToByteArray()

' Display the byte array.
For Each byteValue As Byte In bytes
   Console.Write("0x{0:X2} ", byteValue)
Next   
Console.WriteLine()

' Restore the BigInteger value from a Byte array.
Dim newNumber As BigInteger = New BigInteger(bytes)
Console.WriteLine(newNumber)               
' The example displays the following output:
'    8.5070591730234615847396907784E+37
'    0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x3F
'    
'    8.5070591730234615847396907784E+37

Pour instancier BigInteger une valeur d’un tableau d’octets qui représente une valeur d’un autre type intégral, vous pouvez passer la valeur intégrale à la BitConverter.GetBytes méthode, puis passer le tableau d’octets BigInteger(Byte[]) résultant au constructeur.To instantiate a BigInteger value from a byte array that represents a value of some other integral type, you can pass the integral value to the BitConverter.GetBytes method, and then pass the resulting byte array to the BigInteger(Byte[]) constructor. L’exemple suivant instancie une BigInteger valeur d’un tableau d’octets qui représente Int16 une valeur.The following example instantiates a BigInteger value from a byte array that represents an Int16 value.

short originalValue = 30000;
Console.WriteLine(originalValue);

// Convert the Int16 value to a byte array.
byte[] bytes = BitConverter.GetBytes(originalValue);

// Display the byte array.
foreach (byte byteValue in bytes)
   Console.Write("0x{0} ", byteValue.ToString("X2"));
Console.WriteLine();

// Pass byte array to the BigInteger constructor.
BigInteger number = new BigInteger(bytes);
Console.WriteLine(number);
// The example displays the following output:
//       30000
//       0x30 0x75
//       30000
Dim originalValue As Short = 30000
Console.WriteLine(originalValue)

' Convert the Int16 value to a byte array.
Dim bytes() As Byte = BitConverter.GetBytes(originalValue)

' Display the byte array.
For Each byteValue As Byte In bytes
   Console.Write("0x{0} ", byteValue.ToString("X2"))
Next    
Console.WriteLine() 

' Pass byte array to the BigInteger constructor.
Dim number As BigInteger = New BigInteger(bytes)
Console.WriteLine(number)
' The example displays the following output:
'       30000
'       0x30 0x75
'       30000

La BigInteger structure part du principe que les valeurs négatives sont stockées à l’aide de la représentation du complément à deux.The BigInteger structure assumes that negative values are stored by using two's complement representation. Étant donné BigInteger que la structure représente une valeur numérique sans longueur fixe, BigInteger(Byte[]) le constructeur interprète toujours le bit le plus significatif du dernier octet dans le tableau comme un bit de signe.Because the BigInteger structure represents a numeric value with no fixed length, the BigInteger(Byte[]) constructor always interprets the most significant bit of the last byte in the array as a sign bit. Pour éviter que BigInteger(Byte[]) le constructeur ne déroutant la représentation de complément à deux d’une valeur négative avec la représentation de signe et de magnitude d’une valeur positive, les valeurs positives dans lesquelles le bit le plus significatif du dernier octet dans le tableau d’octets normalement, la définition de doit inclure un octet supplémentaire dont la valeur est 0.To prevent the BigInteger(Byte[]) constructor from confusing the two's complement representation of a negative value with the sign and magnitude representation of a positive value, positive values in which the most significant bit of the last byte in the byte array would ordinarily be set should include an additional byte whose value is 0. Par exemple, 0xC0 0xBD 0xF0 0xFF est la représentation hexadécimale Little-endian de-1 million ou 4 293 967 296.For example, 0xC0 0xBD 0xF0 0xFF is the little-endian hexadecimal representation of either -1,000,000 or 4,293,967,296. Étant donné que le bit le plus significatif du dernier octet de ce tableau est on, la valeur du tableau d’octets est interprétée BigInteger(Byte[]) par le constructeur comme-1 million.Because the most significant bit of the last byte in this array is on, the value of the byte array would be interpreted by the BigInteger(Byte[]) constructor as -1,000,000. Pour instancier BigInteger un dont la valeur est positive, un tableau d’octets dont les éléments sont 0xC0 0xBD 0xF0 0xFF 0x00 doit être passé au constructeur.To instantiate a BigInteger whose value is positive, a byte array whose elements are 0xC0 0xBD 0xF0 0xFF 0x00 must be passed to the constructor. L'exemple suivant illustre ce comportement.The following example illustrates this.

int negativeNumber = -1000000;
uint positiveNumber = 4293967296;

byte[] negativeBytes = BitConverter.GetBytes(negativeNumber); 
BigInteger negativeBigInt = new BigInteger(negativeBytes);
Console.WriteLine(negativeBigInt.ToString("N0"));

byte[] tempPosBytes = BitConverter.GetBytes(positiveNumber);
byte[] positiveBytes = new byte[tempPosBytes.Length + 1];
Array.Copy(tempPosBytes, positiveBytes, tempPosBytes.Length);
BigInteger positiveBigInt = new BigInteger(positiveBytes);
Console.WriteLine(positiveBigInt.ToString("N0")); 
// The example displays the following output:
//    -1,000,000
//    4,293,967,296      
Dim negativeNumber As Integer = -1000000
Dim positiveNumber As UInteger = 4293967296

Dim negativeBytes() As Byte = BitConverter.GetBytes(negativeNumber) 
Dim negativeBigInt As New BigInteger(negativeBytes)
Console.WriteLine(negativeBigInt.ToString("N0"))

Dim tempPosBytes() As Byte = BitConverter.GetBytes(positiveNumber)
Dim positiveBytes(tempposBytes.Length) As Byte
Array.Copy(tempPosBytes, positiveBytes, tempPosBytes.Length)
Dim positiveBigInt As New BigInteger(positiveBytes)
Console.WriteLine(positiveBigInt.ToString("N0")) 
' The example displays the following output:
'    -1,000,000
'    4,293,967,296      

Les tableaux d’octets créés par ToByteArray la méthode à partir de valeurs positives incluent cet octet de valeur zéro supplémentaire.Byte arrays created by the ToByteArray method from positive values include this extra zero-value byte. Par conséquent, BigInteger la structure peut effectuer un aller-retour des valeurs en les assignant à, puis en les restaurant à partir de tableaux d’octets, comme le montre l’exemple suivant.Therefore, the BigInteger structure can successfully round-trip values by assigning them to, and then restoring them from, byte arrays, as the following example shows.

BigInteger positiveValue = 15777216;
BigInteger negativeValue  = -1000000;

Console.WriteLine("Positive value: " + positiveValue.ToString("N0"));
byte[] bytes = positiveValue.ToByteArray();

foreach (byte byteValue in bytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
positiveValue = new BigInteger(bytes);
Console.WriteLine("Restored positive value: " + positiveValue.ToString("N0"));

Console.WriteLine();
   
Console.WriteLine("Negative value: " + negativeValue.ToString("N0"));
bytes = negativeValue.ToByteArray();
foreach (byte byteValue in bytes)
   Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
negativeValue = new BigInteger(bytes);
Console.WriteLine("Restored negative value: " + negativeValue.ToString("N0"));
// The example displays the following output:
//       Positive value: 15,777,216
//       C0 BD F0 00
//       Restored positive value: 15,777,216
//       
//       Negative value: -1,000,000
//       C0 BD F0
//       Restored negative value: -1,000,000
Dim positiveValue As BigInteger = 15777216
Dim negativeValue As BigInteger = -1000000

Console.WriteLine("Positive value: " + positiveValue.ToString("N0"))
Dim bytes() As Byte = positiveValue.ToByteArray()
For Each byteValue As Byte In bytes
   Console.Write("{0:X2} ", byteValue)
Next
Console.WriteLine()
positiveValue = New BigInteger(bytes)
Console.WriteLine("Restored positive value: " + positiveValue.ToString("N0"))

Console.WriteLine()
   
Console.WriteLIne("Negative value: " + negativeValue.ToString("N0"))
bytes = negativeValue.ToByteArray()
For Each byteValue As Byte In bytes
   Console.Write("{0:X2} ", byteValue)
Next
Console.WriteLine()
negativeValue = New BigInteger(bytes)
Console.WriteLine("Restored negative value: " + negativeValue.ToString("N0"))
' The example displays the following output:
'       Positive value: 15,777,216
'       C0 BD F0 00
'       Restored positive value: 15,777,216
'       
'       Negative value: -1,000,000
'       C0 BD F0
'       Restored negative value: -1,000,000

Toutefois, vous devrez peut-être ajouter cet octet de valeur zéro supplémentaire aux tableaux d’octets qui sont créés dynamiquement par le développeur ou qui sont retournés par les méthodes qui convertissent des entiers non signés en BitConverter.GetBytes(UInt16)tableaux BitConverter.GetBytes(UInt32)d’octets BitConverter.GetBytes(UInt64)(tels que, et).However, you may need to add this additional zero-value byte to byte arrays that are created dynamically by the developer or that are returned by methods that convert unsigned integers to byte arrays (such as BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32), and BitConverter.GetBytes(UInt64)).

Lors de l’analyse d’une chaîne hexadécimale BigInteger.Parse(String, NumberStyles, IFormatProvider) , les BigInteger.Parse(String, NumberStyles) méthodes et supposent que si le bit le plus significatif du premier octet de la chaîne est défini, ou si le premier chiffre hexadécimal de la chaîne représente les quatre bits inférieurs d’une valeur d’octet, la valeur est représenté à l’aide de la représentation du complément à deux.When parsing a hexadecimal string, the BigInteger.Parse(String, NumberStyles) and BigInteger.Parse(String, NumberStyles, IFormatProvider) methods assume that if the most significant bit of the first byte in the string is set, or if the first hexadecimal digit of the string represents the lower four bits of a byte value, the value is represented by using two's complement representation. Par exemple, «FF01» et «F01» représentent la valeur décimale-255.For example, both "FF01" and "F01" represent the decimal value -255. Pour différencier les valeurs positives des valeurs négatives, les valeurs positives doivent inclure un zéro non significatif.To differentiate positive from negative values, positive values should include a leading zero. Les surcharges pertinentes de la ToString méthode, quand elles sont passées à la chaîne de format "X", ajoutent un zéro non significatif à la chaîne hexadécimale retournée pour les valeurs positives.The relevant overloads of the ToString method, when they are passed the "X" format string, add a leading zero to the returned hexadecimal string for positive values. Cela permet d’effectuer un aller-retour BigInteger des valeurs à ToString l’aide Parse des méthodes et, comme le montre l’exemple suivant.This makes it possible to round-trip BigInteger values by using the ToString and Parse methods, as the following example shows.

BigInteger negativeNumber = -1000000;
BigInteger positiveNumber  = 15777216;

string negativeHex = negativeNumber.ToString("X");
string positiveHex = positiveNumber.ToString("X");

BigInteger negativeNumber2, positiveNumber2;  
negativeNumber2 = BigInteger.Parse(negativeHex, 
                                   NumberStyles.HexNumber);
positiveNumber2 = BigInteger.Parse(positiveHex,
                                   NumberStyles.HexNumber);

Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   negativeNumber, negativeHex, negativeNumber2);                                         
Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   positiveNumber, positiveHex, positiveNumber2);                                         
// The example displays the following output:
//       Converted -1,000,000 to F0BDC0 back to -1,000,000.
//       Converted 15,777,216 to 0F0BDC0 back to 15,777,216.
Dim negativeNumber As BigInteger = -1000000
Dim positiveNumber As BigInteger = 15777216

Dim negativeHex As String = negativeNumber.ToString("X")
Dim positiveHex As string = positiveNumber.ToString("X")

Dim negativeNumber2, positiveNumber2 As BigInteger 
negativeNumber2 = BigInteger.Parse(negativeHex, 
                                   NumberStyles.HexNumber)
positiveNumber2 = BigInteger.Parse(positiveHex,
                                   NumberStyles.HexNumber)

Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   negativeNumber, negativeHex, negativeNumber2)                                         
Console.WriteLine("Converted {0:N0} to {1} back to {2:N0}.", 
                   positiveNumber, positiveHex, positiveNumber2)                                         
' The example displays the following output:
'       Converted -1,000,000 to F0BDC0 back to -1,000,000.
'       Converted 15,777,216 to 0F0BDC0 back to 15,777,216.

Toutefois, les chaînes hexadécimales créées en appelant ToString les méthodes des autres types intégraux ou les surcharges de ToString la méthode qui inclut toBase un paramètre n’indiquent pas le signe de la valeur ou le type de données source à partir duquel la chaîne hexadécimale a été dérivée.However, the hexadecimal strings created by calling the ToString methods of the other integral types or the overloads of the ToString method that include a toBase parameter do not indicate the sign of the value or the source data type from which the hexadecimal string was derived. L’instanciation BigInteger réussie d’une valeur à partir d’une telle chaîne requiert une logique supplémentaire.Successfully instantiating a BigInteger value from such a string requires some additional logic. L’exemple suivant fournit une implémentation possible.The following example provides one possible implementation.

using System;
using System.Globalization;
using System.Numerics;

public struct HexValue
{
   public int Sign;
   public string Value;
}

public class Example
{
   public static void Main()
   {
      uint positiveNumber = 4039543321;
      int negativeNumber = -255423975;

      // Convert the numbers to hex strings.
      HexValue hexValue1, hexValue2;
      hexValue1.Value = positiveNumber.ToString("X");
      hexValue1.Sign = Math.Sign(positiveNumber);
      
      hexValue2.Value = Convert.ToString(negativeNumber, 16);
      hexValue2.Sign = Math.Sign(negativeNumber);
      
      // Round-trip the hexadecimal values to BigInteger values.
      string hexString;
      BigInteger positiveBigInt, negativeBigInt;
      
      hexString = (hexValue1.Sign == 1 ? "0" : "") + hexValue1.Value;
      positiveBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        positiveNumber, hexValue1.Value, positiveBigInt);

      hexString = (hexValue2.Sign == 1 ? "0" : "") + hexValue2.Value;
      negativeBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        negativeNumber, hexValue2.Value, negativeBigInt);
   }
}
// The example displays the following output:
//       Converted 4039543321 to F0C68A19 and back to 4039543321.
//       Converted -255423975 to f0c68a19 and back to -255423975.
Imports System.Globalization
Imports System.Numerics

Public Structure HexValue
   Public Sign As Integer
   Public Value As String
End Structure
   
Module Example
   Public Sub Main()
      Dim positiveNumber As UInteger = 4039543321
      Dim negativeNumber As Integer = -255423975

      ' Convert the numbers to hex strings.
      Dim hexValue1, hexValue2 As HexValue
      hexValue1.Value = positiveNumber.ToString("X")
      hexValue1.Sign = Math.Sign(positiveNumber)
      
      hexValue2.Value = Convert.ToString(negativeNumber, 16)
      hexValue2.Sign = Math.Sign(negativeNumber)
      
      ' Round-trip the hexadecimal values to BigInteger values.
      Dim hexString As String
      Dim positiveBigInt, negativeBigInt As BigInteger
      
      hexString = CStr(IIf(hexValue1.Sign = 1, "0", "")) + hexValue1.Value
      positiveBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber)      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        positiveNumber, hexValue1.Value, positiveBigInt)

      hexString = CStr(IIf(hexValue2.Sign = 1, "0", "")) + hexValue2.Value
      negativeBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber)      
      Console.WriteLine("Converted {0} to {1} and back to {2}.", 
                        negativeNumber, hexValue2.Value, negativeBigInt)

   End Sub
End Module
' The example displays the following output:
'       Converted 4039543321 to F0C68A19 and back to 4039543321.
'       Converted -255423975 to f0c68a19 and back to -255423975.

Constructeurs

BigInteger(Byte[]) BigInteger(Byte[]) BigInteger(Byte[]) BigInteger(Byte[])

Initialise une nouvelle instance de la structure BigInteger à l'aide des valeurs d'un tableau d'octets.Initializes a new instance of the BigInteger structure using the values in a byte array.

BigInteger(Decimal) BigInteger(Decimal) BigInteger(Decimal) BigInteger(Decimal)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur Decimal.Initializes a new instance of the BigInteger structure using a Decimal value.

BigInteger(Double) BigInteger(Double) BigInteger(Double) BigInteger(Double)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur à virgule flottante double précision.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

BigInteger(Int32) BigInteger(Int32) BigInteger(Int32) BigInteger(Int32)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur d'entier 32 bits signé.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

BigInteger(Int64) BigInteger(Int64) BigInteger(Int64) BigInteger(Int64)

Initialise une nouvelle instance de la structure BigInteger à l’aide d’une valeur d’entier 64 bits signé.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

BigInteger(Single) BigInteger(Single) BigInteger(Single) BigInteger(Single)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur à virgule flottante simple précision.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

BigInteger(UInt32) BigInteger(UInt32) BigInteger(UInt32) BigInteger(UInt32)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur entière 32 bits non signée.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

BigInteger(UInt64) BigInteger(UInt64) BigInteger(UInt64) BigInteger(UInt64)

Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur entière 64 bits non signée.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Propriétés

IsEven IsEven IsEven IsEven

Indique si la valeur de l'objet BigInteger actif est un nombre pair.Indicates whether the value of the current BigInteger object is an even number.

IsOne IsOne IsOne IsOne

Indique si la valeur de l'objet BigInteger actif est One.Indicates whether the value of the current BigInteger object is One.

IsPowerOfTwo IsPowerOfTwo IsPowerOfTwo IsPowerOfTwo

Indique si la valeur de l'objet BigInteger actif est une puissance de deux.Indicates whether the value of the current BigInteger object is a power of two.

IsZero IsZero IsZero IsZero

Indique si la valeur de l'objet BigInteger actif est Zero.Indicates whether the value of the current BigInteger object is Zero.

MinusOne MinusOne MinusOne MinusOne

Obtient une valeur qui représente le nombre moins un (-1).Gets a value that represents the number negative one (-1).

One One One One

Obtient une valeur qui représente le nombre un (1).Gets a value that represents the number one (1).

Sign Sign Sign Sign

Obtient un nombre qui indique le signe (négatif, positif ou zéro) de l'objet BigInteger actif.Gets a number that indicates the sign (negative, positive, or zero) of the current BigInteger object.

Zero Zero Zero Zero

Obtient une valeur qui représente le nombre 0 (zéro).Gets a value that represents the number 0 (zero).

Méthodes

Abs(BigInteger) Abs(BigInteger) Abs(BigInteger) Abs(BigInteger)

Obtient la valeur absolue d'un objet BigInteger.Gets the absolute value of a BigInteger object.

Add(BigInteger, BigInteger) Add(BigInteger, BigInteger) Add(BigInteger, BigInteger) Add(BigInteger, BigInteger)

Ajoute deux valeurs BigInteger et retourne le résultat.Adds two BigInteger values and returns the result.

Compare(BigInteger, BigInteger) Compare(BigInteger, BigInteger) Compare(BigInteger, BigInteger) Compare(BigInteger, BigInteger)

Compare deux valeurs BigInteger et retourne un entier qui indique si la première valeur est inférieure, égale ou supérieure à la seconde valeur.Compares two BigInteger values and returns an integer that indicates whether the first value is less than, equal to, or greater than the second value.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

Compare cette instance à un objet spécifié et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'objet spécifié.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(UInt64) CompareTo(UInt64) CompareTo(UInt64) CompareTo(UInt64)

Compare cette instance à un entier 64 bits non signé et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'entier 64 bits non signé.Compares this instance to an unsigned 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the unsigned 64-bit integer.

CompareTo(Int64) CompareTo(Int64) CompareTo(Int64) CompareTo(Int64)

Compare cette instance à un entier 64 bits signé et retourne un entier qui indique si la valeur de cette instance est inférieure, égale ou supérieure à la valeur de l'entier 64 bits signé.Compares this instance to a signed 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the signed 64-bit integer.

CompareTo(BigInteger) CompareTo(BigInteger) CompareTo(BigInteger) CompareTo(BigInteger)

Compare cette instance à un second BigInteger et retourne un entier qui indique si la valeur de l'instance est inférieure, égale ou supérieure à la valeur de l'objet spécifié.Compares this instance to a second BigInteger and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger)

Divise une valeur BigInteger par une autre et retourne le résultat.Divides one BigInteger value by another and returns the result.

DivRem(BigInteger, BigInteger, BigInteger) DivRem(BigInteger, BigInteger, BigInteger) DivRem(BigInteger, BigInteger, BigInteger) 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.Divides one BigInteger value by another, returns the result, and returns the remainder in an output parameter.

Equals(Int64) Equals(Int64) Equals(Int64) Equals(Int64)

Retourne une valeur qui indique si l'instance actuelle et un entier 64 bits signé ont la même valeur.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

Equals(BigInteger) Equals(BigInteger) Equals(BigInteger) Equals(BigInteger)

Retourne une valeur qui indique si l'instance actuelle et un objet BigInteger spécifié ont la même valeur.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Retourne une valeur qui indique si l'instance actuelle et un objet spécifié ont la même valeur.Returns a value that indicates whether the current instance and a specified object have the same value.

Equals(UInt64) Equals(UInt64) Equals(UInt64) Equals(UInt64)

Retourne une valeur qui indique si l'instance actuelle et un entier 64 bits non signé ont la même valeur.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

GetByteCount(Boolean) GetByteCount(Boolean) GetByteCount(Boolean) GetByteCount(Boolean)

Obtient le nombre d’octets qui seront générés par ToByteArray(Boolean, Boolean) et TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean).Gets the number of bytes that will be output by ToByteArray(Boolean, Boolean) and TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean).

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Retourne le code de hachage pour l'objet BigInteger actuel.Returns the hash code for the current BigInteger object.

GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger)

Recherche le plus grand commun diviseur de deux valeurs BigInteger.Finds the greatest common divisor of two BigInteger values.

Log(BigInteger) Log(BigInteger) Log(BigInteger) Log(BigInteger)

Retourne le logarithme naturel (base e) d'un nombre spécifié.Returns the natural (base e) logarithm of a specified number.

Log(BigInteger, Double) Log(BigInteger, Double) Log(BigInteger, Double) Log(BigInteger, Double)

Retourne le logarithme d'un nombre spécifié dans une base spécifiée.Returns the logarithm of a specified number in a specified base.

Log10(BigInteger) Log10(BigInteger) Log10(BigInteger) Log10(BigInteger)

Retourne le logarithme de base 10 d'un nombre spécifié.Returns the base 10 logarithm of a specified number.

Max(BigInteger, BigInteger) Max(BigInteger, BigInteger) Max(BigInteger, BigInteger) Max(BigInteger, BigInteger)

Retourne la plus grande des deux valeurs BigInteger.Returns the larger of two BigInteger values.

Min(BigInteger, BigInteger) Min(BigInteger, BigInteger) Min(BigInteger, BigInteger) Min(BigInteger, BigInteger)

Retourne la plus petite des deux valeurs BigInteger.Returns the smaller of two BigInteger values.

ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger)

Effectue une division avec coefficient sur un nombre élevé à la puissance d'un autre nombre.Performs modulus division on a number raised to the power of another number.

Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger)

Retourne le produit de deux valeurs BigInteger.Returns the product of two BigInteger values.

Negate(BigInteger) Negate(BigInteger) Negate(BigInteger) Negate(BigInteger)

Rend négative la valeur BigInteger spécifiée.Negates a specified BigInteger value.

Parse(String) Parse(String) Parse(String) Parse(String)

Convertit la représentation sous forme de chaîne d'un nombre en sa représentation BigInteger équivalente.Converts the string representation of a number to its BigInteger equivalent.

Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles)

Convertit la représentation d'un nombre sous forme de chaîne dans un style spécifié en son équivalent BigInteger.Converts the string representation of a number in a specified style to its BigInteger equivalent.

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider)

Convertit la représentation sous forme de chaîne d'un nombre, ayant un format spécifique à la culture spécifié, en sa représentation BigInteger équivalente.Converts the string representation of a number in a specified culture-specific format to its BigInteger equivalent.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider)

Convertit la représentation sous forme de chaîne d'un nombre, ayant un style et un format propre à la culture spécifiés, en sa représentation BigInteger équivalente.Converts the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent.

Pow(BigInteger, Int32) Pow(BigInteger, Int32) Pow(BigInteger, Int32) Pow(BigInteger, Int32)

Élève une valeur BigInteger à la puissance de la valeur spécifiée.Raises a BigInteger value to the power of a specified value.

Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger)

Effectue une division entière sur deux valeurs BigInteger et retourne le modulo.Performs integer division on two BigInteger values and returns the remainder.

Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger)

Soustrait une valeur BigInteger d'une autre valeur et retourne le résultat.Subtracts one BigInteger value from another and returns the result.

ToByteArray() ToByteArray() ToByteArray() ToByteArray()

Convertit une valeur BigInteger en tableau d'octets.Converts a BigInteger value to a byte array.

ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean)

Retourne la valeur de ce BigInteger sous la forme d’un tableau d’octets en utilisant le plus petit nombre d’octets possible.Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. Si la valeur est égale à zéro, retourne un tableau d’un octet dont l’élément est 0x00.If the value is zero, returns an array of one byte whose element is 0x00.

ToString() ToString() ToString() ToString()

Convertit la valeur numérique de l'objet BigInteger actuel dans sa représentation sous forme chaîne équivalente.Converts the numeric value of the current BigInteger object to its equivalent string representation.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Convertit la valeur numérique de l’objet BigInteger actuel en sa représentation sous forme de chaîne équivalente à l’aide des informations spécifiées de mise en forme spécifiques à la culture.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified culture-specific formatting information.

ToString(String) ToString(String) ToString(String) ToString(String)

Convertit la valeur numérique de l’objet BigInteger actuel en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format.

ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider)

Convertit la valeur numérique de l’objet BigInteger actuel en sa représentation sous forme de chaîne équivalente à l’aide du format spécifié et des informations de mise en forme spécifiques à la culture.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format and culture-specific format information.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger)
TryParse(String, BigInteger) TryParse(String, BigInteger) TryParse(String, BigInteger) TryParse(String, BigInteger)

Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent BigInteger et retourne une valeur indiquant si la conversion a réussi.Tries to convert the string representation of a number to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)
TryParse(String, NumberStyles, IFormatProvider, BigInteger) TryParse(String, NumberStyles, IFormatProvider, BigInteger) TryParse(String, NumberStyles, IFormatProvider, BigInteger) TryParse(String, NumberStyles, IFormatProvider, BigInteger)

Essaie de convertir la représentation sous forme de chaîne d'un nombre ayant un style et un format spécifique à la culture spécifiés en son équivalent BigInteger et retourne une valeur qui indique si la conversion a réussi.Tries to convert the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)

Copie la valeur de ce BigInteger en tant qu’octets de complément à deux de poids faible (little-endian), en utilisant le plus petit nombre d’octets possible.Copies the value of this BigInteger as little-endian twos-complement bytes, using the fewest number of bytes possible. Si la valeur est égale à zéro, génère un octet dont l’élément est 0x00.If the value is zero, outputs one byte whose element is 0x00.

Opérateurs

Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger)

Ajoute les valeurs des deux objets BigInteger spécifiés.Adds the values of two specified BigInteger objects.

BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger)

Effectue une opération de bits And sur deux valeurs BigInteger.Performs a bitwise And operation on two BigInteger values.

BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger)

Effectue une opération de bits Or sur deux valeurs BigInteger.Performs a bitwise Or operation on two BigInteger values.

Decrement(BigInteger) Decrement(BigInteger) Decrement(BigInteger) Decrement(BigInteger)

Décrémente une valeur BigInteger de 1.Decrements a BigInteger value by 1.

Division(BigInteger, BigInteger) Division(BigInteger, BigInteger) Division(BigInteger, BigInteger) Division(BigInteger, BigInteger)

Divise une valeur BigInteger spécifique par une autre valeur BigInteger spécifique à l'aide d'une division entière.Divides a specified BigInteger value by another specified BigInteger value by using integer division.

Equality(Int64, BigInteger) Equality(Int64, BigInteger) Equality(Int64, BigInteger) Equality(Int64, BigInteger)

Retourne une valeur qui indique si la valeur d'un entier long signé et la valeur BigInteger sont égales.Returns a value that indicates whether a signed long integer value and a BigInteger value are equal.

Equality(BigInteger, Int64) Equality(BigInteger, Int64) Equality(BigInteger, Int64) Equality(BigInteger, Int64)

Retourne une valeur qui indique si la valeur BigInteger et la valeur d'un entier long signé sont égales.Returns a value that indicates whether a BigInteger value and a signed long integer value are equal.

Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger)

Retourne une valeur qui indique si les valeurs de deux objets BigInteger sont égales.Returns a value that indicates whether the values of two BigInteger objects are equal.

Equality(BigInteger, UInt64) Equality(BigInteger, UInt64) Equality(BigInteger, UInt64) Equality(BigInteger, UInt64)

Retourne une valeur qui indique si la valeur BigInteger et la valeur d'un entier long non signé sont égales.Returns a value that indicates whether a BigInteger value and an unsigned long integer value are equal.

Equality(UInt64, BigInteger) Equality(UInt64, BigInteger) Equality(UInt64, BigInteger) Equality(UInt64, BigInteger)

Retourne une valeur qui indique si la valeur d'un entier long non signé et la valeur BigInteger sont égales.Returns a value that indicates whether an unsigned long integer value and a BigInteger value are equal.

ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger)

Effectue une opération de bits Or (XOr) exclusive sur deux valeurs BigInteger.Performs a bitwise exclusive Or (XOr) operation on two BigInteger values.

Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger)

Définit une conversion explicite d'un objet Decimal en valeur BigInteger.Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger)

Définit une conversion explicite d'une valeur Double en valeur BigInteger.Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte)

Définit une conversion explicite d'un objet BigInteger en valeur d'octet non signée.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal)

Définit une conversion explicite d'un objet BigInteger en valeur Decimal.Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double)

Définit une conversion explicite d'un objet BigInteger en valeur Double.Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16)

Définit une conversion explicite d'un objet BigInteger en valeur d'entier 16 bits signé.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 32 bits signé.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 64 bits signé.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte)

Définit une conversion explicite d'un objet BigInteger en valeur 8 bits signée.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Int16.The compliant alternative is Int16.

Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single)

Définit une conversion explicite d'un objet BigInteger en valeur à virgule flottante simple précision.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16)

Définit une conversion explicite d'un objet BigInteger en valeur entière 16 bits non signée.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Int32.The compliant alternative is Int32.

Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 32 bits non signé.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Int64.The compliant alternative is Int64.

Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64)

Définit une conversion explicite d’un objet BigInteger en valeur d’entier 64 bits non signé.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Double.The compliant alternative is Double.

Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger)

Définit une conversion explicite d'une valeur Single en valeur BigInteger.Defines an explicit conversion of a Single value to a BigInteger value.

GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger)

Retourne une valeur qui indique si une valeur BigInteger est supérieure à un entier 64 bits non signé.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64)

Retourne une valeur qui indique si une valeur BigInteger est supérieure à un entier 64 bits non signé.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits signé est supérieur à une valeur BigInteger.Returns a value that indicates whether a 64-bit signed integer is greater than a BigInteger value.

GreaterThan(BigInteger, Int64) GreaterThan(BigInteger, Int64) GreaterThan(BigInteger, Int64) GreaterThan(BigInteger, Int64)

Retourne une valeur qui indique si BigInteger est supérieur à une valeur d'entier 64 bits signé.Returns a value that indicates whether a BigInteger is greater than a 64-bit signed integer value.

GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger)

Retourne une valeur qui indique si une valeur BigInteger est supérieure à une autre valeur BigInteger.Returns a value that indicates whether a BigInteger value is greater than another BigInteger value.

GreaterThanOrEqual(Int64, BigInteger) GreaterThanOrEqual(Int64, BigInteger) GreaterThanOrEqual(Int64, BigInteger) GreaterThanOrEqual(Int64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits signé est supérieur ou égal à une valeur BigInteger.Returns a value that indicates whether a 64-bit signed integer is greater than or equal to a BigInteger value.

GreaterThanOrEqual(BigInteger, Int64) GreaterThanOrEqual(BigInteger, Int64) GreaterThanOrEqual(BigInteger, Int64) GreaterThanOrEqual(BigInteger, Int64)

Retourne une valeur qui indique si une valeur BigInteger est supérieure ou égale à une valeur d'entier 64 bits signé.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit signed integer value.

GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger)

Retourne une valeur qui indique si une valeur BigInteger est supérieure ou égale à une autre valeur BigInteger.Returns a value that indicates whether a BigInteger value is greater than or equal to another BigInteger value.

GreaterThanOrEqual(BigInteger, UInt64) GreaterThanOrEqual(BigInteger, UInt64) GreaterThanOrEqual(BigInteger, UInt64) GreaterThanOrEqual(BigInteger, UInt64)

Retourne une valeur qui indique si une valeur BigInteger est supérieure ou égale à une valeur entière 64 bits non signée.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit unsigned integer value.

GreaterThanOrEqual(UInt64, BigInteger) GreaterThanOrEqual(UInt64, BigInteger) GreaterThanOrEqual(UInt64, BigInteger) GreaterThanOrEqual(UInt64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits non signé est supérieur ou égal à une valeur BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is greater than or equal to a BigInteger value.

Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger)

Définit une conversion implicite d’un entier 32 bits non signé en valeur BigInteger.Defines an implicit conversion of a 32-bit unsigned integer to a BigInteger value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Implicit(Int64 to BigInteger).The compliant alternative is Implicit(Int64 to BigInteger).

Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger)

Définit une conversion implicite d'un entier 16 bits non signé en valeur BigInteger.Defines an implicit conversion of a 16-bit unsigned integer to a BigInteger value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Implicit(Int32 to BigInteger).The compliant alternative is Implicit(Int32 to BigInteger).

Implicit(SByte to BigInteger) Implicit(SByte to BigInteger) Implicit(SByte to BigInteger) Implicit(SByte to BigInteger)

Définit une conversion implicite d'un entier 8 bits signé en valeur BigInteger.Defines an implicit conversion of an 8-bit signed integer to a BigInteger value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est BigInteger(Int32).The compliant alternative is BigInteger(Int32).

Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger)

Définit une conversion implicite d’un entier 64 bits non signé en valeur BigInteger.Defines an implicit conversion of a 64-bit unsigned integer to a BigInteger value.

Cette API n'est pas conforme CLS.This API is not CLS-compliant. L’alternative conforme est Double.The compliant alternative is Double.

Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger)

Définit une conversion implicite d’un entier 32 bits signé en valeur BigInteger.Defines an implicit conversion of a signed 32-bit integer to a BigInteger value.

Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger)

Définit une conversion implicite d'un entier 16 bits signé en valeur BigInteger.Defines an implicit conversion of a signed 16-bit integer to a BigInteger value.

Implicit(Byte to BigInteger) Implicit(Byte to BigInteger) Implicit(Byte to BigInteger) Implicit(Byte to BigInteger)

Définit une conversion implicite d'un octet non signé en valeur BigInteger.Defines an implicit conversion of an unsigned byte to a BigInteger value.

Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger)

Définit une conversion implicite d’un entier 64 bits signé en valeur BigInteger.Defines an implicit conversion of a signed 64-bit integer to a BigInteger value.

Increment(BigInteger) Increment(BigInteger) Increment(BigInteger) Increment(BigInteger)

Incrémente une valeur BigInteger de 1.Increments a BigInteger value by 1.

Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits non signé et une valeur BigInteger ne sont pas égaux.Returns a value that indicates whether a 64-bit unsigned integer and a BigInteger value are not equal.

Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger)

Retourne une valeur qui indique si deux objets BigInteger ont des valeurs différentes.Returns a value that indicates whether two BigInteger objects have different values.

Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64)

Retourne une valeur qui indique si une valeur BigInteger et un entier 64 bits non signé ne sont pas égaux.Returns a value that indicates whether a BigInteger value and a 64-bit unsigned integer are not equal.

Inequality(Int64, BigInteger) Inequality(Int64, BigInteger) Inequality(Int64, BigInteger) Inequality(Int64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits signé et une valeur BigInteger ne sont pas égaux.Returns a value that indicates whether a 64-bit signed integer and a BigInteger value are not equal.

Inequality(BigInteger, Int64) Inequality(BigInteger, Int64) Inequality(BigInteger, Int64) Inequality(BigInteger, Int64)

Retourne une valeur qui indique si une valeur BigInteger et un entier 64 bits signé ne sont pas égaux.Returns a value that indicates whether a BigInteger value and a 64-bit signed integer are not equal.

LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32)

Décale une valeur BigInteger d'un certain nombre de bits vers la gauche.Shifts a BigInteger value a specified number of bits to the left.

LessThan(Int64, BigInteger) LessThan(Int64, BigInteger) LessThan(Int64, BigInteger) LessThan(Int64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits signé est inférieur à une valeur BigInteger.Returns a value that indicates whether a 64-bit signed integer is less than a BigInteger value.

LessThan(BigInteger, Int64) LessThan(BigInteger, Int64) LessThan(BigInteger, Int64) LessThan(BigInteger, Int64)

Retourne une valeur qui indique si une valeur BigInteger est inférieure à un entier 64 bits signé.Returns a value that indicates whether a BigInteger value is less than a 64-bit signed integer.

LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger)

Retourne une valeur qui indique si une valeur BigInteger est inférieure à une autre valeur BigInteger.Returns a value that indicates whether a BigInteger value is less than another BigInteger value.

LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64)

Retourne une valeur qui indique si une valeur BigInteger est inférieure à un entier 64 bits non signé.Returns a value that indicates whether a BigInteger value is less than a 64-bit unsigned integer.

LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits non signé est inférieur à une valeur BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is less than a BigInteger value.

LessThanOrEqual(UInt64, BigInteger) LessThanOrEqual(UInt64, BigInteger) LessThanOrEqual(UInt64, BigInteger) LessThanOrEqual(UInt64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits non signé est inférieur ou égal à une valeur BigInteger.Returns a value that indicates whether a 64-bit unsigned integer is less than or equal to a BigInteger value.

LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger)

Retourne une valeur qui indique si une valeur BigInteger est inférieure ou égale à une autre valeur BigInteger.Returns a value that indicates whether a BigInteger value is less than or equal to another BigInteger value.

LessThanOrEqual(BigInteger, UInt64) LessThanOrEqual(BigInteger, UInt64) LessThanOrEqual(BigInteger, UInt64) LessThanOrEqual(BigInteger, UInt64)

Retourne une valeur qui indique si une valeur BigInteger est inférieure ou égale à un entier 64 bits non signé.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit unsigned integer.

LessThanOrEqual(Int64, BigInteger) LessThanOrEqual(Int64, BigInteger) LessThanOrEqual(Int64, BigInteger) LessThanOrEqual(Int64, BigInteger)

Retourne une valeur qui indique si un entier 64 bits signé est inférieur ou égal à une valeur BigInteger.Returns a value that indicates whether a 64-bit signed integer is less than or equal to a BigInteger value.

LessThanOrEqual(BigInteger, Int64) LessThanOrEqual(BigInteger, Int64) LessThanOrEqual(BigInteger, Int64) LessThanOrEqual(BigInteger, Int64)

Retourne une valeur qui indique si une valeur BigInteger est inférieure ou égale à un entier 64 bits signé.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit signed integer.

Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger)

Retourne le modulo de la division de deux valeurs BigInteger spécifiques.Returns the remainder that results from division with two specified BigInteger values.

Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger)

Multiplie deux valeurs BigInteger spécifiées.Multiplies two specified BigInteger values.

OnesComplement(BigInteger) OnesComplement(BigInteger) OnesComplement(BigInteger) OnesComplement(BigInteger)

Retourne le complément à un au niveau du bit d'une valeur BigInteger.Returns the bitwise one's complement of a BigInteger value.

RightShift(BigInteger, Int32) RightShift(BigInteger, Int32) RightShift(BigInteger, Int32) RightShift(BigInteger, Int32)

Décale une valeur BigInteger d’un certain nombre de bits vers la droite.Shifts a BigInteger value a specified number of bits to the right.

Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger)

Soustrait une valeur BigInteger d'une autre valeur BigInteger.Subtracts a BigInteger value from another BigInteger value.

UnaryNegation(BigInteger) UnaryNegation(BigInteger) UnaryNegation(BigInteger) UnaryNegation(BigInteger)

Rend négative la valeur BigInteger spécifiée.Negates a specified BigInteger value.

UnaryPlus(BigInteger) UnaryPlus(BigInteger) UnaryPlus(BigInteger) UnaryPlus(BigInteger)

Retourne la valeur de l'opérande BigInteger.Returns the value of the BigInteger operand. (Le signe de l’opérande est inchangé.)(The sign of the operand is unchanged.)

Implémentations d’interfaces explicites

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)

S’applique à