BigInteger Estructura

Definición

Espacio de nombres:

System.Numerics

Ensamblado:

System.Runtime.Numerics.dll

Representa un entero con signo arbitrariamente grande.

public value class BigInteger : IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IParsable<System::Numerics::BigInteger>, ISpanParsable<System::Numerics::BigInteger>, IUtf8SpanParsable<System::Numerics::BigInteger>, System::Numerics::IAdditionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IAdditiveIdentity<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IBinaryInteger<System::Numerics::BigInteger>, System::Numerics::IBinaryNumber<System::Numerics::BigInteger>, System::Numerics::IBitwiseOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IComparisonOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, bool>, System::Numerics::IDecrementOperators<System::Numerics::BigInteger>, System::Numerics::IDivisionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IEqualityOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, bool>, System::Numerics::IIncrementOperators<System::Numerics::BigInteger>, System::Numerics::IModulusOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IMultiplicativeIdentity<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IMultiplyOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::INumber<System::Numerics::BigInteger>, System::Numerics::INumberBase<System::Numerics::BigInteger>, System::Numerics::IShiftOperators<System::Numerics::BigInteger, int, System::Numerics::BigInteger>, System::Numerics::ISignedNumber<System::Numerics::BigInteger>, System::Numerics::ISubtractionOperators<System::Numerics::BigInteger, System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IUnaryNegationOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>, System::Numerics::IUnaryPlusOperators<System::Numerics::BigInteger, System::Numerics::BigInteger>

public readonly struct BigInteger : IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IParsable<System.Numerics.BigInteger>, ISpanParsable<System.Numerics.BigInteger>, IUtf8SpanParsable<System.Numerics.BigInteger>, System.Numerics.IAdditionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IAdditiveIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IBinaryInteger<System.Numerics.BigInteger>, System.Numerics.IBinaryNumber<System.Numerics.BigInteger>, System.Numerics.IBitwiseOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IComparisonOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,bool>, System.Numerics.IDecrementOperators<System.Numerics.BigInteger>, System.Numerics.IDivisionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IEqualityOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,bool>, System.Numerics.IIncrementOperators<System.Numerics.BigInteger>, System.Numerics.IModulusOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IMultiplicativeIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IMultiplyOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.INumber<System.Numerics.BigInteger>, System.Numerics.INumberBase<System.Numerics.BigInteger>, System.Numerics.IShiftOperators<System.Numerics.BigInteger,int,System.Numerics.BigInteger>, System.Numerics.ISignedNumber<System.Numerics.BigInteger>, System.Numerics.ISubtractionOperators<System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IUnaryNegationOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>, System.Numerics.IUnaryPlusOperators<System.Numerics.BigInteger,System.Numerics.BigInteger>

type BigInteger = struct
    interface IFormattable
    interface IParsable<BigInteger>
    interface ISpanFormattable
    interface ISpanParsable<BigInteger>
    interface IAdditionOperators<BigInteger, BigInteger, BigInteger>
    interface IAdditiveIdentity<BigInteger, BigInteger>
    interface IBinaryInteger<BigInteger>
    interface IBinaryNumber<BigInteger>
    interface IBitwiseOperators<BigInteger, BigInteger, BigInteger>
    interface IComparisonOperators<BigInteger, BigInteger, bool>
    interface IEqualityOperators<BigInteger, BigInteger, bool>
    interface IDecrementOperators<BigInteger>
    interface IDivisionOperators<BigInteger, BigInteger, BigInteger>
    interface IIncrementOperators<BigInteger>
    interface IModulusOperators<BigInteger, BigInteger, BigInteger>
    interface IMultiplicativeIdentity<BigInteger, BigInteger>
    interface IMultiplyOperators<BigInteger, BigInteger, BigInteger>
    interface INumber<BigInteger>
    interface INumberBase<BigInteger>
    interface ISubtractionOperators<BigInteger, BigInteger, BigInteger>
    interface IUnaryNegationOperators<BigInteger, BigInteger>
    interface IUnaryPlusOperators<BigInteger, BigInteger>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<BigInteger>
    interface IShiftOperators<BigInteger, int, BigInteger>
    interface ISignedNumber<BigInteger>

Public Structure BigInteger
Implements IAdditionOperators(Of BigInteger, BigInteger, BigInteger), IAdditiveIdentity(Of BigInteger, BigInteger), IBinaryInteger(Of BigInteger), IBinaryNumber(Of BigInteger), IBitwiseOperators(Of BigInteger, BigInteger, BigInteger), IComparable(Of BigInteger), IComparisonOperators(Of BigInteger, BigInteger, Boolean), IDecrementOperators(Of BigInteger), IDivisionOperators(Of BigInteger, BigInteger, BigInteger), IEqualityOperators(Of BigInteger, BigInteger, Boolean), IEquatable(Of BigInteger), IIncrementOperators(Of BigInteger), IModulusOperators(Of BigInteger, BigInteger, BigInteger), IMultiplicativeIdentity(Of BigInteger, BigInteger), IMultiplyOperators(Of BigInteger, BigInteger, BigInteger), INumber(Of BigInteger), INumberBase(Of BigInteger), IParsable(Of BigInteger), IShiftOperators(Of BigInteger, Integer, BigInteger), ISignedNumber(Of BigInteger), ISpanParsable(Of BigInteger), ISubtractionOperators(Of BigInteger, BigInteger, BigInteger), IUnaryNegationOperators(Of BigInteger, BigInteger), IUnaryPlusOperators(Of BigInteger, BigInteger), IUtf8SpanParsable(Of BigInteger)

