BigInteger, structure

Vous pouvez instancier un objet BigInteger de plusieurs façons :

• Vous pouvez utiliser le mot clé new et fournir n'importe quelle valeur intégrale ou à virgule flottante comme paramètre au constructeur BigInteger. (Les valeurs à virgule flottante sont tronquées avant qu'elles soient assignées au BigInteger.) L'exemple suivant illustre comment utiliser le mot clé new pour instancier des valeurs BigInteger.

  C#

  VB

  Copier

  
  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		
  
  
  

• Vous pouvez déclarer une variable BigInteger et lui assigner une valeur tout comme n'importe quel type numérique, tant que cette valeur est de type intégral. L'exemple suivant utilise une assignation pour créer une valeur BigInteger à partir d'un Int64.

  C#

  VB

  Copier

  
  long longValue = 6315489358112;      
  BigInteger assignedFromLong = longValue;
  Console.WriteLine(assignedFromLong);
  // The example displays the following output:
  //   6315489358112
  
  
  

• Vous pouvez assigner une valeur décimale ou à virgule flottante à un objet BigInteger si vous effectuez un cast sur la valeur ou la convertissez en premier lieu. L'exemple suivant caste (en C#) ou convertit (en Visual Basic) explicitement une valeur Double et Decimal en BigInteger.

  C#

  VB

  Copier

  
  BigInteger assignedFromDouble = (BigInteger) 179032.6541;
  Console.WriteLine(assignedFromDouble);   
  BigInteger assignedFromDecimal = (BigInteger) 64312.65m;      
  Console.WriteLine(assignedFromDecimal);
  // The example displays the following output:
  //   179032
  //   64312      
  
  
  

Ces méthodes vous permettent d'instancier un objet BigInteger dont la valeur est comprise dans la plage de l'un des types numériques existants. Vous pouvez instancier un objet BigInteger dont la valeur peut dépasser la plage des types numériques existants de l'une de trois façons suivantes :

• Vous pouvez utiliser le mot clé new et fournir un tableau d'octets de n'importe quelle taille au constructeur BigInteger.BigInteger. Ce constructeur peut être utilisé pour créer une valeur BigInteger positive uniquement. Par exemple :

  C#

  VB

  Copier

  
  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).
  
  
  

• Vous pouvez appeler les méthodes Parse ou TryParse pour convertir la représentation sous forme de chaîne d'un nombre en un BigInteger. Par exemple :

  C#

  VB

  Copier

  
  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
  
  
  

• Vous pouvez appeler une méthode static (Shared dans Visual Basic) BigInteger qui effectue certaines opérations sur une expression numérique et retourne un résultat BigInteger calculé. Pour ce faire, l'exemple suivant cube UInt64.MaxValue et assigne le résultat à BigInteger.

  C#

  VB

  Copier

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

La valeur non initialisée de BigInteger est Zero.

Vous pouvez utiliser une instance BigInteger comme vous utiliseriez tout autre type intégral. BigInteger surcharge les opérateurs numériques standard pour vous permettre d'exécuter 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. Vous pouvez également utiliser les opérateurs numériques standard pour comparer deux valeurs BigInteger. Comme les autres types intégraux, BigInteger prend en charge également les opérateurs de bit, de décalage vers la droite et de décalage vers la gauche And, Or et XOr. Pour les langages qui ne prennent pas en charge d'opérateurs personnalisés, la structure BigInteger fournit également des méthodes équivalentes pour l'exécution d'opérations mathématiques. Il peut s'agir, entre autres, de Add, Divide, Multiply, Negate et Subtract.

De nombreux membres de la structure BigInteger correspondent directement aux membres des autres types intégraux. De plus, BigInteger ajoute des membres tels que les suivants :

• Sign , qui retourne une valeur qui indique le signe d'une valeur BigInteger.

• Abs , qui retourne la valeur absolue d'une valeur BigInteger.

• DivRem , qui retourne à la fois le quotient et reste d'une opération de division.

• GreatestCommonDivisor , qui retourne le plus grand diviseur commun de deux valeurs BigInteger.

Beaucoup de ces membres supplémentaires correspondent aux membres de la classe Math, qui fournit des fonctionnalités permettant d'utiliser les types numériques de base.

L'exemple suivant instancie un objet BigInteger, puis incrémente sa valeur d'une unité.

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

Bien que cet exemple semble modifier la valeur de l'objet existant, ce n'est pas le cas. Les objets BigInteger sont immuables, ce qui signifie qu'en interne, le common language runtime crée un objet BigInteger et lui assigne une valeur supérieure de un à sa valeur précédente. Puis ce nouvel objet est retourné à l'appelant.

Remarque
Les autres types numériques du .NET Framework sont également immuables. Toutefois, étant donné que le type BigInteger n'a pas de limites supérieures ou inférieures, ses valeurs peuvent considérablement augmenter et avoir un impact mesurable sur la performance.

