BigInteger Struct

Definition

Namespace:

System.Numerics

Assembly:

System.Runtime.Numerics.dll

Represents an arbitrarily large signed integer.

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

Inheritance

Object

ValueType

BigInteger

Implements

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>

Remarks

The BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. The members of the BigInteger type closely parallel those of other integral types (the Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, and UInt64 types). This type differs from the other integral types in the .NET Framework, which have a range indicated by their MinValue and MaxValue properties.

Note

Because the BigInteger type is immutable (see Mutability and the BigInteger Structure) and because it has no upper or lower bounds, an OutOfMemoryException can be thrown for any operation that causes a BigInteger value to grow too large.

Instantiating a BigInteger Object

You can instantiate a BigInteger object in several ways:

• You can use the new keyword and provide any integral or floating-point value as a parameter to the BigInteger constructor. (Floating-point values are truncated before they are assigned to the BigInteger.) The following example illustrates how to use the new keyword to instantiate BigInteger values.

  BigInteger bigIntFromDouble = new BigInteger(179032.6541);
  Console.WriteLine(bigIntFromDouble);
  BigInteger bigIntFromInt64 = new BigInteger(934157136952);
  Console.WriteLine(bigIntFromInt64);
  // The example displays the following output:
  //   179032
  //   934157136952
  

  Dim bigIntFromDouble As New BigInteger(179032.6541)
  Console.WriteLine(bigIntFromDouble)
  Dim bigIntFromInt64 As New BigInteger(934157136952)
  Console.WriteLine(bigIntFromInt64)
  ' The example displays the following output:
  '   179032
  '   934157136952
  

• You can declare a BigInteger variable and assign it a value just as you would any numeric type, as long as that value is an integral type. The following example uses assignment to create a BigInteger value from an Int64.

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

  Dim longValue As Long = 6315489358112      
  Dim assignedFromLong As BigInteger = longValue
  Console.WriteLine(assignedFromLong)
  ' The example displays the following output:
  '   6315489358112
  

• You can assign a decimal or floating-point value to a BigInteger object if you cast the value or convert it first. The following example explicitly casts (in C#) or converts (in Visual Basic) a Double and a Decimal value to a BigInteger.

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

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

These methods enable you to instantiate a BigInteger object whose value is in the range of one of the existing numeric types only. You can instantiate a BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

• You can use the new keyword and provide a byte array of any size to the BigInteger.BigInteger constructor. For example:

  byte[] byteArray = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
  BigInteger newBigInt = new BigInteger(byteArray);
  Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt);
  // The example displays the following output:
  //   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
  

  Dim byteArray() As Byte = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
  Dim newBigInt As New BigInteger(byteArray)
  Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt)    
  ' The example displays the following output:
  '   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
  

• You can call the Parse or TryParse methods to convert the string representation of a number to a BigInteger. For example:

  string positiveString = "91389681247993671255432112000000";
  string negativeString = "-90315837410896312071002088037140000";
  BigInteger posBigInt = 0;
  BigInteger negBigInt = 0;
  
  try {
     posBigInt = BigInteger.Parse(positiveString);
     Console.WriteLine(posBigInt);
  }
  catch (FormatException)
  {
     Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.",
                       positiveString);
  }
  
  if (BigInteger.TryParse(negativeString, out negBigInt))
    Console.WriteLine(negBigInt);
  else
     Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.",
                        negativeString);
  
  // The example displays the following output:
  //   9.1389681247993671255432112E+31
  //   -9.0315837410896312071002088037E+34
  

  Dim positiveString As String = "91389681247993671255432112000000"
  Dim negativeString As string = "-90315837410896312071002088037140000"
  Dim posBigInt As BigInteger = 0
  Dim negBigInt As BigInteger = 0
  
  Try
     posBigInt = BigInteger.Parse(positiveString)
     Console.WriteLine(posBigInt)
  Catch e As FormatException
     Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                       positiveString)
  End Try
  
  If BigInteger.TryParse(negativeString, negBigInt) Then
    Console.WriteLine(negBigInt)
  Else
     Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                        negativeString)
  End If         
  ' The example displays the following output:
  '   9.1389681247993671255432112E+31
  '   -9.0315837410896312071002088037E+34
  