Herencia

Object

ValueType

BigInteger

Implementaciones

IComparable IComparable<BigInteger> IEquatable<BigInteger> IFormattable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<BigInteger> IParsable<TSelf> ISpanParsable<BigInteger> ISpanParsable<TSelf> IAdditionOperators<BigInteger,BigInteger,BigInteger> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<BigInteger,BigInteger> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<BigInteger> IBinaryNumber<BigInteger> IBinaryNumber<TSelf> IBitwiseOperators<BigInteger,BigInteger,BigInteger> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<BigInteger,BigInteger,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<BigInteger> IDecrementOperators<TSelf> IDivisionOperators<BigInteger,BigInteger,BigInteger> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<BigInteger,BigInteger,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<BigInteger> IIncrementOperators<TSelf> IModulusOperators<BigInteger,BigInteger,BigInteger> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<BigInteger,BigInteger> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<BigInteger,BigInteger,BigInteger> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<BigInteger> INumber<TSelf> INumberBase<BigInteger> INumberBase<TSelf> IShiftOperators<BigInteger,Int32,BigInteger> IShiftOperators<TSelf,Int32,TSelf> ISignedNumber<BigInteger> ISubtractionOperators<BigInteger,BigInteger,BigInteger> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<BigInteger,BigInteger> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<BigInteger,BigInteger> IUnaryPlusOperators<TSelf,TSelf> IUtf8SpanFormattable IUtf8SpanParsable<BigInteger> IUtf8SpanParsable<TSelf>

Comentarios

El BigInteger tipo es un tipo inmutable que representa un entero arbitrariamente grande cuyo valor en teoría no tiene límites superiores o inferiores. Los miembros del BigInteger tipo son paralelos estrechamente a los de otros tipos enteros (los Bytetipos , Int16, SByteInt64UInt16Int32UInt32y ).UInt64 Este tipo difiere de los otros tipos enteros de .NET Framework, que tienen un intervalo indicado por sus MinValue propiedades y MaxValue .

Nota:

Dado que el BigInteger tipo es inmutable (vea Mutability and the BigInteger Structure) y porque no tiene límites superiores o inferiores, se puede iniciar para OutOfMemoryException cualquier operación que haga que un BigInteger valor crezca demasiado grande.

Creación de instancias de un objeto BigInteger

Puede crear instancias de un BigInteger objeto de varias maneras:

• Puede usar la new palabra clave y proporcionar cualquier valor entero o de punto flotante como parámetro al BigInteger constructor. (Los valores de punto flotante se truncan antes de asignarlos a ). BigInteger En el ejemplo siguiente se muestra cómo usar la new palabra clave para crear instancias BigInteger de valores.

  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
  

• Puede declarar una BigInteger variable y asignarle un valor igual que cualquier tipo numérico, siempre que ese valor sea un tipo entero. En el ejemplo siguiente se usa la asignación para crear un BigInteger valor a partir de .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
  

• Puede asignar un valor decimal o de punto flotante a un BigInteger objeto si convierte el valor o lo convierte primero. En el ejemplo siguiente se convierten explícitamente (en C#) o se convierte (en Visual Basic) y Double un Decimal valor 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
  

  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
  

Estos métodos permiten crear instancias de un BigInteger objeto cuyo valor se encuentra en el intervalo de uno de los tipos numéricos existentes únicamente. Puede crear instancias de un BigInteger objeto cuyo valor puede superar el intervalo de los tipos numéricos existentes de una de estas tres maneras:

• Puede usar la new palabra clave y proporcionar una matriz de bytes de cualquier tamaño al BigInteger.BigInteger constructor. Por ejemplo:

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

• Puede llamar a los Parse métodos o TryParse para convertir la representación de cadena de un número en .BigInteger Por ejemplo:

  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
  

• Puede llamar a un static método (Shared en Visual Basic) BigInteger que realiza alguna operación en una expresión numérica y devuelve un resultado calculado BigInteger . En el ejemplo siguiente se hace esto mediante el cubing UInt64.MaxValue y la asignación del resultado 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
  

El valor no inicializado de es BigIntegerZero.

Realización de operaciones en valores bigInteger

Puede usar una BigInteger instancia como usaría cualquier otro tipo entero. BigInteger sobrecarga los operadores numéricos estándar para permitirle realizar operaciones matemáticas básicas como suma, resta, división, multiplicación y negación unaria. También puede usar los operadores numéricos estándar para comparar dos BigInteger valores entre sí. Al igual que los otros tipos enteros, BigInteger también admite los operadores bit a Andbit , Or, XOr, desplazamiento a la izquierda y desplazamiento a la derecha. En el caso de los lenguajes que no admiten operadores personalizados, la BigInteger estructura también proporciona métodos equivalentes para realizar operaciones matemáticas. Entre ellos se incluyen Add, DivideMultiply, Negate, , Subtracty varios otros.

Muchos miembros de la BigInteger estructura corresponden directamente a los miembros de los otros tipos enteros. Además, BigInteger agrega miembros como los siguientes:

• Sign, que devuelve un valor que indica el signo de un BigInteger valor.

• Abs, que devuelve el valor absoluto de un BigInteger valor .

• DivRem, que devuelve el cociente y el resto de una operación de división.

• GreatestCommonDivisor, que devuelve el divisor común más grande de dos BigInteger valores.

Muchos de estos miembros adicionales corresponden a los miembros de la Math clase , que proporciona la funcionalidad para trabajar con los tipos numéricos primitivos.

Mutabilidad y estructura bigInteger

En el ejemplo siguiente se crea una instancia de un BigInteger objeto y, a continuación, se incrementa su valor en uno.

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)

