BigInteger Estrutura

Referência

Definição

Namespace:: System.Numerics

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa um inteiro com sinal arbitrariamente grande.

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IFormattable

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, ISpanFormattable

public value class BigInteger : IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IParsable<System::Numerics::BigInteger>, ISpanParsable<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>, 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>, 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, 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 struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable

public readonly struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable

public readonly struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, ISpanFormattable

public readonly struct BigInteger : IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IParsable<System.Numerics.BigInteger>, ISpanParsable<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>, 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>, 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,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>

[System.Serializable]
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable

type BigInteger = struct
    interface IFormattable

type BigInteger = struct
    interface ISpanFormattable
    interface IFormattable

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>
    interface IEqualityOperators<BigInteger, BigInteger>
    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 IShiftOperators<BigInteger, BigInteger>
    interface ISignedNumber<BigInteger>

[<System.Serializable>]
type BigInteger = struct
    interface IFormattable

Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable

Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), ISpanFormattable

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), IDecrementOperators(Of BigInteger), IDivisionOperators(Of BigInteger, BigInteger, BigInteger), IEqualityOperators(Of BigInteger, BigInteger), 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, BigInteger), ISignedNumber(Of BigInteger), ISpanParsable(Of BigInteger), ISubtractionOperators(Of BigInteger, BigInteger, BigInteger), IUnaryNegationOperators(Of BigInteger, BigInteger), IUnaryPlusOperators(Of BigInteger, BigInteger)

Herança: Object

ValueType
BigInteger

Atributos: SerializableAttribute

Implementações: IComparable IComparable<BigInteger> IEquatable<BigInteger> IFormattable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> 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> System.Numerics.IComparisonOperators<BigInteger,BigInteger> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<BigInteger> IDecrementOperators<TSelf> IDivisionOperators<BigInteger,BigInteger,BigInteger> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<BigInteger,BigInteger> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> 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> System.Numerics.IShiftOperators<BigInteger,BigInteger> System.Numerics.IShiftOperators<TSelf,TSelf> ISignedNumber<BigInteger> ISubtractionOperators<BigInteger,BigInteger,BigInteger> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<BigInteger,BigInteger> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<BigInteger,BigInteger> IUnaryPlusOperators<TSelf,TSelf>

Comentários

O BigInteger tipo é um tipo imutável que representa um inteiro arbitrariamente grande cujo valor em teoria não tem limites superiores ou inferiores. Os membros do BigInteger tipo são muito paralelos aos de outros tipos integrais (os Bytetipos, , Int16, Int32, Int64, SByte, UInt16 UInt32e UInt64 tipos). Esse tipo difere dos outros tipos integrais no .NET Framework, que têm um intervalo indicado por suas MinValue propriedades e MaxValue propriedades.

Observação

Como o BigInteger tipo é imutável (consulte Mutability e a Estrutura BigInteger) e, como ele não tem limites superiores ou inferiores, pode OutOfMemoryException ser gerado para qualquer operação que faz com que um BigInteger valor cresça muito grande.

Criando uma instância de um objeto BigInteger

Você pode criar uma instância de um BigInteger objeto de várias maneiras:

Você pode usar a new palavra-chave e fornecer qualquer valor integral ou de ponto flutuante como um parâmetro para o BigInteger construtor. (Os valores de ponto flutuante são truncados antes de serem atribuídos ao BigInteger.) O exemplo a seguir ilustra como usar a new palavra-chave para instanciar BigInteger 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

Você pode declarar uma BigInteger variável e atribuir um valor da mesma forma que faria com qualquer tipo numérico, desde que esse valor seja um tipo integral. O exemplo a seguir usa a atribuição para criar um BigInteger valor de um 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