• You can call a static (Shared in Visual Basic) BigInteger method that performs some operation on a numeric expression and returns a calculated BigInteger result. The following example does this by cubing UInt64.MaxValue and assigning the result to a BigInteger.

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

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

The uninitialized value of a BigInteger is Zero.

Performing Operations on BigInteger Values

You can use a BigInteger instance as you would use any other integral type. BigInteger overloads the standard numeric operators to enable you to perform basic mathematical operations such as addition, subtraction, division, multiplication, and unary negation. You can also use the standard numeric operators to compare two BigInteger values with each other. Like the other integral types, BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. For languages that do not support custom operators, the BigInteger structure also provides equivalent methods for performing mathematical operations. These include Add, Divide, Multiply, Negate, Subtract, and several others.

Many members of the BigInteger structure correspond directly to members of the other integral types. In addition, BigInteger adds members such as the following:

• Sign, which returns a value that indicates the sign of a BigInteger value.

• Abs, which returns the absolute value of a BigInteger value.

• DivRem, which returns both the quotient and remainder of a division operation.

• GreatestCommonDivisor, which returns the greatest common divisor of two BigInteger values.

Many of these additional members correspond to the members of the Math class, which provides the functionality to work with the primitive numeric types.

Mutability and the BigInteger Structure

The following example instantiates a BigInteger object and then increments its value by one.

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

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

Although this example appears to modify the value of the existing object, this is not the case. BigInteger objects are immutable, which means that internally, the common language runtime actually creates a new BigInteger object and assigns it a value one greater than its previous value. This new object is then returned to the caller.

Note

The other numeric types in .NET are also immutable. However, because the BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

Although this process is transparent to the caller, it does incur a performance penalty. In some cases, especially when repeated operations are performed in a loop on very large BigInteger values, that performance penalty can be significant. For example, in the following example, an operation is performed repetitively up to a million times, and a BigInteger value is incremented by one every time the operation succeeds.

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

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

In such a case, you can improve performance by performing all intermediate assignments to an Int32 variable. The final value of the variable can then be assigned to the BigInteger object when the loop exits. The following example provides an illustration.

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

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

Working with Byte Arrays and Hexadecimal Strings

If you convert BigInteger values to byte arrays, or if you convert byte arrays to BigInteger values, you must consider the order of bytes. The BigInteger structure expects the individual bytes in a byte array to appear in little-endian order (that is, the lower-order bytes of the value precede the higher-order bytes). You can round-trip a BigInteger value by calling the ToByteArray method and then passing the resulting byte array to the BigInteger(Byte[]) constructor, as the following example shows.

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

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

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

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

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

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

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

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

To instantiate a BigInteger value from a byte array that represents a value of some other integral type, you can pass the integral value to the BitConverter.GetBytes method, and then pass the resulting byte array to the BigInteger(Byte[]) constructor. The following example instantiates a BigInteger value from a byte array that represents an Int16 value.

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

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

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

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

Dim originalValue As Short = 30000
Console.WriteLine(originalValue)

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

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

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

The BigInteger structure assumes that negative values are stored by using two's complement representation. Because the BigInteger structure represents a numeric value with no fixed length, the BigInteger(Byte[]) constructor always interprets the most significant bit of the last byte in the array as a sign bit. To prevent the BigInteger(Byte[]) constructor from confusing the two's complement representation of a negative value with the sign and magnitude representation of a positive value, positive values in which the most significant bit of the last byte in the byte array would ordinarily be set should include an additional byte whose value is 0. For example, 0xC0 0xBD 0xF0 0xFF is the little-endian hexadecimal representation of either -1,000,000 or 4,293,967,296. Because the most significant bit of the last byte in this array is on, the value of the byte array would be interpreted by the BigInteger(Byte[]) constructor as -1,000,000. To instantiate a BigInteger whose value is positive, a byte array whose elements are 0xC0 0xBD 0xF0 0xFF 0x00 must be passed to the constructor. The following example illustrates this.

int negativeNumber = -1000000;
uint positiveNumber = 4293967296;

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

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

Dim negativeNumber As Integer = -1000000
Dim positiveNumber As UInteger = 4293967296

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

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

Byte arrays created by the ToByteArray method from positive values include this extra zero-value byte. Therefore, the BigInteger structure can successfully round-trip values by assigning them to, and then restoring them from, byte arrays, as the following example shows.