Aunque este ejemplo parece modificar el valor del objeto existente, este no es el caso. BigInteger Los objetos son inmutables, lo que significa que, internamente, Common Language Runtime realmente crea un nuevo BigInteger objeto y lo asigna un valor uno mayor que su valor anterior. A continuación, este nuevo objeto se devuelve al autor de la llamada.

Nota

Los otros tipos numéricos de .NET también son inmutables. Sin embargo, dado que el BigInteger tipo no tiene límites superiores o inferiores, sus valores pueden crecer extremadamente grandes y tener un impacto medible en el rendimiento.

Aunque este proceso es transparente para el autor de la llamada, se produce una penalización de rendimiento. En algunos casos, especialmente cuando se realizan operaciones repetidas en un bucle en valores muy grandes BigInteger , esa penalización de rendimiento puede ser significativa. Por ejemplo, en el ejemplo siguiente, una operación se realiza repetidamente hasta un millón de veces y un BigInteger valor se incrementa en uno cada vez que la operación se realiza correctamente.

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

En tal caso, puede mejorar el rendimiento realizando todas las asignaciones intermedias en una Int32 variable. A continuación, el valor final de la variable se puede asignar al BigInteger objeto cuando se cierra el bucle. Esto se muestra en el ejemplo siguiente.

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

Trabajar con matrices de bytes y cadenas hexadecimales

Si convierte BigInteger valores en matrices de bytes o si convierte matrices BigInteger de bytes en valores, debe tener en cuenta el orden de los bytes. La BigInteger estructura espera que los bytes individuales de una matriz de bytes aparezcan en orden little-endian (es decir, los bytes de orden inferior del valor preceden a los bytes de orden superior). Puede realizar un recorrido de ida y vuelta de un BigInteger valor llamando al ToByteArray método y pasando la matriz de bytes resultante al BigInteger(Byte[]) constructor, como se muestra en el ejemplo siguiente.

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

Para crear una instancia de un BigInteger valor de una matriz de bytes que representa un valor de algún otro tipo entero, puede pasar el valor entero al BitConverter.GetBytes método y, a continuación, pasar la matriz de bytes resultante al BigInteger(Byte[]) constructor. En el ejemplo siguiente se crea una instancia de un BigInteger valor de una matriz de bytes que representa un Int16 valor.

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 estructura supone que los valores negativos se almacenan mediante la representación complementaria de dos. Dado que la BigInteger estructura representa un valor numérico sin longitud fija, el BigInteger(Byte[]) constructor siempre interpreta el bit más significativo del último byte de la matriz como un bit de signo. Para evitar que el BigInteger(Byte[]) constructor confunda la representación complementaria de dos de un valor negativo con la representación de signo y magnitud de un valor positivo, los valores positivos en los que el bit más significativo del último byte de la matriz de bytes se establecería normalmente debe incluir un byte adicional cuyo valor es 0. Por ejemplo, 0xC0 0xBD 0xF0 0xFF es la representación hexadecimal little-endian de -1.000.000 o 4.293.967.296. Dado que el bit más significativo del último byte de esta matriz está activado, el constructor interpretaría el valor de la BigInteger(Byte[]) matriz de bytes como -1000 000. Para crear una instancia de un BigInteger cuyo valor es positivo, se debe pasar a un constructor una matriz de bytes cuyos elementos están 0xC0 0xBD 0xF0 0xFF 0x00. Esto se ilustra en el siguiente ejemplo:

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

Las matrices de bytes creadas por el ToByteArray método a partir de valores positivos incluyen este byte de valor cero adicional. Por lo tanto, la BigInteger estructura puede asignarlos correctamente a valores de ida y vuelta y, a continuación, restaurarlos desde matrices de bytes, como se muestra en el ejemplo siguiente.

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

Sin embargo, es posible que tenga que agregar este byte de valor cero adicional a matrices de bytes creadas dinámicamente por el desarrollador o que devuelven métodos que convierten enteros sin signo en matrices de bytes (como BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32)y BitConverter.GetBytes(UInt64)).

Al analizar una cadena hexadecimal, los BigInteger.Parse(String, NumberStyles) métodos y BigInteger.Parse(String, NumberStyles, IFormatProvider) asumen que si se establece el bit más significativo del primer byte de la cadena, o si el primer dígito hexadecimal de la cadena representa los cuatro bits inferiores de un valor de byte, el valor se representa mediante la representación complementaria de dos. Por ejemplo, "FF01" y "F01" representan el valor decimal -255. Para diferenciar los valores positivos de los negativos, los valores positivos deben incluir un cero inicial. Las sobrecargas pertinentes del ToString método, cuando se pasan la cadena de formato "X", agregan un cero inicial a la cadena hexadecimal devuelta para los valores positivos. Esto permite realizar un recorrido BigInteger de ida y vuelta mediante los ToString métodos y Parse , como se muestra en el ejemplo siguiente.

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.

