Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction manuelle. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte.
Traduction
Source

BigInteger, structure

Représente un entier signé arbitrairement grand.

Espace de noms :  System.Numerics
Assembly :  System.Numerics (dans System.Numerics.dll)

[SerializableAttribute]
public struct BigInteger : IFormattable, 
	IComparable, IComparable<BigInteger>, IEquatable<BigInteger>

Le type BigInteger expose les membres suivants.

  NomDescription
Méthode publiqueBigInteger(Byte[])Initialise une nouvelle instance de la structure BigInteger à l'aide des valeurs d'un tableau d'octets.
Méthode publiqueBigInteger(Decimal)Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur Decimal.
Méthode publiqueBigInteger(Double)Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur à virgule flottante double précision.
Méthode publiqueBigInteger(Int32)Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur entière signée 32 bits.
Méthode publiqueBigInteger(Int64)Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur entière signée 64 bits.
Méthode publiqueBigInteger(Single)Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur à virgule flottante simple précision.
Méthode publiqueBigInteger(UInt32)Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur entière32 bits non signée.
Méthode publiqueBigInteger(UInt64)Initialise une nouvelle instance de la structure BigInteger à l'aide d'une valeur entière 64 bits non signée.
Début

  NomDescription
Propriété publiqueIsEvenIndique si la valeur de l'objet BigInteger actif est un nombre pair.
Propriété publiqueIsOneIndique si la valeur de l'objet BigInteger actif est BigInteger.One.
Propriété publiqueIsPowerOfTwoIndique si la valeur de l'objet BigInteger actif est une puissance de deux.
Propriété publiqueIsZeroIndique si la valeur de l'objet BigInteger actif est BigInteger.Zero.
Propriété publiqueMembre statiqueMinusOneObtient une valeur qui représente le nombre moins un (-1).
Propriété publiqueMembre statiqueOneObtient une valeur qui représente le nombre un (1).
Propriété publiqueSignObtient un nombre qui indique le signe (négatif, positif ou zéro) de l'objet BigInteger actif.
Propriété publiqueMembre statiqueZeroObtient une valeur qui représente le nombre 0 (zéro).
Début

  NomDescription