BigInteger positiveValue = 15777216;
BigInteger negativeValue  = -1000000;

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

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

Console.WriteLine();

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

Dim positiveValue As BigInteger = 15777216
Dim negativeValue As BigInteger = -1000000

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

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

However, you may need to add this additional zero-value byte to byte arrays that are created dynamically by the developer or that are returned by methods that convert unsigned integers to byte arrays (such as BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32), and BitConverter.GetBytes(UInt64)).

When parsing a hexadecimal string, the BigInteger.Parse(String, NumberStyles) and BigInteger.Parse(String, NumberStyles, IFormatProvider) methods assume that if the most significant bit of the first byte in the string is set, or if the first hexadecimal digit of the string represents the lower four bits of a byte value, the value is represented by using two's complement representation. For example, both "FF01" and "F01" represent the decimal value -255. To differentiate positive from negative values, positive values should include a leading zero. The relevant overloads of the ToString method, when they are passed the "X" format string, add a leading zero to the returned hexadecimal string for positive values. This makes it possible to round-trip BigInteger values by using the ToString and Parse methods, as the following example shows.

BigInteger negativeNumber = -1000000;
BigInteger positiveNumber  = 15777216;

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

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

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

Dim negativeNumber As BigInteger = -1000000
Dim positiveNumber As BigInteger = 15777216

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

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

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

However, the hexadecimal strings created by calling the ToString methods of the other integral types or the overloads of the ToString method that include a toBase parameter do not indicate the sign of the value or the source data type from which the hexadecimal string was derived. Successfully instantiating a BigInteger value from such a string requires some additional logic. The following example provides one possible implementation.

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

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

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

      // Convert the numbers to hex strings.
      HexValue hexValue1, hexValue2;
      hexValue1.Value = positiveNumber.ToString("X");
      hexValue1.Sign = Math.Sign(positiveNumber);

      hexValue2.Value = Convert.ToString(negativeNumber, 16);
      hexValue2.Sign = Math.Sign(negativeNumber);

      // Round-trip the hexadecimal values to BigInteger values.
      string hexString;
      BigInteger positiveBigInt, negativeBigInt;

      hexString = (hexValue1.Sign == 1 ? "0" : "") + hexValue1.Value;
      positiveBigInt = BigInteger.Parse(hexString, NumberStyles.HexNumber);
      Console.WriteLine("Converted {0} to {1} and back to {2}.",
                        positiveNumber, hexValue1.Value, positiveBigInt);

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

Imports System.Globalization
Imports System.Numerics

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

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

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

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

Constructors

BigInteger(Byte[])	Initializes a new instance of the BigInteger structure using the values in a byte array.
BigInteger(Decimal)	Initializes a new instance of the BigInteger structure using a Decimal value.
BigInteger(Double)	Initializes a new instance of the BigInteger structure using a double-precision floating-point value.
BigInteger(Int32)	Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.
BigInteger(Int64)	Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	Initializes a new instance of the BigInteger structure using the values in a read-only span of bytes, and optionally indicating the signing encoding and the endianness byte order.
BigInteger(Single)	Initializes a new instance of the BigInteger structure using a single-precision floating-point value.
BigInteger(UInt32)	Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.
BigInteger(UInt64)	Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

Properties

IsEven	Indicates whether the value of the current BigInteger object is an even number.
IsOne	Indicates whether the value of the current BigInteger object is One.
IsPowerOfTwo	Indicates whether the value of the current BigInteger object is a power of two.
IsZero	Indicates whether the value of the current BigInteger object is Zero.
MinusOne	Gets a value that represents the number negative one (-1).
One	Gets a value that represents the number one (1).
Sign	Gets a number that indicates the sign (negative, positive, or zero) of the current BigInteger object.
Zero	Gets a value that represents the number 0 (zero).

Methods