Sin embargo, las cadenas hexadecimales creadas mediante una llamada a los ToString métodos de los otros tipos enteros o las sobrecargas del ToString método que incluyen un toBase parámetro no indican el signo del valor o el tipo de datos de origen del que se deriva la cadena hexadecimal. La creación correcta de una instancia de un BigInteger valor de esta cadena requiere cierta lógica adicional. En el ejemplo siguiente se proporciona una posible implementación.

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.

Constructores

BigInteger(Byte[])	Inicializa una nueva instancia de la estructura BigInteger utilizando los valores de una matriz de bytes.
BigInteger(Decimal)	Inicializa una nueva instancia de la estructura BigInteger utilizando un valor Decimal.
BigInteger(Double)	Inicializa una nueva instancia de la estructura BigInteger utilizando un valor de punto flotante de precisión doble.
BigInteger(Int32)	Inicializa una nueva instancia de la estructura BigInteger usando un valor entero de 32 bits con signo.
BigInteger(Int64)	Inicializa una nueva instancia de la estructura BigInteger usando un valor entero de 64 bits con signo.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	Inicializa una nueva instancia de la estructura BigInteger mediante los valores de un intervalo de solo lectura de bytes y, de forma opcional, indica la codificación de firma y el orden de bytes endianness.
BigInteger(Single)	Inicializa una nueva instancia de la estructura BigInteger utilizando un valor de punto flotante de precisión sencilla.
BigInteger(UInt32)	Inicializa una nueva instancia de la estructura BigInteger utilizando un valor entero de 32 bits sin signo.
BigInteger(UInt64)	Inicializa una nueva instancia de la estructura BigInteger con un valor entero de 64 bits sin signo.

Propiedades

IsEven	Indica si el valor del objeto BigInteger actual es un número par.
IsOne	Indica si el valor del objeto BigInteger actual es One.
IsPowerOfTwo	Indica si el valor del objeto BigInteger actual es una potencia de dos.
IsZero	Indica si el valor del objeto BigInteger actual es Zero.
MinusOne	Obtiene un valor que representa menos uno (-1).
One	Obtiene un valor que representa el número uno (1).
Sign	Obtiene un número que indica el signo (negativo, positivo o cero) del objeto BigInteger actual.
Zero	Obtiene un valor que representa el número 0 (cero).

Métodos