Bien que ce processus soit transparent pour l'appelant, il entraîne une altération des performances. Dans certains cas, surtout lorsque des opérations répétées sont exécutées une boucle sur des valeurs BigInteger très grandes, cette altération des performances peut être significative. Par exemple, dans l'exemple suivant, une opération est exécutée répétitivement jusqu'à un million de fois, et une valeur BigInteger est incrémentée de un chaque fois que l'opération réussit.

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++;
}

Dans un tel cas, vous pouvez améliorer les performances en exécutant toutes les assignations intermédiaires à une variable Int32. La dernière valeur de la variable peut ensuite être assignée à l'objet BigInteger lorsque la boucle s'arrête. L'exemple suivant illustre cette situation.

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;

Si vous convertissez des valeurs BigInteger en tableaux d'octets, ou si vous convertissez des tableaux d'octets en valeurs BigInteger, vous devez considérer l'ordre des octets. La structure BigInteger s'attend à ce que les octets individuels dans un tableau d'octets apparaissent dans l'ordre avec primauté des octets de poids faible (little-endian) ; autrement dit, les octets d'ordre inférieur de la valeur précèdent les octets d'ordre plus élevé. Vous pouvez effectuer un aller-retour sur une valeur BigInteger en appelant la méthode ToByteArray, puis en passant le tableau d'octets résultant au constructeur BigInteger(Byte[]), comme dans l'exemple suivant.

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

Pour instancier une valeur BigInteger d'un tableau d'octets qui représente une valeur de quelque autre type intégral, vous pouvez passer la valeur intégrale à la méthode BitConverter.GetBytes, puis passer le tableau d'octets résultant au constructeur BigInteger(Byte[]). L'exemple suivant instancie une valeur BigInteger d'un tableau d'octets qui représente une valeur Int16.

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

La structure BigInteger suppose que des valeurs de négative sont stockées à l'aide de la représentation du complément à deux. Étant donné que la structure BigInteger représente une valeur numérique sans longueur fixe, le constructeur BigInteger(Byte[]) interprète toujours le bit le plus significatif du dernier octet dans le tableau comme un bit de signe. Pour empêcher le constructeur BigInteger(Byte[]) de confondre la représentation du complément à deux d'une valeur négative avec le signe et représentation de grandeur d'une valeur positive, les valeurs positives dans lesquelles le bit le plus significatif du dernier octet dans le tableau d'octets serait défini ordinairement doivent inclure un octet supplémentaire dont la valeur est 0. Par exemple, 0xC0 0xBD 0xF0 0xFF est la représentation hexadécimale avec primauté des octets de poids faible (little-endian) de -1,000,000 ou de 4,293,967,296. Étant donné que le bit le plus significatif du dernier octet dans ce tableau est activé, la valeur du tableau d'octets serait interprétée par le constructeur BigInteger(Byte[]) comme -1,000,000. Pour instancier un BigInteger dont la valeur est positive, un tableau d'octets dont les éléments sont des 0xC0 0xBD 0xF0 0xFF 0x00 doit être passé au constructeur. L'exemple suivant illustre ce comportement.

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      

Les tableaux d'octets créés par la méthode ToByteArray à partir des valeurs positives incluent cet octet de valeur zéro supplémentaire. Par conséquent, la structure BigInteger peut effectuer des allers-retours de valeurs en les assignant puis en les restaurant aux tableaux d'octets, comme le montre l'exemple suivant.

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

Toutefois, vous devrez peut-être ajouter cet octet de valeur zéro supplémentaire aux tableaux d'octets créés dynamiquement par le développeur ou qui sont retournés par les méthodes qui convertissent des entiers non signés en tableaux d'octets (telles que BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32) et BitConverter.GetBytes(UInt64)).

Lors de l'analyse d'une chaîne hexadécimale, les méthodes BigInteger.Parse(String, NumberStyles) et BigInteger.Parse(String, NumberStyles, IFormatProvider) supposent que si le bit le plus significatif du premier octet dans 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ée à l'aide de la représentation du complément à deux. Par exemple, « FF01 » et « F01 » représentent tous les deux la valeur décimale -255. Pour différencier les valeurs positives des valeurs négatives, les valeurs positives doivent inclure un zéro non significatif. Les surcharges appropriées de la méthode ToString, lorsque la chaîne de format "X" leur est passée, ajoutent un zéro non significatif à la chaîne hexadécimale retournée pour les valeurs positives. Cela permet d'effectuer des allers-retours de valeurs BigInteger à l'aide des méthodes ToString et Parse, comme le montre l'exemple suivant.

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.

Toutefois, les chaînes hexadécimales créées en appelant les méthodes ToString des autres types intégraux ou des surcharges de la méthode ToString qui inclue un paramètre toBase n'indiquent pas le signe de la valeur ou le type des données sources desquelles elles sont dérivées. L'instanciation avec succès une valeur BigInteger d'une telle chaîne requiert une logique supplémentaire. L'exemple suivant présente une implémentation possible.

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.