Abs(BigInteger)	Gets the absolute value of a BigInteger object.
Add(BigInteger, BigInteger)	Adds two BigInteger values and returns the result.
Clamp(BigInteger, BigInteger, BigInteger)	Clamps a value to an inclusive minimum and maximum value.
Compare(BigInteger, BigInteger)	Compares two BigInteger values and returns an integer that indicates whether the first value is less than, equal to, or greater than the second value.
CompareTo(BigInteger)	Compares this instance to a second BigInteger and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.
CompareTo(Int64)	Compares this instance to a signed 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the signed 64-bit integer.
CompareTo(Object)	Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.
CompareTo(UInt64)	Compares this instance to an unsigned 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the unsigned 64-bit integer.
CopySign(BigInteger, BigInteger)	Copies the sign of a value to the sign of another value.
CreateChecked<TOther>(TOther)	Creates an instance of the current type from a value, throwing an overflow exception for any values that fall outside the representable range of the current type.
CreateSaturating<TOther>(TOther)	Creates an instance of the current type from a value, saturating any values that fall outside the representable range of the current type.
CreateTruncating<TOther>(TOther)	Creates an instance of the current type from a value, truncating any values that fall outside the representable range of the current type.
Divide(BigInteger, BigInteger)	Divides one BigInteger value by another and returns the result.
DivRem(BigInteger, BigInteger)	Computes the quotient and remainder of two values.
DivRem(BigInteger, BigInteger, BigInteger)	Divides one BigInteger value by another, returns the result, and returns the remainder in an output parameter.
Equals(BigInteger)	Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.
Equals(Int64)	Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.
Equals(Object)	Returns a value that indicates whether the current instance and a specified object have the same value.
Equals(UInt64)	Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.
GetBitLength()	Gets the number of bits required for shortest two's complement representation of the current instance without the sign bit.
GetByteCount(Boolean)	Gets the number of bytes that will be output by ToByteArray(Boolean, Boolean) and TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean).
GetHashCode()	Returns the hash code for the current BigInteger object.
GreatestCommonDivisor(BigInteger, BigInteger)	Finds the greatest common divisor of two BigInteger values.
IsEvenInteger(BigInteger)	Determines if a value represents an even integral number.
IsNegative(BigInteger)	Determines if a value is negative.
IsOddInteger(BigInteger)	Determines if a value represents an odd integral number.
IsPositive(BigInteger)	Determines if a value is positive.
IsPow2(BigInteger)	Determines if a value is a power of two.
LeadingZeroCount(BigInteger)	Computes the number of leading zeros in a value.
Log(BigInteger)	Returns the natural (base e) logarithm of a specified number.
Log(BigInteger, Double)	Returns the logarithm of a specified number in a specified base.
Log10(BigInteger)	Returns the base 10 logarithm of a specified number.
Log2(BigInteger)	Computes the log2 of a value.
Max(BigInteger, BigInteger)	Returns the larger of two BigInteger values.
MaxMagnitude(BigInteger, BigInteger)	Compares two values to compute which is greater.
Min(BigInteger, BigInteger)	Returns the smaller of two BigInteger values.
MinMagnitude(BigInteger, BigInteger)	Compares two values to compute which is lesser.
ModPow(BigInteger, BigInteger, BigInteger)	Performs modulus division on a number raised to the power of another number.
Multiply(BigInteger, BigInteger)	Returns the product of two BigInteger values.
Negate(BigInteger)	Negates a specified BigInteger value.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parses a span of characters into a value.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Converts the representation of a number, contained in the specified read-only span of characters, in a specified style to its BigInteger equivalent.
Parse(String)	Converts the string representation of a number to its BigInteger equivalent.
Parse(String, IFormatProvider)	Converts the string representation of a number in a specified culture-specific format to its BigInteger equivalent.
Parse(String, NumberStyles)	Converts the string representation of a number in a specified style to its BigInteger equivalent.
Parse(String, NumberStyles, IFormatProvider)	Converts the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent.
PopCount(BigInteger)	Computes the number of bits that are set in a value.
Pow(BigInteger, Int32)	Raises a BigInteger value to the power of a specified value.
Remainder(BigInteger, BigInteger)	Performs integer division on two BigInteger values and returns the remainder.
RotateLeft(BigInteger, Int32)	Rotates a value left by a given amount.
RotateRight(BigInteger, Int32)	Rotates a value right by a given amount.
Subtract(BigInteger, BigInteger)	Subtracts one BigInteger value from another and returns the result.
ToByteArray()	Converts a BigInteger value to a byte array.
ToByteArray(Boolean, Boolean)	Returns the value of this BigInteger as a byte array using the fewest number of bytes possible. If the value is zero, returns an array of one byte whose element is 0x00.
ToString()	Converts the numeric value of the current BigInteger object to its equivalent string representation.
ToString(IFormatProvider)	Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified culture-specific formatting information.
ToString(String)	Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format.
ToString(String, IFormatProvider)	Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format and culture-specific format information.
TrailingZeroCount(BigInteger)	Computes the number of trailing zeros in a value.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Formats this big integer instance into a span of characters.
TryParse(ReadOnlySpan<Char>, BigInteger)	Tries to convert the representation of a number contained in the specified read-only character span, to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.
TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)	Tries to parse a span of characters into a value.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)	Tries to convert the string representation of a number to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.
TryParse(String, BigInteger)	Tries to convert the string representation of a number to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.
TryParse(String, IFormatProvider, BigInteger)	Tries to parse a string into a value.
TryParse(String, NumberStyles, IFormatProvider, BigInteger)	Tries to convert the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.
TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)	Copies the value of this BigInteger as little-endian twos-complement bytes, using the fewest number of bytes possible. If the value is zero, outputs one byte whose element is 0x00.