Abs(BigInteger)	Obtiene el valor absoluto de un objeto BigInteger.
Add(BigInteger, BigInteger)	Suma dos valores BigInteger y devuelve el resultado.
Clamp(BigInteger, BigInteger, BigInteger)	Sujeta un valor a un valor mínimo inclusivo y máximo.
Compare(BigInteger, BigInteger)	Compara dos valores BigInteger y devuelve un entero que indica si el primer valor es menor, igual o mayor que el segundo.
CompareTo(BigInteger)	Compara esta instancia con un segundo BigInteger y devuelve un entero que indica si el valor de esta instancia es menor, igual o mayor que el valor del objeto especificado.
CompareTo(Int64)	Compara esta instancia con un entero de 64 bits con signo y devuelve un entero que indica si el valor de esta instancia es menor, igual o mayor que el valor del entero de 64 bits con signo.
CompareTo(Object)	Compara esta instancia con un objeto especificado y devuelve un entero que indica si el valor de esta instancia es mayor, igual o menor que el valor del objeto especificado.
CompareTo(UInt64)	Compara esta instancia con un entero de 64 bits sin signo y devuelve un entero que indica si el valor de esta instancia es menor, igual o mayor que el valor del entero de 64 bits sin signo.
CopySign(BigInteger, BigInteger)	Copia el signo de un valor en el signo de otro valor.
CreateChecked<TOther>(TOther)	Crea una instancia del tipo actual a partir de un valor, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo representable del tipo actual.
CreateSaturating<TOther>(TOther)	Crea una instancia del tipo actual a partir de un valor, saturando los valores que se encuentran fuera del intervalo representable del tipo actual.
CreateTruncating<TOther>(TOther)	Crea una instancia del tipo actual a partir de un valor, truncando los valores que se encuentran fuera del intervalo representable del tipo actual.
Divide(BigInteger, BigInteger)	Divide un valor BigInteger por otro y devuelve el resultado.
DivRem(BigInteger, BigInteger)	Calcula el cociente y el resto de dos valores.
DivRem(BigInteger, BigInteger, BigInteger)	Divide un valor BigInteger por otro, devuelve el resultado y devuelve el resto en un parámetro de salida.
Equals(BigInteger)	Devuelve un valor que indica si la instancia actual y un objeto BigInteger especificado tienen el mismo valor.
Equals(Int64)	Devuelve un valor que indica si la instancia actual y un entero de 64 bits con signo tienen el mismo valor.
Equals(Object)	Devuelve un valor que indica si la instancia actual y un objeto especificado tienen el mismo valor.
Equals(UInt64)	Devuelve un valor que indica si la instancia actual y un entero de 64 bits sin signo tienen el mismo valor.
GetBitLength()	Obtiene el número de bits necesarios para la representación de complemento más corta de dos de la instancia actual sin el bit de signo.
GetByteCount(Boolean)	Obtiene el número de bytes que ToByteArray(Boolean, Boolean) y TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) van a generar.
GetHashCode()	Devuelve el código hash del objeto BigInteger actual.
GreatestCommonDivisor(BigInteger, BigInteger)	Busca el máximo común divisor de dos valores BigInteger.
IsEvenInteger(BigInteger)	Determina si un valor representa un número entero par.
IsNegative(BigInteger)	Determina si un valor es negativo.
IsOddInteger(BigInteger)	Determina si un valor representa un número entero impar.
IsPositive(BigInteger)	Determina si un valor es positivo.
IsPow2(BigInteger)	Determina si un valor es una potencia de dos.
LeadingZeroCount(BigInteger)	Calcula el número de ceros iniciales en un valor.
Log(BigInteger)	Devuelve el logaritmo natural (en base e) de un número especificado.
Log(BigInteger, Double)	Devuelve el logaritmo de un número especificado en una base determinada.
Log10(BigInteger)	Devuelve el logaritmo en base 10 de un número especificado.
Log2(BigInteger)	Calcula el registro2 de un valor.
Max(BigInteger, BigInteger)	Devuelve el mayor de dos valores BigInteger.
MaxMagnitude(BigInteger, BigInteger)	Compara dos valores con el proceso, que es mayor.
Min(BigInteger, BigInteger)	Devuelve el menor de dos valores BigInteger.
MinMagnitude(BigInteger, BigInteger)	Compara dos valores con el proceso, que es menor.
ModPow(BigInteger, BigInteger, BigInteger)	Realiza una división de módulo en un número elevado a la potencia de otro número.
Multiply(BigInteger, BigInteger)	Devuelve el producto de dos valores BigInteger.
Negate(BigInteger)	Crea el negativo de un valor BigInteger especificado.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analiza un intervalo de caracteres en un valor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convierte la representación de un número, incluida en el intervalo de solo lectura especificado de caracteres, en un estilo especificado en su equivalente BigInteger.
Parse(String)	Convierte la representación en forma de cadena de un número en su BigInteger equivalente.
Parse(String, IFormatProvider)	Convierte la representación en forma de cadena de un número con el formato específico de la referencia cultural indicada en su BigInteger equivalente.
Parse(String, NumberStyles)	Convierte la representación de cadena de un número con un estilo especificado en su BigInteger equivalente.
Parse(String, NumberStyles, IFormatProvider)	Convierte la representación de cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en su equivalente de BigInteger.
PopCount(BigInteger)	Calcula el número de bits establecidos en un valor.
Pow(BigInteger, Int32)	Eleva un valor BigInteger a la potencia del valor especificado.
Remainder(BigInteger, BigInteger)	Realiza la división entera en dos valores BigInteger y devuelve el resto.
RotateLeft(BigInteger, Int32)	Gira un valor a la izquierda por una cantidad determinada.
RotateRight(BigInteger, Int32)	Gira un valor a la derecha por una cantidad determinada.
Subtract(BigInteger, BigInteger)	Resta un valor BigInteger de otro y devuelve el resultado.
ToByteArray()	Convierte un valor BigInteger en una matriz de bytes.
ToByteArray(Boolean, Boolean)	Devuelve el valor de este objeto BigInteger como una matriz de bytes usando el menor número de bytes posible. Si el valor es cero, devuelve una matriz de un byte cuyo elemento es 0x00.
ToString()	Convierte el valor numérico del objeto BigInteger actual en su representación de cadena equivalente.
ToString(IFormatProvider)	Convierte el valor numérico del objeto BigInteger actual en su representación de cadena equivalente usando la información de formato específica de la referencia cultural indicada.
ToString(String)	Convierte el valor numérico del objeto BigInteger actual en su representación de cadena equivalente con el formato especificado.
ToString(String, IFormatProvider)	Convierte el valor numérico del objeto BigInteger actual en su representación de cadena equivalente usando el formato especificado y la información de formato específica de la referencia cultural.
TrailingZeroCount(BigInteger)	Calcula el número de ceros finales en un valor.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Aplica formato de intervalo de caracteres a esta instancia de entero grande.
TryParse(ReadOnlySpan<Char>, BigInteger)	Intenta convertir la representación de un número incluido en el intervalo de caracteres de solo lectura especificado en su equivalente BigInteger y devuelve un valor que indica si la conversión se ha realizado correctamente.
TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)	Intenta analizar un intervalo de caracteres en un valor.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)	Intenta convertir la representación en forma de cadena de un número en su equivalente BigInteger y devuelve un valor que indica si la conversión tuvo éxito.
TryParse(String, BigInteger)	Intenta convertir la representación en forma de cadena de un número en su equivalente BigInteger y devuelve un valor que indica si la conversión tuvo éxito.
TryParse(String, IFormatProvider, BigInteger)	Intenta analizar una cadena en un valor.
TryParse(String, NumberStyles, IFormatProvider, BigInteger)	Intenta convertir la representación de cadena de un número con un estilo específico y un formato específico de la referencia cultural en su equivalente de BigInteger y devuelve un valor que indica si la conversión fue correcta.
TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)	Copia el valor de este objeto BigInteger como bytes de complemento a dos little endian usando el menor número de bytes posible. Si el valor es cero, se genera un byte cuyo elemento es 0x00.

Operadores

Addition(BigInteger, BigInteger)	Suma los valores de dos objetos BigInteger especificados.
BitwiseAnd(BigInteger, BigInteger)	Realiza una operación And bit a bit en dos valores BigInteger.
BitwiseOr(BigInteger, BigInteger)	Realiza una operación Or bit a bit en dos valores BigInteger.
Decrement(BigInteger)	Disminuye un valor BigInteger en 1.
Division(BigInteger, BigInteger)	Divide un valor BigInteger especificado por otro valor BigInteger indicado utilizando división de enteros.
Equality(BigInteger, BigInteger)	Devuelve un valor que indica si los valores de dos objetos BigInteger son iguales.
Equality(BigInteger, Int64)	Devuelve un valor que indica si un valor BigInteger y un valor entero long con signo son iguales.
Equality(BigInteger, UInt64)	Devuelve un valor que indica si un valor BigInteger y un valor entero long sin signo son iguales.
Equality(Int64, BigInteger)	Devuelve un valor que indica si un valor entero long con signo y un valor BigInteger son iguales.
Equality(UInt64, BigInteger)	Devuelve un valor que indica si un valor entero long sin signo y un valor BigInteger son iguales.
ExclusiveOr(BigInteger, BigInteger)	Realiza una operación exclusiva Or (XOr) bit a bit en dos valores BigInteger.
Explicit(BigInteger to Byte)	Define una conversión explícita de un objeto BigInteger en un valor de byte sin signo.
Explicit(BigInteger to Char)	Convierte explícitamente un entero grande en un Char valor.
Explicit(BigInteger to Decimal)	Define una conversión explícita de un objeto BigInteger en un valor Decimal.
Explicit(BigInteger to Double)	Define una conversión explícita de un objeto BigInteger en un valor Double.
Explicit(BigInteger to Half)	Convierte explícitamente un entero grande en un Half valor.
Explicit(BigInteger to Int128)	Convierte explícitamente un entero grande en un Int128 valor.
Explicit(BigInteger to Int16)	Define una conversión explícita de un objeto BigInteger en un valor entero de 16 bits con signo.
Explicit(BigInteger to Int32)	Define una conversión explícita de un objeto BigInteger en un valor entero de 32 bits con signo.
Explicit(BigInteger to Int64)	Define una conversión explícita de un objeto BigInteger en un valor entero de 64 bits con signo.
Explicit(BigInteger to IntPtr)	Convierte explícitamente un entero grande en un IntPtr valor.
Explicit(BigInteger to SByte)	Define una conversión explícita de un objeto BigInteger en un valor de 8 bits con signo. Esta API no es conforme a CLS. La alternativa conforme es Int16.
Explicit(BigInteger to Single)	Define una conversión explícita de un objeto BigInteger en un valor de punto flotante de precisión sencilla.
Explicit(BigInteger to UInt128)	Convierte explícitamente un entero grande en un UInt128 valor.
Explicit(BigInteger to UInt16)	Define una conversión explícita de un objeto BigInteger en un valor entero de 16 bits sin signo. Esta API no es conforme a CLS. La alternativa conforme es Int32.
Explicit(BigInteger to UInt32)	Define una conversión explícita de un objeto BigInteger en un valor entero de 32 bits sin signo. Esta API no es conforme a CLS. La alternativa conforme es Int64.
Explicit(BigInteger to UInt64)	Define una conversión explícita de un objeto BigInteger en un valor entero de 64 bits sin signo. Esta API no es conforme a CLS. La alternativa conforme es Double.
Explicit(BigInteger to UIntPtr)	Convierte explícitamente un entero grande en un UIntPtr valor.
Explicit(Complex to BigInteger)	Convierte explícitamente un Complex valor en un entero grande.
Explicit(Decimal to BigInteger)	Define una conversión explícita de un objeto Decimal en un valor BigInteger.
Explicit(Double to BigInteger)	Define una conversión explícita de un valor Double en un valor BigInteger.
Explicit(Half to BigInteger)	Convierte explícitamente un Half valor en un entero grande.
Explicit(Single to BigInteger)	Define una conversión explícita de un valor Single en un valor BigInteger.
GreaterThan(BigInteger, BigInteger)	Devuelve un valor que indica si un valor BigInteger es mayor que otro valor BigInteger.
GreaterThan(BigInteger, Int64)	Devuelve un valor que indica si un valor BigInteger es mayor que un valor entero de 64 bits con signo.
GreaterThan(BigInteger, UInt64)	Devuelve un valor que indica si un valor BigInteger es mayor que un entero de 64 bits sin signo.
GreaterThan(Int64, BigInteger)	Devuelve un valor que indica si un entero de 64 bits con signo es mayor que un valor BigInteger.
GreaterThan(UInt64, BigInteger)	Devuelve un valor que indica si un valor BigInteger es mayor que un entero de 64 bits sin signo.
GreaterThanOrEqual(BigInteger, BigInteger)	Devuelve un valor que indica si un valor BigInteger es mayor o igual que otro valor BigInteger.
GreaterThanOrEqual(BigInteger, Int64)	Devuelve un valor que indica si un valor BigInteger es mayor o igual que un valor entero de 64 bits con signo.
GreaterThanOrEqual(BigInteger, UInt64)	Devuelve un valor que indica si un valor BigInteger es mayor o igual que un valor entero de 64 bits sin signo.
GreaterThanOrEqual(Int64, BigInteger)	Devuelve un valor que indica si un entero de 64 bits con signo es mayor o igual que un valor BigInteger.
GreaterThanOrEqual(UInt64, BigInteger)	Devuelve un valor que indica si un entero de 64 bits sin signo es mayor o igual que un valor BigInteger.
Implicit(Byte to BigInteger)	Define una conversión implícita de un byte sin signo en un valor BigInteger.
Implicit(Char to BigInteger)	Convierte implícitamente un Char valor en un entero grande.
Implicit(Int128 to BigInteger)	Convierte implícitamente un Int128 valor en un entero grande.
Implicit(Int16 to BigInteger)	Define una conversión implícita de un entero de 16 bits con signo en un valor BigInteger.
Implicit(Int32 to BigInteger)	Define una conversión implícita de un entero de 32 bits con signo en un valor BigInteger.
Implicit(Int64 to BigInteger)	Define una conversión implícita de un entero de 64 bits con signo en un valor BigInteger.
Implicit(IntPtr to BigInteger)	Convierte implícitamente un IntPtr valor en un entero grande.
Implicit(SByte to BigInteger)	Define una conversión implícita de un entero de 8 bits con signo en un valor BigInteger. Esta API no es conforme a CLS. La alternativa conforme es BigInteger(Int32).
Implicit(UInt128 to BigInteger)	Convierte implícitamente un UInt128 valor en un entero grande.
Implicit(UInt16 to BigInteger)	Define una conversión implícita de un entero de 16 bits sin signo en un valor BigInteger. Esta API no es conforme a CLS. La alternativa conforme es Implicit(Int32 to BigInteger).
Implicit(UInt32 to BigInteger)	Define una conversión implícita de un entero de 32 bits sin signo en un valor BigInteger. Esta API no es conforme a CLS. La alternativa conforme es Implicit(Int64 to BigInteger).
Implicit(UInt64 to BigInteger)	Define una conversión implícita de un entero de 64 bits sin signo en un valor BigInteger. Esta API no es conforme a CLS. La alternativa conforme es Double.
Implicit(UIntPtr to BigInteger)	Convierte implícitamente un UIntPtr valor en un entero grande.
Increment(BigInteger)	Aumenta un valor BigInteger en 1.
Inequality(BigInteger, BigInteger)	Devuelve un valor que indica si dos objetos BigInteger tienen valores diferentes.
Inequality(BigInteger, Int64)	Devuelve un valor que indica si un valor BigInteger y un valor de 64 bits con signo no son iguales.
Inequality(BigInteger, UInt64)	Devuelve un valor que indica si un valor BigInteger y un valor de 64 bits sin signo no son iguales.
Inequality(Int64, BigInteger)	Devuelve un valor que indica si un entero de 64 bits con signo y un valor BigInteger no son iguales.
Inequality(UInt64, BigInteger)	Devuelve un valor que indica si un entero de 64 bits sin signo y un valor BigInteger no son iguales.
LeftShift(BigInteger, Int32)	Desplaza un valor BigInteger un número especificado de bits a la izquierda.
LessThan(BigInteger, BigInteger)	Devuelve un valor que indica si un valor BigInteger es menor que otro valor BigInteger.
LessThan(BigInteger, Int64)	Devuelve un valor que indica si un valor BigInteger es menor que un entero de 64 bits con signo.
LessThan(BigInteger, UInt64)	Devuelve un valor que indica si un valor BigInteger es menor que un entero de 64 bits sin signo.
LessThan(Int64, BigInteger)	Devuelve un valor que indica si un entero de 64 bits con signo es menor que un valor BigInteger.
LessThan(UInt64, BigInteger)	Devuelve un valor que indica si un entero de 64 bits sin signo es menor que un valor BigInteger.
LessThanOrEqual(BigInteger, BigInteger)	Devuelve un valor que indica si un valor BigInteger es menor o igual que otro valor BigInteger.
LessThanOrEqual(BigInteger, Int64)	Devuelve un valor que indica si un valor BigInteger es menor o igual que un entero de 64 bits con signo.
LessThanOrEqual(BigInteger, UInt64)	Devuelve un valor que indica si un valor BigInteger es menor o igual que un entero de 64 bits sin signo.
LessThanOrEqual(Int64, BigInteger)	Devuelve un valor que indica si un entero de 64 bits con signo es menor o igual que un valor BigInteger.
LessThanOrEqual(UInt64, BigInteger)	Devuelve un valor que indica si un entero de 64 bits sin signo es menor o igual que un valor BigInteger.
Modulus(BigInteger, BigInteger)	Devuelve el resto que se obtiene al dividir dos valores BigInteger especificados.
Multiply(BigInteger, BigInteger)	Multiplica dos valores BigInteger especificados.
OnesComplement(BigInteger)	Devuelve el complemento de uno bit a bit de un valor BigInteger.
RightShift(BigInteger, Int32)	Desplaza un valor BigInteger un número especificado de bits a la derecha.
Subtraction(BigInteger, BigInteger)	Resta un valor BigInteger de otro valor BigInteger.
UnaryNegation(BigInteger)	Crea el negativo de un valor BigInteger especificado.
UnaryPlus(BigInteger)	Devuelve el valor del operando BigInteger. (El signo del operando no cambia).
UnsignedRightShift(BigInteger, Int32)	Desplaza un valor a la derecha por una cantidad determinada.