Você pode atribuir um valor decimal ou de ponto flutuante a um BigInteger objeto se converter o valor ou convertê-lo primeiro. O exemplo a seguir converte explicitamente (em C#) ou converte (no Visual Basic) um Double e um Decimal valor em um 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

Esses métodos permitem criar uma instância de um BigInteger objeto cujo valor está no intervalo de apenas um dos tipos numéricos existentes. Você pode criar uma instância de um BigInteger objeto cujo valor pode exceder o intervalo dos tipos numéricos existentes de uma das três maneiras:

Você pode usar a new palavra-chave e fornecer uma matriz de bytes de qualquer tamanho para o BigInteger.BigInteger construtor. Por exemplo:

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

Você pode chamar os Parse métodos ou TryParse para converter a representação de cadeia de caracteres de um número em um BigInteger. Por exemplo:

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

Você pode chamar um static método (Shared no Visual Basic) BigInteger que executa alguma operação em uma expressão numérica e retorna um resultado calculado BigInteger . O exemplo a seguir faz isso ao criar um cubo UInt64.MaxValue e atribuir o resultado a um 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

O valor não inicializado de a BigInteger é Zero.

Realizando operações em valores BigInteger

Você pode usar uma BigInteger instância como usaria qualquer outro tipo integral. BigInteger sobrecarrega os operadores numéricos padrão para permitir que você execute operações matemáticas básicas, como adição, subtração, divisão, multiplicação e negação unária. Você também pode usar os operadores numéricos padrão para comparar dois BigInteger valores entre si. Assim como os outros tipos integrais, BigInteger também dá suporte aos operadores bit a bit And, Or, XOrde deslocamento para a esquerda e de deslocamento para a direita. Para idiomas que não dão suporte a operadores personalizados, a BigInteger estrutura também fornece métodos equivalentes para executar operações matemáticas. Elas incluem Add, Divide, Multiply, Negatee Subtractvárias outras.

Muitos membros da BigInteger estrutura correspondem diretamente aos membros dos outros tipos integrais. Além disso, BigInteger adiciona membros como o seguinte:

Sign, que retorna um valor que indica o sinal de um BigInteger valor.
Abs, que retorna o valor absoluto de um BigInteger valor.
DivRem, que retorna o quociente e o restante de uma operação de divisão.
GreatestCommonDivisor, que retorna o maior divisor comum de dois BigInteger valores.

Muitos desses membros adicionais correspondem aos membros da classe, que Math fornece a funcionalidade para trabalhar com os tipos numéricos primitivos.

Mutabilidade e a estrutura de BigInteger

O exemplo a seguir cria uma instância de um BigInteger objeto e incrementa seu valor por um.

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)

Embora este exemplo pareça modificar o valor do objeto existente, esse não é o caso. BigInteger os objetos são imutáveis, o que significa que, internamente, o common language runtime realmente cria um novo BigInteger objeto e atribui a ele um valor maior que seu valor anterior. Em seguida, esse novo objeto é retornado ao chamador.

Observação

Os outros tipos numéricos no .NET também são imutáveis. No entanto, como o BigInteger tipo não tem limites superiores ou inferiores, seus valores podem crescer muito e ter um impacto mensurável no desempenho.

Embora esse processo seja transparente para o chamador, ele incorre em uma penalidade de desempenho. Em alguns casos, especialmente quando operações repetidas são executadas em um loop em valores muito grandes BigInteger , essa penalidade de desempenho pode ser significativa. Por exemplo, no exemplo a seguir, uma operação é executada repetidamente até um milhão de vezes e um BigInteger valor é incrementado por um sempre que a operação é bem-sucedida.

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

Nesse caso, você pode melhorar o desempenho executando todas as atribuições intermediárias para uma Int32 variável. O valor final da variável pode ser atribuído ao BigInteger objeto quando o loop é encerrado. O exemplo a seguir ilustra esse cenário.

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

Trabalhando com matrizes de bytes e cadeias de caracteres hexadecimais

Se você converter BigInteger valores em matrizes de bytes ou converter matrizes de bytes em BigInteger valores, deverá considerar a ordem dos bytes. A BigInteger estrutura espera que os bytes individuais em uma matriz de bytes apareçam em ordem little-endian (ou seja, os bytes de ordem inferior do valor precedem os bytes de ordem mais alta). Você pode fazer uma viagem de ida e volta de um BigInteger valor chamando o ToByteArray método e passando a matriz de bytes resultante para o BigInteger(Byte[]) construtor, como mostra o exemplo a seguir.

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 criar uma instância de um BigInteger valor de uma matriz de bytes que representa um valor de algum outro tipo integral, você pode passar o valor integral para o BitConverter.GetBytes método e, em seguida, passar a matriz de bytes resultante para o BigInteger(Byte[]) construtor. O exemplo a seguir cria uma instância de um BigInteger valor de uma matriz de bytes que representa um 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