Operators

Addition(BigInteger, BigInteger)	Adds the values of two specified BigInteger objects.
BitwiseAnd(BigInteger, BigInteger)	Performs a bitwise And operation on two BigInteger values.
BitwiseOr(BigInteger, BigInteger)	Performs a bitwise Or operation on two BigInteger values.
Decrement(BigInteger)	Decrements a BigInteger value by 1.
Division(BigInteger, BigInteger)	Divides a specified BigInteger value by another specified BigInteger value by using integer division.
Equality(BigInteger, BigInteger)	Returns a value that indicates whether the values of two BigInteger objects are equal.
Equality(BigInteger, Int64)	Returns a value that indicates whether a BigInteger value and a signed long integer value are equal.
Equality(BigInteger, UInt64)	Returns a value that indicates whether a BigInteger value and an unsigned long integer value are equal.
Equality(Int64, BigInteger)	Returns a value that indicates whether a signed long integer value and a BigInteger value are equal.
Equality(UInt64, BigInteger)	Returns a value that indicates whether an unsigned long integer value and a BigInteger value are equal.
ExclusiveOr(BigInteger, BigInteger)	Performs a bitwise exclusive Or (XOr) operation on two BigInteger values.
Explicit(BigInteger to Byte)	Defines an explicit conversion of a BigInteger object to an unsigned byte value.
Explicit(BigInteger to Char)	Explicitly converts a big integer to a Char value.
Explicit(BigInteger to Decimal)	Defines an explicit conversion of a BigInteger object to a Decimal value.
Explicit(BigInteger to Double)	Defines an explicit conversion of a BigInteger object to a Double value.
Explicit(BigInteger to Half)	Explicitly converts a big integer to a Half value.
Explicit(BigInteger to Int128)	Explicitly converts a big integer to a Int128 value.
Explicit(BigInteger to Int16)	Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.
Explicit(BigInteger to Int32)	Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.
Explicit(BigInteger to Int64)	Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.
Explicit(BigInteger to IntPtr)	Explicitly converts a big integer to a IntPtr value.
Explicit(BigInteger to SByte)	Defines an explicit conversion of a BigInteger object to a signed 8-bit value. This API is not CLS-compliant. The compliant alternative is Int16.
Explicit(BigInteger to Single)	Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.
Explicit(BigInteger to UInt128)	Explicitly converts a big integer to a UInt128 value.
Explicit(BigInteger to UInt16)	Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value. This API is not CLS-compliant. The compliant alternative is Int32.
Explicit(BigInteger to UInt32)	Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value. This API is not CLS-compliant. The compliant alternative is Int64.
Explicit(BigInteger to UInt64)	Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value. This API is not CLS-compliant. The compliant alternative is Double.
Explicit(BigInteger to UIntPtr)	Explicitly converts a big integer to a UIntPtr value.
Explicit(Complex to BigInteger)	Explicitly converts a Complex value to a big integer.
Explicit(Decimal to BigInteger)	Defines an explicit conversion of a Decimal object to a BigInteger value.
Explicit(Double to BigInteger)	Defines an explicit conversion of a Double value to a BigInteger value.
Explicit(Half to BigInteger)	Explicitly converts a Half value to a big integer.
Explicit(Single to BigInteger)	Defines an explicit conversion of a Single value to a BigInteger value.
GreaterThan(BigInteger, BigInteger)	Returns a value that indicates whether a BigInteger value is greater than another BigInteger value.
GreaterThan(BigInteger, Int64)	Returns a value that indicates whether a BigInteger is greater than a 64-bit signed integer value.
GreaterThan(BigInteger, UInt64)	Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.
GreaterThan(Int64, BigInteger)	Returns a value that indicates whether a 64-bit signed integer is greater than a BigInteger value.
GreaterThan(UInt64, BigInteger)	Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.
GreaterThanOrEqual(BigInteger, BigInteger)	Returns a value that indicates whether a BigInteger value is greater than or equal to another BigInteger value.
GreaterThanOrEqual(BigInteger, Int64)	Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit signed integer value.
GreaterThanOrEqual(BigInteger, UInt64)	Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit unsigned integer value.
GreaterThanOrEqual(Int64, BigInteger)	Returns a value that indicates whether a 64-bit signed integer is greater than or equal to a BigInteger value.
GreaterThanOrEqual(UInt64, BigInteger)	Returns a value that indicates whether a 64-bit unsigned integer is greater than or equal to a BigInteger value.
Implicit(Byte to BigInteger)	Defines an implicit conversion of an unsigned byte to a BigInteger value.
Implicit(Char to BigInteger)	Implicitly converts a Char value to a big integer.
Implicit(Int128 to BigInteger)	Implicitly converts a Int128 value to a big integer.
Implicit(Int16 to BigInteger)	Defines an implicit conversion of a signed 16-bit integer to a BigInteger value.
Implicit(Int32 to BigInteger)	Defines an implicit conversion of a signed 32-bit integer to a BigInteger value.
Implicit(Int64 to BigInteger)	Defines an implicit conversion of a signed 64-bit integer to a BigInteger value.
Implicit(IntPtr to BigInteger)	Implicitly converts a IntPtr value to a big integer.
Implicit(SByte to BigInteger)	Defines an implicit conversion of an 8-bit signed integer to a BigInteger value. This API is not CLS-compliant. The compliant alternative is BigInteger(Int32).
Implicit(UInt128 to BigInteger)	Implicitly converts a UInt128 value to a big integer.
Implicit(UInt16 to BigInteger)	Defines an implicit conversion of a 16-bit unsigned integer to a BigInteger value. This API is not CLS-compliant. The compliant alternative is Implicit(Int32 to BigInteger).
Implicit(UInt32 to BigInteger)	Defines an implicit conversion of a 32-bit unsigned integer to a BigInteger value. This API is not CLS-compliant. The compliant alternative is Implicit(Int64 to BigInteger).
Implicit(UInt64 to BigInteger)	Defines an implicit conversion of a 64-bit unsigned integer to a BigInteger value. This API is not CLS-compliant. The compliant alternative is Double.
Implicit(UIntPtr to BigInteger)	Implicitly converts a UIntPtr value to a big integer.
Increment(BigInteger)	Increments a BigInteger value by 1.
Inequality(BigInteger, BigInteger)	Returns a value that indicates whether two BigInteger objects have different values.
Inequality(BigInteger, Int64)	Returns a value that indicates whether a BigInteger value and a 64-bit signed integer are not equal.
Inequality(BigInteger, UInt64)	Returns a value that indicates whether a BigInteger value and a 64-bit unsigned integer are not equal.
Inequality(Int64, BigInteger)	Returns a value that indicates whether a 64-bit signed integer and a BigInteger value are not equal.
Inequality(UInt64, BigInteger)	Returns a value that indicates whether a 64-bit unsigned integer and a BigInteger value are not equal.
LeftShift(BigInteger, Int32)	Shifts a BigInteger value a specified number of bits to the left.
LessThan(BigInteger, BigInteger)	Returns a value that indicates whether a BigInteger value is less than another BigInteger value.
LessThan(BigInteger, Int64)	Returns a value that indicates whether a BigInteger value is less than a 64-bit signed integer.
LessThan(BigInteger, UInt64)	Returns a value that indicates whether a BigInteger value is less than a 64-bit unsigned integer.
LessThan(Int64, BigInteger)	Returns a value that indicates whether a 64-bit signed integer is less than a BigInteger value.
LessThan(UInt64, BigInteger)	Returns a value that indicates whether a 64-bit unsigned integer is less than a BigInteger value.
LessThanOrEqual(BigInteger, BigInteger)	Returns a value that indicates whether a BigInteger value is less than or equal to another BigInteger value.
LessThanOrEqual(BigInteger, Int64)	Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit signed integer.
LessThanOrEqual(BigInteger, UInt64)	Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit unsigned integer.
LessThanOrEqual(Int64, BigInteger)	Returns a value that indicates whether a 64-bit signed integer is less than or equal to a BigInteger value.
LessThanOrEqual(UInt64, BigInteger)	Returns a value that indicates whether a 64-bit unsigned integer is less than or equal to a BigInteger value.
Modulus(BigInteger, BigInteger)	Returns the remainder that results from division with two specified BigInteger values.
Multiply(BigInteger, BigInteger)	Multiplies two specified BigInteger values.
OnesComplement(BigInteger)	Returns the bitwise one's complement of a BigInteger value.
RightShift(BigInteger, Int32)	Shifts a BigInteger value a specified number of bits to the right.
Subtraction(BigInteger, BigInteger)	Subtracts a BigInteger value from another BigInteger value.
UnaryNegation(BigInteger)	Negates a specified BigInteger value.
UnaryPlus(BigInteger)	Returns the value of the BigInteger operand. (The sign of the operand is unchanged.)
UnsignedRightShift(BigInteger, Int32)	Shifts a value right by a given amount.