Implementaciones de interfaz explícitas

IAdditiveIdentity<BigInteger,BigInteger>.AdditiveIdentity	Obtiene la identidad de suma del tipo actual.
IBinaryInteger<BigInteger>.GetByteCount()	Obtiene el número de bytes que se escribirán como parte de TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<BigInteger>.GetShortestBitLength()	Obtiene la longitud, en bits, de la representación complementaria de dos más corta del valor actual.
IBinaryInteger<BigInteger>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, BigInteger)	Representa un entero con signo arbitrariamente grande.
IBinaryInteger<BigInteger>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, BigInteger)	Representa un entero con signo arbitrariamente grande.
IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<Byte>, Int32)	Intenta escribir el valor actual, en formato big-endian, en un intervalo determinado.
IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<Byte>, Int32)	Intenta escribir el valor actual, en formato little-endian, en un intervalo determinado.
IBinaryNumber<BigInteger>.AllBitsSet	Obtiene una instancia del tipo binario en el que se establecen todos los bits.
IMultiplicativeIdentity<BigInteger,BigInteger>.MultiplicativeIdentity	Obtiene la identidad multiplicativa del tipo actual.
INumber<BigInteger>.MaxNumber(BigInteger, BigInteger)	Compara dos valores con el proceso, que es mayor y devuelve el otro valor si una entrada es NaN.
INumber<BigInteger>.MinNumber(BigInteger, BigInteger)	Compara dos valores con el proceso que es menor y devuelve el otro valor si una entrada es NaN.
INumber<BigInteger>.Sign(BigInteger)	Calcula el signo de un valor.
INumberBase<BigInteger>.IsCanonical(BigInteger)	Determina si un valor está en su representación canónica.
INumberBase<BigInteger>.IsComplexNumber(BigInteger)	Determina si un valor representa un número complejo.
INumberBase<BigInteger>.IsFinite(BigInteger)	Determina si un valor es finito.
INumberBase<BigInteger>.IsImaginaryNumber(BigInteger)	Determina si un valor representa un número imaginario puro.
INumberBase<BigInteger>.IsInfinity(BigInteger)	Determina si un valor es infinito.
INumberBase<BigInteger>.IsInteger(BigInteger)	Determina si un valor representa un número entero.
INumberBase<BigInteger>.IsNaN(BigInteger)	Determina si un valor es NaN.
INumberBase<BigInteger>.IsNegativeInfinity(BigInteger)	Determina si un valor es infinito negativo.
INumberBase<BigInteger>.IsNormal(BigInteger)	Determina si un valor es normal.
INumberBase<BigInteger>.IsPositiveInfinity(BigInteger)	Determina si un valor es infinito positivo.
INumberBase<BigInteger>.IsRealNumber(BigInteger)	Determina si un valor representa un número real.
INumberBase<BigInteger>.IsSubnormal(BigInteger)	Determina si un valor es subnormal.
INumberBase<BigInteger>.IsZero(BigInteger)	Determina si un valor es cero.
INumberBase<BigInteger>.MaxMagnitudeNumber(BigInteger, BigInteger)	Compara dos valores con el proceso que tiene la magnitud mayor y devuelve el otro valor si una entrada es NaN.
INumberBase<BigInteger>.MinMagnitudeNumber(BigInteger, BigInteger)	Compara dos valores con el proceso que tiene la magnitud menor y devuelve el otro valor si una entrada es NaN.
INumberBase<BigInteger>.Radix	Obtiene la raíz, o base, para el tipo.
INumberBase<BigInteger>.TryConvertFromChecked<TOther>(TOther, BigInteger)	Representa un entero con signo arbitrariamente grande.
INumberBase<BigInteger>.TryConvertFromSaturating<TOther>(TOther, BigInteger)	Representa un entero con signo arbitrariamente grande.
INumberBase<BigInteger>.TryConvertFromTruncating<TOther>(TOther, BigInteger)	Representa un entero con signo arbitrariamente grande.
INumberBase<BigInteger>.TryConvertToChecked<TOther>(BigInteger, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo representable del tipo actual.
INumberBase<BigInteger>.TryConvertToSaturating<TOther>(BigInteger, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, saturando los valores que se encuentran fuera del intervalo representable del tipo actual.
INumberBase<BigInteger>.TryConvertToTruncating<TOther>(BigInteger, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, truncando los valores que se encuentran fuera del intervalo representable del tipo actual.
ISignedNumber<BigInteger>.NegativeOne	Obtiene el valor -1 del tipo.