A BigInteger estrutura pressupõe que os valores negativos sejam armazenados usando a representação complementar de dois. Como a BigInteger estrutura representa um valor numérico sem comprimento fixo, o BigInteger(Byte[]) construtor sempre interpreta o bit mais significativo do último byte na matriz como um bit de sinal. Para evitar que o BigInteger(Byte[]) construtor confunda a representação complementar dos dois de um valor negativo com o sinal e a representação de magnitude de um valor positivo, os valores positivos nos quais o bit mais significativo do último byte na matriz de bytes normalmente seria definido devem incluir um byte adicional cujo valor é 0. Por exemplo, 0xC0 0xBD 0xF0 0xFF é a representação hexadecimal de little-endian de -1.000.000 ou 4.293.967.296. Como o bit mais significativo do último byte nessa matriz está ativado, o valor da matriz de bytes seria interpretado pelo BigInteger(Byte[]) construtor como -1.000.000. Para criar uma BigInteger instância cujo valor é positivo, uma matriz de bytes cujos elementos são 0xC0 0xBD 0xF0 0xFF 0x00 deve ser passada para o construtor. O exemplo a seguir ilustra isto.

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

As matrizes de bytes criadas pelo método a ToByteArray partir de valores positivos incluem esse byte extra de valor zero. Portanto, a BigInteger estrutura pode obter valores de ida e volta com êxito atribuindo-os e, em seguida, restaurando-os de matrizes de bytes, como mostra o exemplo a seguir.

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

No entanto, talvez seja necessário adicionar esse byte de valor zero adicional a matrizes de bytes que são criadas dinamicamente pelo desenvolvedor ou que são retornadas por métodos que convertem inteiros não assinados em matrizes de bytes (como BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32)e BitConverter.GetBytes(UInt64)).

Ao analisar uma cadeia de caracteres hexadecimal, os métodos e BigInteger.Parse(String, NumberStyles, IFormatProvider) os BigInteger.Parse(String, NumberStyles) métodos pressupõem que, se o bit mais significativo do primeiro byte na cadeia de caracteres for definido ou se o primeiro dígito hexadecimal da cadeia de caracteres representar os quatro bits inferiores de um valor de byte, o valor será representado usando a representação complementar de dois. Por exemplo, "FF01" e "F01" representam o valor decimal -255. Para diferenciar o positivo de valores negativos, os valores positivos devem incluir um zero à esquerda. As sobrecargas relevantes do ToString método, quando são passadas a cadeia de caracteres de formato "X", adicionam um zero à cadeia de caracteres hexadecimal retornada para valores positivos. Isso possibilita valores de ida e volta BigInteger usando os métodos e Parse os ToString métodos, como mostra o exemplo a seguir.

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.

No entanto, as cadeias de caracteres hexadecimal criadas chamando os ToString métodos dos outros tipos integrais ou as sobrecargas do ToString método que incluem um toBase parâmetro não indicam o sinal do valor ou o tipo de dados de origem do qual a cadeia de caracteres hexadecimal foi derivada. Criar uma instância com êxito de um BigInteger valor dessa cadeia de caracteres requer alguma lógica adicional. O exemplo a seguir fornece uma implementação possível.

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.

Construtores

BigInteger(Byte[])	Inicializa uma nova instância da estrutura BigInteger usando os valores de uma matriz de bytes.
BigInteger(Decimal)	Inicializa uma nova instância da estrutura BigInteger usando um valor Decimal.
BigInteger(Double)	Inicializa uma nova instância de estrutura BigInteger usando um valor de ponto flutuante de precisão dupla.
BigInteger(Int32)	Inicializa uma nova instância da estrutura BigInteger usando um valor inteiro com sinal de 32 bits.
BigInteger(Int64)	Inicializa uma nova instância da estrutura BigInteger usando um valor inteiro com sinal de 64 bits.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	Inicializa uma nova instância da estrutura BigInteger usando os valores em um intervalo de bytes somente leitura e, opcionalmente, indicando a codificação de assinatura e a ordem de byte com endian.
BigInteger(Single)	Inicializa uma nova instância da estrutura BigInteger usando um valor de ponto flutuante de precisão simples.
BigInteger(UInt32)	Inicializa uma nova instância da estrutura BigInteger usando um valor inteiro de 32 bits sem sinal.
BigInteger(UInt64)	Inicializa uma nova instância da estrutura BigInteger com um valor inteiro de 64 bits sem sinal.

Propriedades

IsEven	Indica se o valor do objeto BigInteger atual é um número par.
IsOne	Indica se o valor do objeto BigInteger atual é One.
IsPowerOfTwo	Indica se o valor do objeto BigInteger atual é uma potência de dois.
IsZero	Indica se o valor do objeto BigInteger atual é Zero.
MinusOne	Obtém um valor que representa o número um negativo (-1).
One	Obtém um valor que representa o número um (1).
Sign	Obtém um número que indica o sinal (negativo, positivo ou zero) do objeto BigInteger atual.
Zero	Obtém um valor que representa o número 0 (zero).

Métodos

Abs(BigInteger)	Obtém o valor absoluto de um objeto BigInteger.
Add(BigInteger, BigInteger)	Adiciona dois valores de BigInteger e retorna o resultado.
Clamp(BigInteger, BigInteger, BigInteger)	Fixa um valor a um valor mínimo e máximo inclusivo.
Compare(BigInteger, BigInteger)	Compara dois valores BigInteger e retorna um inteiro que indica se o primeiro valor é menor que, igual a ou maior que o segundo valor.
CompareTo(BigInteger)	Compara esta instância a um segundo BigInteger e retorna um inteiro que indica se o valor desta instância é menor, igual ou maior que o valor do objeto especificado.
CompareTo(Int64)	Compara essa instância a um inteiro com sinal de 64 bits e retorna um inteiro que indica se o valor dessa instância é menor, igual ou maior que o valor do inteiro com sinal de 64 bits.
CompareTo(Object)	Compara esta instância a um objeto especificado e retorna um inteiro que indica se o valor desta instância é menor, igual ou maior que o valor do objeto especificado.
CompareTo(UInt64)	Compara essa instância a um inteiro sem sinal de 64 bits e retorna um inteiro que indica se o valor dessa instância é menor, igual ou maior que o valor do inteiro sem sinal de 64 bits.
CopySign(BigInteger, BigInteger)	Copia o sinal de um valor para o sinal de outro valor.
Divide(BigInteger, BigInteger)	Divide um valor BigInteger em outro e retorna o resultado.
DivRem(BigInteger, BigInteger)	Calcula o quociente e o restante de dois valores.
DivRem(BigInteger, BigInteger, BigInteger)	Divide um valor BigInteger por outro, retorna o resultado e retorna o restante em um parâmetro de saída.
Equals(BigInteger)	Retorna um valor que indica se a instância atual e um objeto BigInteger especificado têm o mesmo valor.
Equals(Int64)	Retorna um valor que indica se a instância atual e um inteiro com sinal de 64 bits têm o mesmo valor.
Equals(Object)	Retorna um valor que indica se a instância atual e um objeto especificado têm o mesmo valor.
Equals(UInt64)	Retorna um valor que indica se a instância atual e um inteiro sem sinal de 64 bits têm o mesmo valor.
GetBitLength()	Obtém o número de bits necessários da representação mais curta de complemento de dois da instância atual sem o bit de sinal.
GetByteCount(Boolean)	Obtém o número de bytes que serão gerados por ToByteArray(Boolean, Boolean) e TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean).
GetHashCode()	Retorna o código hash para o objeto BigInteger atual.
GreatestCommonDivisor(BigInteger, BigInteger)	Localiza o maior divisor comum de dois valores BigInteger.
IsEvenInteger(BigInteger)	Determina se um valor representa um número integral par.
IsNegative(BigInteger)	Determina se um valor é negativo.
IsOddInteger(BigInteger)	Determina se um valor representa um número integral ímpar.
IsPositive(BigInteger)	Determina se um valor é positivo.
IsPow2(BigInteger)	Determina se um valor é uma potência de dois.
LeadingZeroCount(BigInteger)	Calcula o número de zeros à esquerda em um valor.
Log(BigInteger)	Retorna o logaritmo natural (de base `e`) de um número especificado.
Log(BigInteger, Double)	Retorna o logaritmo de um número especificado em uma base especificada.
Log10(BigInteger)	Retorna o logaritmo de base 10 de um número especificado.
Log2(BigInteger)	Calcula o log2 de um valor.
Max(BigInteger, BigInteger)	Retorna o maior dos dois valores BigInteger.
MaxMagnitude(BigInteger, BigInteger)	Compara dois valores com a computação que é maior.
Min(BigInteger, BigInteger)	Retorna o menor de dois valores BigInteger.
MinMagnitude(BigInteger, BigInteger)	Compara dois valores com a computação menor.
ModPow(BigInteger, BigInteger, BigInteger)	Executa a divisão de módulo em um número elevado à potência de outro número.
Multiply(BigInteger, BigInteger)	Retorna o produto de dois valores BigInteger.
Negate(BigInteger)	Nega um valor BigInteger especificado.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analisa um intervalo de caracteres em um valor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Converte a representação de um número, contida no intervalo de caracteres somente leitura, em um estilo especificado para seu BigInteger equivalente.
Parse(String)	Converte a representação da cadeia de caracteres de um número no BigInteger equivalente.
Parse(String, IFormatProvider)	Converte a representação de cadeia de caracteres de um número em um formato específico da cultura especificado em seu equivalente de BigInteger.
Parse(String, NumberStyles)	Converte a representação de cadeia de caracteres de um número em um estilo especificado em seu BigInteger equivalente.
Parse(String, NumberStyles, IFormatProvider)	Converte a representação de cadeia de caracteres de um número com um estilo especificado e um formato específico à cultura para seu BigInteger equivalente.
PopCount(BigInteger)	Calcula o número de bits definidos em um valor.
Pow(BigInteger, Int32)	Gera um valor BigInteger à potência de um valor especificado.
Remainder(BigInteger, BigInteger)	Executa a divisão do inteiro em dois valores BigInteger e retorna o restante.
RotateLeft(BigInteger, Int32)	Gira um valor deixado por um determinado valor.
RotateRight(BigInteger, Int32)	Gira um valor direito em um determinado valor.
Subtract(BigInteger, BigInteger)	Subtrai um valor BigInteger de outro e retorna o resultado.
ToByteArray()	Converte um valor de BigInteger em uma matriz de bytes.
ToByteArray(Boolean, Boolean)	Retorna o valor deste BigInteger como uma matriz de bytes usando o menor número possível de bytes. Se o valor é zero, retorna uma matriz de um byte cujo elemento é 0x00.
ToString()	Converte o valor numérico do objeto BigInteger atual na representação da cadeia de caracteres equivalente.
ToString(IFormatProvider)	Converte o valor numérico do objeto BigInteger atual em sua representação de cadeia de caracteres equivalente usando as informações especificadas de formatação específicas de cultura.
ToString(String)	Converte o valor numérico do objeto BigInteger atual para sua representação de cadeia de caracteres equivalente usando o formato especificado.
ToString(String, IFormatProvider)	Converte o valor numérico do objeto BigInteger atual em sua representação de cadeia de caracteres equivalente usando o formato especificado e as informações de formato específicas de cultura.
TrailingZeroCount(BigInteger)	Calcula o número de zeros à direita em um valor.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Formata essa instância de inteiro grande em um intervalo de caracteres.
TryParse(ReadOnlySpan<Char>, BigInteger)	Tenta converter a representação de um número contido no intervalo de caracteres somente leitura especificado em seu BigInteger equivalente e retorna um valor que indica se a conversão foi bem-sucedida.
TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)	Tenta analisar um intervalo de caracteres em um valor.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)	Tenta converter a representação de cadeia de caracteres de um número em seu BigInteger equivalente e retorna um valor que indica se a conversão foi bem-sucedida.
TryParse(String, BigInteger)	Tenta converter a representação de cadeia de caracteres de um número em seu BigInteger equivalente e retorna um valor que indica se a conversão foi bem-sucedida.
TryParse(String, IFormatProvider, BigInteger)
TryParse(String, NumberStyles, IFormatProvider, BigInteger)	Tenta converter a representação de cadeia de caracteres de um número em um estilo e formato específico à cultura especificados no equivalente BigInteger e retorna um valor que indica se a conversão foi bem-sucedida.
TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)	Copia o valor deste BigInteger como bytes de dois complementos little endian usando o menor número possível de bytes. Se o valor é zero, produz um byte cujo elemento é 0x00.

Operadores

Addition(BigInteger, BigInteger)	Adiciona os valores dos dois objetos BigInteger especificados.
BitwiseAnd(BigInteger, BigInteger)	Executa uma operação `And` bit a bit em dois valores BigInteger.
BitwiseOr(BigInteger, BigInteger)	Executa uma operação `Or` bit a bit em dois valores BigInteger.
Decrement(BigInteger)	Diminui um valor BigInteger em 1.
Division(BigInteger, BigInteger)	Divide um valor BigInteger especificado por outro valor BigInteger especificado usando a divisão de inteiros.
Equality(BigInteger, BigInteger)	Retorna um valor que indica se os valores de dois objetos BigInteger são iguais.
Equality(BigInteger, Int64)	Retorna um valor que indica se um valor BigInteger e um valor inteiro longo com sinal são iguais.
Equality(BigInteger, UInt64)	Retorna um valor que indica se um valor BigInteger e um valor inteiro longo sem sinal são iguais.
Equality(Int64, BigInteger)	Retorna um valor que indica se um valor inteiro longo com sinal e um valor BigInteger são iguais.
Equality(UInt64, BigInteger)	Retorna um valor que indica se um valor inteiro longo sem sinal e um valor BigInteger são iguais.
ExclusiveOr(BigInteger, BigInteger)	Executa uma operação exclusiva `Or` bit a bit (`XOr`) em dois valores BigInteger.
Explicit(BigInteger to Byte)	Define uma conversão explícita de um objeto BigInteger em um valor de byte sem sinal.
Explicit(BigInteger to Char)	Converte explicitamente um inteiro grande em um Char valor.
Explicit(BigInteger to Decimal)	Define uma conversão explícita de um objeto BigInteger em um valor Decimal.
Explicit(BigInteger to Double)	Define uma conversão explícita de um objeto BigInteger em um valor Double.
Explicit(BigInteger to Half)	Converte explicitamente um inteiro grande em um Half valor.
Explicit(BigInteger to Int128)	Converte explicitamente um inteiro grande em um Int128 valor.
Explicit(BigInteger to Int16)	Define uma conversão explícita de um objeto BigInteger em um valor inteiro com sinal de 16 bits.
Explicit(BigInteger to Int32)	Define uma conversão explícita de um objeto BigInteger para um valor inteiro com sinal de 32 bits.
Explicit(BigInteger to Int64)	Define uma conversão explícita de um objeto BigInteger para um valor inteiro com sinal de 64 bits.
Explicit(BigInteger to IntPtr)	Converte explicitamente um inteiro grande em um IntPtr valor.
Explicit(BigInteger to SByte)	Define uma conversão explícita de um objeto BigInteger em um valor de 8 bits com sinal. Esta API não compatível com CLS. A alternativa em conformidade é Int16.
Explicit(BigInteger to Single)	Define uma conversão explícita de um objeto BigInteger em um valor de ponto flutuante de precisão simples.
Explicit(BigInteger to UInt128)	Converte explicitamente um inteiro grande em um UInt128 valor.
Explicit(BigInteger to UInt16)	Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 16 bits. Esta API não compatível com CLS. A alternativa em conformidade é Int32.
Explicit(BigInteger to UInt32)	Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 32 bits. Esta API não compatível com CLS. A alternativa em conformidade é Int64.
Explicit(BigInteger to UInt64)	Define uma conversão explícita de um objeto BigInteger em um valor inteiro sem sinal de 64 bits. Esta API não compatível com CLS. A alternativa em conformidade é Double.
Explicit(BigInteger to UIntPtr)	Converte explicitamente um inteiro grande em um UIntPtr valor.
Explicit(Complex to BigInteger)	Converte explicitamente um Complex valor em um inteiro grande.
Explicit(Decimal to BigInteger)	Define uma conversão explícita de um objeto Decimal em um valor BigInteger.
Explicit(Double to BigInteger)	Define uma conversão explícita de um valor Double para um valor BigInteger.
Explicit(Half to BigInteger)	Converte explicitamente um Half valor em um inteiro grande.
Explicit(Single to BigInteger)	Define uma conversão explícita de um valor Single para um valor BigInteger.
GreaterThan(BigInteger, BigInteger)	Retorna um valor que indica se um valor BigInteger é maior que outro valor BigInteger.
GreaterThan(BigInteger, Int64)	Retorna um valor que indica se um BigInteger é maior que um valor inteiro com sinal de 64 bits.
GreaterThan(BigInteger, UInt64)	Retorna um valor que indica se um valor BigInteger é maior que um inteiro sem sinal de 64 bits.
GreaterThan(Int64, BigInteger)	Retorna um valor que indica se um inteiro com sinal de 64 bits é maior que um valor BigInteger.
GreaterThan(UInt64, BigInteger)	Retorna um valor que indica se um valor BigInteger é maior que um inteiro sem sinal de 64 bits.
GreaterThanOrEqual(BigInteger, BigInteger)	Retorna um valor que indica se um valor BigInteger é maior ou igual a outro valor BigInteger.
GreaterThanOrEqual(BigInteger, Int64)	Retorna um valor que indica se um valor de BigInteger é maior ou igual a um valor inteiro com sinal de 64 bits.
GreaterThanOrEqual(BigInteger, UInt64)	Retorna um valor que indica se um valor BigInteger é maior ou igual a um valor inteiro sem sinal de 64 bits.
GreaterThanOrEqual(Int64, BigInteger)	Retorna um valor que indica se um inteiro com sinal de 64 bits é maior ou igual a um valor BigInteger.
GreaterThanOrEqual(UInt64, BigInteger)	Retorna um valor que indica se um inteiro sem sinal de 64 bits é maior ou igual a um valor BigInteger.
Implicit(Byte to BigInteger)	Define uma conversão implícita de um byte sem sinal em um valor BigInteger.
Implicit(Char to BigInteger)	Converte implicitamente um Char valor em um inteiro grande.
Implicit(Int128 to BigInteger)	Converte implicitamente um Int128 valor em um inteiro grande.
Implicit(Int16 to BigInteger)	Define uma conversão implícita de um inteiro com sinal de 16 bits em um valor BigInteger.
Implicit(Int32 to BigInteger)	Define uma conversão implícita de um inteiro com sinal de 32 bits em um valor BigInteger.
Implicit(Int64 to BigInteger)	Define uma conversão implícita de um inteiro com sinal de 64 bits em um valor BigInteger.
Implicit(IntPtr to BigInteger)	Converte implicitamente um IntPtr valor em um inteiro grande.
Implicit(SByte to BigInteger)	Define uma conversão implícita de um inteiro com sinal de 8 bits em um valor BigInteger. Esta API não compatível com CLS. A alternativa em conformidade é BigInteger(Int32).
Implicit(UInt128 to BigInteger)	Converte implicitamente um UInt128 valor em um inteiro grande.
Implicit(UInt16 to BigInteger)	Define uma conversão implícita de um inteiro sem sinal de 16 bits em um valor BigInteger. Esta API não compatível com CLS. A alternativa em conformidade é Implicit(Int32 to BigInteger).
Implicit(UInt32 to BigInteger)	Define uma conversão implícita de um inteiro sem sinal de 32 bits em um valor BigInteger. Esta API não compatível com CLS. A alternativa em conformidade é Implicit(Int64 to BigInteger).
Implicit(UInt64 to BigInteger)	Define uma conversão implícita de um inteiro sem sinal de 64 bits em um valor BigInteger. Esta API não compatível com CLS. A alternativa em conformidade é Double.
Implicit(UIntPtr to BigInteger)	Converte implicitamente um UIntPtr valor em um inteiro grande.
Increment(BigInteger)	Incrementa um valor BigInteger em 1.
Inequality(BigInteger, BigInteger)	Retorna um valor que indica se dois objetos BigInteger têm valores diferentes.
Inequality(BigInteger, Int64)	Retorna um valor que indica se um valor BigInteger e um inteiro com sinal de 64 bits não são iguais.
Inequality(BigInteger, UInt64)	Retorna um valor que indica se um valor BigInteger e um inteiro sem sinal de 64 bits não são iguais.
Inequality(Int64, BigInteger)	Retorna um valor que indica se um inteiro com sinal de 64 bits e um valor BigInteger não são iguais.
Inequality(UInt64, BigInteger)	Retorna um valor que indica se um inteiro sem sinal de 64 bits e um valor BigInteger não são iguais.
LeftShift(BigInteger, Int32)	Desloca um valor BigInteger um número especificado de bits para a esquerda.
LessThan(BigInteger, BigInteger)	Retorna um valor que indica se um valor BigInteger é menor que outro valor BigInteger.
LessThan(BigInteger, Int64)	Retorna um valor que indica se um valor BigInteger é menor que um inteiro com sinal de 64 bits.
LessThan(BigInteger, UInt64)	Retorna um valor que indica se um valor BigInteger é menor que um inteiro sem sinal de 64 bits.
LessThan(Int64, BigInteger)	Retorna um valor que indica se um inteiro com sinal de 64 bits é menor que um valor BigInteger.
LessThan(UInt64, BigInteger)	Retorna um valor que indica se um inteiro sem sinal de 64 bits é menor que um valor BigInteger.
LessThanOrEqual(BigInteger, BigInteger)	Retorna um valor que indica se um valor BigInteger é menor ou igual a outro valor BigInteger.
LessThanOrEqual(BigInteger, Int64)	Retorna um valor que indica se um valor BigInteger é menor ou igual a um inteiro com sinal de 64 bits.
LessThanOrEqual(BigInteger, UInt64)	Retorna um valor que indica se um valor BigInteger é menor ou igual a um inteiro sem sinal de 64 bits.
LessThanOrEqual(Int64, BigInteger)	Retorna um valor que indica se um inteiro com sinal de 64 bits é menor ou igual a um valor BigInteger.
LessThanOrEqual(UInt64, BigInteger)	Retorna um valor que indica se um inteiro sem sinal de 64 bits é menor ou igual a um valor BigInteger.
Modulus(BigInteger, BigInteger)	Retorna o resto que resulta da divisão com dois valores especificados BigInteger.
Multiply(BigInteger, BigInteger)	Multiplica dois valores BigInteger especificados.
OnesComplement(BigInteger)	Retorna o complemento bit a bit de um valor BigInteger.
RightShift(BigInteger, Int32)	Desloca um valor BigInteger um número especificado de bits para a direita.
Subtraction(BigInteger, BigInteger)	Subtrai um valor BigInteger de outro valor BigInteger.
UnaryNegation(BigInteger)	Nega um valor BigInteger especificado.
UnaryPlus(BigInteger)	Retorna o valor do operando BigInteger. (O sinal do operando permanece inalterado).
UnsignedRightShift(BigInteger, Int32)	Desloca um valor para a direita por um determinado valor.

Implantações explícitas de interface

IBinaryInteger<BigInteger>.GetByteCount()	Obtém o número de bytes que serão gravados como parte de TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<BigInteger>.GetShortestBitLength()	Obtém o comprimento, em bits, da representação complementar dos dois mais curtos do valor atual.
IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<Byte>, Int32)	Tenta gravar o valor atual, no formato big-endian, em um determinado intervalo.
IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<Byte>, Int32)	Tenta gravar o valor atual, no formato little-endian, em um determinado intervalo.
IComparable.CompareTo(Object)	Compara esta instância a um objeto especificado e retorna um inteiro que indica se o valor desta instância é menor, igual ou maior que o valor do objeto especificado.

Aplica-se a