Explicit Interface Implementations

IAdditiveIdentity<BigInteger,BigInteger>.AdditiveIdentity
IBinaryInteger<BigInteger>.GetByteCount()	Gets the number of bytes that will be written as part of TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<BigInteger>.GetShortestBitLength()	Gets the length, in bits, of the shortest two's complement representation of the current value.
IBinaryInteger<BigInteger>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, BigInteger)
IBinaryInteger<BigInteger>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, BigInteger)
IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<Byte>, Int32)	Tries to write the current value, in big-endian format, to a given span.
IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<Byte>, Int32)	Tries to write the current value, in little-endian format, to a given span.
IBinaryNumber<BigInteger>.AllBitsSet
IMultiplicativeIdentity<BigInteger,BigInteger>.MultiplicativeIdentity
INumber<BigInteger>.MaxNumber(BigInteger, BigInteger)
INumber<BigInteger>.MinNumber(BigInteger, BigInteger)
INumber<BigInteger>.Sign(BigInteger)
INumberBase<BigInteger>.IsCanonical(BigInteger)
INumberBase<BigInteger>.IsComplexNumber(BigInteger)
INumberBase<BigInteger>.IsFinite(BigInteger)
INumberBase<BigInteger>.IsImaginaryNumber(BigInteger)
INumberBase<BigInteger>.IsInfinity(BigInteger)
INumberBase<BigInteger>.IsInteger(BigInteger)
INumberBase<BigInteger>.IsNaN(BigInteger)
INumberBase<BigInteger>.IsNegativeInfinity(BigInteger)
INumberBase<BigInteger>.IsNormal(BigInteger)
INumberBase<BigInteger>.IsPositiveInfinity(BigInteger)
INumberBase<BigInteger>.IsRealNumber(BigInteger)
INumberBase<BigInteger>.IsSubnormal(BigInteger)
INumberBase<BigInteger>.IsZero(BigInteger)
INumberBase<BigInteger>.MaxMagnitudeNumber(BigInteger, BigInteger)
INumberBase<BigInteger>.MinMagnitudeNumber(BigInteger, BigInteger)
INumberBase<BigInteger>.Radix
INumberBase<BigInteger>.TryConvertFromChecked<TOther>(TOther, BigInteger)
INumberBase<BigInteger>.TryConvertFromSaturating<TOther>(TOther, BigInteger)
INumberBase<BigInteger>.TryConvertFromTruncating<TOther>(TOther, BigInteger)
INumberBase<BigInteger>.TryConvertToChecked<TOther>(BigInteger, TOther)
INumberBase<BigInteger>.TryConvertToSaturating<TOther>(BigInteger, TOther)
INumberBase<BigInteger>.TryConvertToTruncating<TOther>(BigInteger, TOther)
ISignedNumber<BigInteger>.NegativeOne