Méthode publiqueMembre statiqueAbsObtient la valeur absolue d'un objet BigInteger.
Méthode publiqueMembre statiqueAddAjoute deux valeurs BigInteger et retourne le résultat.
Méthode publiqueMembre statiqueCompareCompare deux valeurs BigInteger et retourne un entier qui indique si la première valeur est inférieure, égale ou supérieure à la seconde valeur.
Méthode publiqueCompareTo(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é.
Méthode publiqueCompareTo(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é.
Méthode publiqueCompareTo(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é.
Méthode publiqueCompareTo(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é.
Méthode publiqueMembre statiqueDivideDivise une valeur BigInteger par une autre et retourne le résultat.
Méthode publiqueMembre statiqueDivRemDivise une valeur BigInteger par une autre, retourne le résultat, puis retourne le modulo dans un paramètre de sortie.
Méthode publiqueEquals(BigInteger)Retourne une valeur qui indique si l'instance actuelle et un objet BigInteger spécifié ont la même valeur.
Méthode publiqueEquals(Int64)Retourne une valeur qui indique si l'instance actuelle et un entier 64 bits signé ont la même valeur.
Méthode publiqueEquals(Object)Retourne une valeur qui indique si l'instance actuelle et un objet spécifié ont la même valeur. (Substitue ValueType.Equals(Object).)
Méthode publiqueEquals(UInt64)Retourne une valeur qui indique si l'instance actuelle et un entier 64 bits non signé ont la même valeur.
Méthode protégéeFinalize Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)
Méthode publiqueGetHashCodeRetourne le code de hachage pour l'objet BigInteger actif. (Substitue ValueType.GetHashCode().)
Méthode publiqueGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiqueMembre statiqueGreatestCommonDivisorRecherche le plus grand commun diviseur de deux valeurs BigInteger.
Méthode publiqueMembre statiqueLog(BigInteger)Retourne le logarithme naturel (base e) d'un nombre spécifié.
Méthode publiqueMembre statiqueLog(BigInteger, Double)Retourne le logarithme d'un nombre spécifié dans une base spécifiée.
Méthode publiqueMembre statiqueLog10Retourne le logarithme de base 10 d'un nombre spécifié.
Méthode publiqueMembre statiqueMaxRetourne la plus grande des deux valeurs BigInteger.
Méthode protégéeMemberwiseCloneCrée une copie superficielle de l'objet Object actif. (Hérité de Object.)
Méthode publiqueMembre statiqueMinRetourne la plus petite des deux valeurs BigInteger.
Méthode publiqueMembre statiqueModPowEffectue une division avec modulo sur un nombre élevé à la puissance d'un autre nombre.
Méthode publiqueMembre statiqueMultiplyRetourne le produit de deux valeurs BigInteger.
Méthode publiqueMembre statiqueNegateRend négative la valeur BigInteger spécifiée.
Méthode publiqueMembre statiqueParse(String)Convertit la représentation sous forme de chaîne d'un nombre en sa représentation BigInteger équivalente.
Méthode publiqueMembre statiqueParse(String, NumberStyles)Convertit la représentation sous forme de chaîne d'un nombre dans le style spécifié en sa représentation BigInteger équivalente.
Méthode publiqueMembre statiqueParse(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.
Méthode publiqueMembre statiqueParse(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.
Méthode publiqueMembre statiquePowÉlève une valeur BigInteger à la puissance de la valeur spécifiée.
Méthode publiqueMembre statiqueRemainder Effectue une division entière sur deux valeurs BigInteger et retourne le reste.
Méthode publiqueMembre statiqueSubtractSoustrait une valeur BigInteger d'une autre valeur et retourne le résultat.
Méthode publiqueToByteArrayConvertit une valeur BigInteger en tableau d'octets.
Méthode publiqueToString()Convertit la valeur numérique de l'objet en cours BigInteger en sa représentation chaîne équivalente. (Substitue ValueType.ToString().)
Méthode publiqueToString(IFormatProvider)Convertit la valeur numérique de l'objet BigInteger actif en sa représentation sous forme de chaîne équivalente à l'aide des informations de mise en forme spécifiques à la culture.
Méthode publiqueToString(String)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é.
Méthode publiqueToString(String, IFormatProvider)Convertit la valeur numérique de l'objet BigInteger actif 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.
Méthode publiqueMembre statiqueTryParse(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.
Méthode publiqueMembre statiqueTryParse(String, NumberStyles, IFormatProvider, BigInteger)Essaie de convertir la représentation sous forme de chaîne d'un nombre ayant le style spécifié et une mise en forme spécifique à la culture en son équivalent BigInteger, puis retourne une valeur indiquant si la conversion a réussi.
Début

  NomDescription
Opérateur publicMembre statiqueAdditionAjoute les valeurs des deux objets BigInteger spécifiés.
Opérateur publicMembre statiqueBitwiseAndEffectue une opération de bits And sur deux valeurs BigInteger.
Opérateur publicMembre statiqueBitwiseOrEffectue une opération de bits Or sur deux valeurs BigInteger.
Opérateur publicMembre statiqueDecrementDécrémente une valeur BigInteger de 1.
Opérateur publicMembre statiqueDivisionDivise une valeur BigInteger spécifique par une autre valeur BigInteger spécifique à l'aide d'une division entière.
Opérateur publicMembre statiqueEquality(BigInteger, Int64)Retourne une valeur qui indique si la valeur BigInteger et la valeur d'un entier long signé sont égales.
Opérateur publicMembre statiqueEquality(BigInteger, BigInteger)Retourne une valeur qui indique si les valeurs de deux objets BigInteger sont égales.
Opérateur publicMembre statiqueEquality(BigInteger, UInt64)Retourne une valeur qui indique si la valeur BigInteger et la valeur d'un entier long non signé sont égales.
Opérateur publicMembre statiqueEquality(Int64, BigInteger)Retourne une valeur qui indique si la valeur d'un entier long signé et la valeur BigInteger sont égales.
Opérateur publicMembre statiqueEquality(UInt64, BigInteger)Retourne une valeur qui indique si la valeur d'un entier long non signé et la valeur BigInteger sont égales.
Opérateur publicMembre statiqueExclusiveOrEffectue une opération de bits Or (XOr) exclusive sur deux valeurs BigInteger.
Opérateur publicMembre statiqueExplicit(BigInteger to Byte)Définit une conversion explicite d'un objet BigInteger en valeur d'octet non signée.
Opérateur publicMembre statiqueExplicit(BigInteger to Int32)Définit une conversion explicite d'un objet BigInteger en valeur entière signée 32 bits.
Opérateur publicMembre statiqueExplicit(BigInteger to UInt64)Définit une conversion explicite d'un objet BigInteger en valeur entière 64 bits non signée.
Opérateur publicMembre statiqueExplicit(BigInteger to Single)Définit une conversion explicite d'un objet BigInteger en valeur à virgule flottante simple précision.
Opérateur publicMembre statiqueExplicit(BigInteger to Double)Définit une conversion explicite d'un objet BigInteger en valeur Double.
Opérateur publicMembre statiqueExplicit(BigInteger to Int64)Définit une conversion explicite d'un objet BigInteger en valeur entière signée 64 bits.
Opérateur publicMembre statiqueExplicit(BigInteger to Int16)Définit une conversion explicite d'un objet BigInteger en valeur entière signée 16 bits.
Opérateur publicMembre statiqueExplicit(BigInteger to SByte)Définit une conversion explicite d'un objet BigInteger en valeur 8 bits signée.
Opérateur publicMembre statiqueExplicit(BigInteger to UInt32)Définit une conversion explicite d'un objet BigInteger en valeur entière 32 bits non signée.
Opérateur publicMembre statiqueExplicit(BigInteger to UInt16)Définit une conversion explicite d'un objet BigInteger en valeur entière 16 bits non signée.
Opérateur publicMembre statiqueExplicit(BigInteger to Decimal)Définit une conversion explicite d'un objet BigInteger en valeur Decimal.
Opérateur publicMembre statiqueExplicit(Decimal to BigInteger)Définit une conversion explicite d'un objet Decimal en valeur BigInteger.
Opérateur publicMembre statiqueExplicit(Double to BigInteger)Définit une conversion explicite d'une valeur Double en valeur BigInteger.
Opérateur publicMembre statiqueExplicit(Single to BigInteger)Définit une conversion explicite d'un objet Single en valeur BigInteger.
Opérateur publicMembre statiqueGreaterThan(BigInteger, Int64)Retourne une valeur qui indique si BigInteger est supérieur à une valeur entière signée 64 bits.
Opérateur publicMembre statiqueGreaterThan(BigInteger, BigInteger)Retourne une valeur qui indique si une valeur BigInteger est supérieure à une autre valeur BigInteger.
Opérateur publicMembre statiqueGreaterThan(BigInteger, UInt64)Retourne une valeur qui indique si une valeur BigInteger est supérieure à un entier non signé 64 bits.
Opérateur publicMembre statiqueGreaterThan(Int64, BigInteger)Retourne une valeur qui indique si un entier signé 64 bits est supérieur à une valeur BigInteger.
Opérateur publicMembre statiqueGreaterThan(UInt64, BigInteger)Retourne une valeur qui indique si une valeur BigInteger est supérieure à un entier non signé 64 bits.
Opérateur publicMembre statiqueGreaterThanOrEqual(BigInteger, Int64)Retourne une valeur qui indique si une valeur BigInteger est supérieure ou égale à une valeur entière signée 64 bits.
Opérateur publicMembre statiqueGreaterThanOrEqual(BigInteger, BigInteger)Retourne une valeur qui indique si une valeur BigInteger est supérieure ou égale à une autre valeur BigInteger.
Opérateur publicMembre statiqueGreaterThanOrEqual(BigInteger, UInt64)Retourne une valeur qui indique si une valeur BigInteger est supérieure ou égale à une valeur entière non signée 64 bits.
Opérateur publicMembre statiqueGreaterThanOrEqual(Int64, BigInteger)Retourne une valeur qui indique si un entier signé 64 bits est supérieur ou égal à une valeur BigInteger.
Opérateur publicMembre statiqueGreaterThanOrEqual(UInt64, BigInteger)Retourne une valeur qui indique si un entier non signé 64 bits est supérieur ou égal à une valeur BigInteger.
Opérateur publicMembre statiqueImplicit(Byte to BigInteger)Définit une conversion implicite d'un octet non signé en valeur BigInteger.
Opérateur publicMembre statiqueImplicit(Int16 to BigInteger)Définit une conversion implicite d'un entier 16 bits signé en valeur BigInteger.
Opérateur publicMembre statiqueImplicit(Int32 to BigInteger)Définit une conversion implicite d'un entier 32 bits signé en valeur BigInteger.
Opérateur publicMembre statiqueImplicit(Int64 to BigInteger)Définit une conversion implicite d'un entier 64 bits signé en valeur BigInteger.
Opérateur publicMembre statiqueImplicit(SByte to BigInteger)Définit une conversion implicite d'un entier signé 8 bits en valeur BigInteger.
Opérateur publicMembre statiqueImplicit(UInt16 to BigInteger)Définit une conversion implicite d'un entier non signé 16 bits en valeur BigInteger.
Opérateur publicMembre statiqueImplicit(UInt32 to BigInteger)Définit une conversion implicite d'un entier non signé 32 bits en valeur BigInteger.
Opérateur publicMembre statiqueImplicit(UInt64 to BigInteger)Définit une conversion implicite d'un entier non signé 64 bits en valeur BigInteger.
Opérateur publicMembre statiqueIncrementIncrémente une valeur BigInteger de 1.
Opérateur publicMembre statiqueInequality(BigInteger, Int64)Retourne une valeur qui indique si une valeur BigInteger et un entier signé 64 bits ne sont pas égaux.
Opérateur publicMembre statiqueInequality(BigInteger, BigInteger)Retourne une valeur qui indique si deux objets BigInteger ont des valeurs différentes.
Opérateur publicMembre statiqueInequality(BigInteger, UInt64)Retourne une valeur qui indique si une valeur BigInteger et un entier non signé 64 bits ne sont pas égaux.
Opérateur publicMembre statiqueInequality(Int64, BigInteger)Retourne une valeur qui indique si un entier signé 64 bits et une valeur BigInteger ne sont pas égaux.
Opérateur publicMembre statiqueInequality(UInt64, BigInteger)Retourne une valeur qui indique si un entier non signé 64 bits et une valeur BigInteger ne sont pas égaux.
Opérateur publicMembre statiqueLeftShiftDécale une valeur BigInteger d'un certain nombre de bits vers la gauche.
Opérateur publicMembre statiqueLessThan(BigInteger, Int64)Retourne une valeur qui indique si une valeur BigInteger est inférieure à un entier signé 64 bits.
Opérateur publicMembre statiqueLessThan(BigInteger, BigInteger)Retourne une valeur qui indique si une valeur BigInteger est inférieure à une autre valeur BigInteger.
Opérateur publicMembre statiqueLessThan(BigInteger, UInt64)Retourne une valeur qui indique si une valeur BigInteger est inférieure à un entier non signé 64 bits.
Opérateur publicMembre statiqueLessThan(Int64, BigInteger)Retourne une valeur qui indique si un entier signé 64 bits est inférieur à une valeur BigInteger.
Opérateur publicMembre statiqueLessThan(UInt64, BigInteger)Retourne une valeur qui indique si un entier non signé 64 bits est inférieur à une valeur BigInteger.
Opérateur publicMembre statiqueLessThanOrEqual(BigInteger, Int64)Retourne une valeur qui indique si une valeur BigInteger est inférieure ou égale à un entier signé 64 bits.
Opérateur publicMembre statiqueLessThanOrEqual(BigInteger, BigInteger)Retourne une valeur qui indique si une valeur BigInteger est inférieure ou égale à une autre valeur BigInteger.
Opérateur publicMembre statiqueLessThanOrEqual(BigInteger, UInt64)Retourne une valeur qui indique si une valeur BigInteger est inférieure ou égale à un entier non signé 64 bits.
Opérateur publicMembre statiqueLessThanOrEqual(Int64, BigInteger)Retourne une valeur qui indique si un entier signé 64 bits est inférieur ou égal à une valeur BigInteger.
Opérateur publicMembre statiqueLessThanOrEqual(UInt64, BigInteger)Retourne une valeur qui indique si un entier non signé 64 bits est inférieur ou égal à une valeur BigInteger.
Opérateur publicMembre statiqueModulusRetourne le modulo de la division de deux valeurs BigInteger spécifiques.
Opérateur publicMembre statiqueMultiplyMultiplie deux valeurs BigInteger spécifiées.
Opérateur publicMembre statiqueOnesComplementRetourne le complément à un au niveau du bit d'une valeur BigInteger.
Opérateur publicMembre statiqueRightShiftDécale une valeur BigInteger d'un certain nombre de bits vers la droite.
Opérateur publicMembre statiqueSubtractionSoustrait une valeur BigInteger d'une autre valeur BigInteger.
Opérateur publicMembre statiqueUnaryNegationRend négative la valeur BigInteger spécifiée.
Opérateur publicMembre statiqueUnaryPlusRetourne la valeur de l'opérande BigInteger. (Le signe de l'opérande est inchangé.)
Début

Le type BigInteger est un type immuable qui représente un entier arbitrairement grand dont la valeur, en théorie, n'a pas de limites supérieures ou inférieures. Les membres du type BigInteger correspondent étroitement à ceux d'autres types intégraux (types Byte, Int16, Int32, Int64, SByte, UInt16, UInt32 et UInt64). Ce type diffère des autres types intégraux dans .NET Framework, qui ont une plage indiquée par leurs propriétés MinValue et MaxValue.

RemarqueRemarque

Parce que le type BigInteger est immuable (consultez Mutabilité et structure BigInteger) et étant donné qu'il n'a pas de limites supérieures ou inférieures, un OutOfMemoryException peut être levé pour toute opération qui ferait qu'une valeur BigInteger devient trop grande.

Instanciation d'un objet BigInteger

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.

    
    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.

    
    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.

    
    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 :

    
    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 :

    
    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.

    
    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.

Exécution d'opérations sur des valeurs BigInteger

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.

Mutabilité et structure BigInteger

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.

RemarqueRemarque

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;


Utilisation de tableaux d'octets et de chaînes hexadécimales

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.


.NET Framework

Pris en charge dans : 4

.NET Framework Client Profile

Pris en charge dans : 4

Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft