BigInteger Constructors
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Initializes a new instance of the BigInteger structure.
Overloads
| 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(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. |
| 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(Byte[])
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
Important
This API is not CLS-compliant.
Initializes a new instance of the BigInteger structure using the values in a byte array.
public:
BigInteger(cli::array <System::Byte> ^ value);[System.CLSCompliant(false)]
public BigInteger (byte[] value);[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : byte[] -> System.Numerics.BigIntegerPublic Sub New (value As Byte())Parameters
- value
- Byte[]
An array of byte values in little-endian order.
- Attributes
Exceptions
value is null.
Examples
The following example instantiates a BigInteger object from a 5-element byte array whose value is {5, 4, 3, 2, 1}. It then displays the BigInteger value, represented as both decimal and hexadecimal numbers, to the console. A comparison of the input array with the text output makes it clear why this overload of the BigInteger class constructor creates a BigInteger object whose value is 4328719365 (or 0x102030405). The first element of the byte array, whose value is 5, defines the value of the lowest-order byte of the BigInteger object, which is 0x05. The second element of the byte array, whose value is 4, defines the value of the second byte of the BigInteger object, which is 0x04, and so on.
byte[] bytes = { 5, 4, 3, 2, 1 };
BigInteger number = new BigInteger(bytes);
Console.WriteLine("The value of number is {0} (or 0x{0:x}).", number);
// The example displays the following output:
// The value of number is 4328719365 (or 0x102030405).
let bytes = [| 5uy; 4uy; 3uy; 2uy; 1uy |]
let number = new BigInteger(bytes)
printfn $"The value of number is {number} (or 0x{number:x})."
// The example displays the following output:
// The value of number is 4328719365 (or 0x102030405).
Dim bytes() As Byte = { 5, 4, 3, 2, 1 }
Dim number As New BigInteger(bytes)
Console.WriteLine("The value of number is {0} (or 0x{0:x}).", number)
' The example displays the following output:
' The value of number is 4328719365 (or 0x102030405).
The following example instantiates a positive and a negative BigInteger value, passes them to the ToByteArray method, and then restores the original BigInteger values from the resulting byte array. Note that the two values are represented by identical byte arrays. The only difference between them is in the most significant bit of the last element in the byte array. This bit is set (the value of the byte is 0xFF) if the array is created from a negative BigInteger value. The bit is not set (the value of the byte is zero), if the array is created from a positive BigInteger value.
// Instantiate BigInteger values.
BigInteger positiveValue = BigInteger.Parse("4713143110832790377889");
BigInteger negativeValue = BigInteger.Add(-Int64.MaxValue, -60000);
BigInteger positiveValue2, negativeValue2;
// Create two byte arrays.
byte[] positiveBytes = positiveValue.ToByteArray();
byte[] negativeBytes = negativeValue.ToByteArray();
// Instantiate new BigInteger from negativeBytes array.
Console.Write("Converted {0:N0} to the byte array ", negativeValue);
foreach (byte byteValue in negativeBytes)
Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
negativeValue2 = new BigInteger(negativeBytes);
Console.WriteLine("Converted the byte array to {0:N0}", negativeValue2);
Console.WriteLine();
// Instantiate new BigInteger from positiveBytes array.
Console.Write("Converted {0:N0} to the byte array ", positiveValue);
foreach (byte byteValue in positiveBytes)
Console.Write("{0:X2} ", byteValue);
Console.WriteLine();
positiveValue2 = new BigInteger(positiveBytes);
Console.WriteLine("Converted the byte array to {0:N0}", positiveValue2);
Console.WriteLine();
// The example displays the following output:
// Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
// Converted the byte array to -9,223,372,036,854,835,807
//
// Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
// Converted the byte array to 4,713,143,110,832,790,377,889
// Instantiate BigInteger values.
let positiveValue = BigInteger.Parse "4713143110832790377889"
let negativeValue = BigInteger.Add(-Int64.MaxValue, -60000)
// Create two byte arrays.
let positiveBytes = positiveValue.ToByteArray()
let negativeBytes = negativeValue.ToByteArray()
// Instantiate new BigInteger from negativeBytes array.
printf $"Converted {negativeValue:N0} to the byte array "
for byteValue in negativeBytes do
printf $"0x{byteValue:x2} "
printfn ""
let negativeValue2 = bigint negativeBytes
printfn $"Converted the byte array to {negativeValue2:N0}"
printfn ""
// Instantiate new BigInteger from positiveBytes array.
printf $"Converted {positiveValue:N0} to the byte array "
for byteValue in positiveBytes do
printf $"0x{byteValue:x2} "
printfn ""
let positiveValue2 = new BigInteger(positiveBytes)
printfn $"Converted the byte array to {positiveValue2:N0}"
printfn ""
// The example displays the following output:
// Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
// Converted the byte array to -9,223,372,036,854,835,807
//
// Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
// Converted the byte array to 4,713,143,110,832,790,377,889
' Instantiate BigInteger values.
Dim positiveValue As BigInteger = BigInteger.Parse("4713143110832790377889")
Dim negativeValue As BigInteger = BigInteger.Add(-Int64.MaxValue, -60000)
Dim positiveValue2, negativeValue2 As BigInteger
' Create two byte arrays.
Dim positiveBytes() As Byte = positiveValue.ToByteArray()
Dim negativeBytes() As Byte = negativeValue.ToByteArray()
' Instantiate new BigInteger from negativeBytes array.
Console.Write("Converted {0:N0} to the byte array ", negativeValue)
For Each byteValue As Byte In negativeBytes
Console.Write("{0:X2} ", byteValue)
Next
Console.WriteLine()
negativeValue2 = New BigInteger(negativeBytes)
Console.WriteLine("Converted the byte array to {0:N0}", negativeValue2)
Console.WriteLine()
' Instantiate new BigInteger from positiveBytes array.
Console.Write("Converted {0:N0} to the byte array ", positiveValue)
For Each byteValue As Byte In positiveBytes
Console.Write("{0:X2} ", byteValue)
Next
Console.WriteLine()
positiveValue2 = New BigInteger(positiveBytes)
Console.WriteLine("Converted the byte array to {0:N0}", positiveValue2)
Console.WriteLine()
' The example displays the following output:
' Converted -9,223,372,036,854,835,807 to the byte array A1 15 FF FF FF FF FF 7F FF
' Converted the byte array to -9,223,372,036,854,835,807
'
' Converted 4,713,143,110,832,790,377,889 to the byte array A1 15 FF FF FF FF FF 7F FF 00
' Converted the byte array to 4,713,143,110,832,790,377,889
The following example illustrates how to make sure that a positive value is not incorrectly instantiated as a negative value by adding a byte whose value is zero to the end of the array.
ulong originalNumber = UInt64.MaxValue;
byte[] bytes = BitConverter.GetBytes(originalNumber);
if (originalNumber > 0 && (bytes[bytes.Length - 1] & 0x80) > 0)
{
byte[] temp = new byte[bytes.Length];
Array.Copy(bytes, temp, bytes.Length);
bytes = new byte[temp.Length + 1];
Array.Copy(temp, bytes, temp.Length);
}
BigInteger newNumber = new BigInteger(bytes);
Console.WriteLine("Converted the UInt64 value {0:N0} to {1:N0}.",
originalNumber, newNumber);
// The example displays the following output:
// Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.
let originalNumber = UInt64.MaxValue
let mutable bytes = BitConverter.GetBytes originalNumber
if originalNumber > 0uL && (bytes[bytes.Length - 1] &&& 0x80uy) > 0uy then
let temp = Array.zeroCreate bytes.Length
Array.Copy(bytes, temp, bytes.Length)
bytes <- Array.zeroCreate (temp.Length + 1)
Array.Copy(temp, bytes, temp.Length)
let newNumber = bigint bytes
printfn $"Converted the UInt64 value {originalNumber:N0} to {newNumber:N0}."
// The example displays the following output:
// Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.
Dim originalNumber As ULong = UInt64.MaxValue
' Convert an unsigned integer to a byte array.
Dim bytes() As Byte = BitConverter.GetBytes(originalNumber)
' Determine whether the MSB of the highest-order byte is set.
If originalNumber > 0 And (bytes(bytes.Length - 1) And &h80) > 0 Then
' If the MSB is set, add one zero-value byte to the end of the array.
ReDim Preserve bytes(bytes.Length)
End If
Dim newNumber As New BigInteger(bytes)
Console.WriteLine("Converted the UInt64 value {0:N0} to {1:N0}.",
originalNumber, newNumber)
' The example displays the following output:
' Converted the UInt64 value 18,446,744,073,709,551,615 to 18,446,744,073,709,551,615.
Remarks
The individual bytes in the value array should be in little-endian order, from lowest-order byte to highest-order byte. For example, the numeric value 1,000,000,000,000 is represented as shown in the following table:
| Representation | Value |
|---|---|
| Hexadecimal string | E8D4A51000 |
| Byte array (lowest index first) | 00 10 A5 D4 E8 00 |
Most methods that convert numeric values to byte arrays, such as BigInteger.ToByteArray and BitConverter.GetBytes, return byte arrays in little-endian order.
The constructor expects positive values in the byte array to use sign-and-magnitude representation, and negative values to use two's complement representation. In other words, if the highest-order bit of the highest-order byte in value is set, the resulting BigInteger value is negative. Depending on the source of the byte array, this might cause a positive value to be misinterpreted as a negative value. Byte arrays are typically generated in the following ways:
By calling the BigInteger.ToByteArray method. Because this method returns a byte array with the highest-order bit of the highest-order byte in the array set to zero for positive values, there is no chance of misinterpreting a positive value as negative. Unmodified byte arrays created by the ToByteArray method always successfully round-trip when they are passed to the BigInteger(Byte[]) constructor.
By calling the BitConverter.GetBytes method and passing it a signed integer as a parameter. Because signed integers handle both sign-and-magnitude representation and two's complement representation, there is no chance of misinterpreting a positive value as negative.
By calling the BitConverter.GetBytes method and passing it an unsigned integer as a parameter. Because unsigned integers are represented by their magnitude only, positive values can be misinterpreted as negative values. To prevent this misinterpretation, you can add a zero-byte value to the end of the array. The example in the next section provides an illustration.
By creating a byte array either dynamically or statically without necessarily calling any of the previous methods, or by modifying an existing byte array. To prevent positive values from being misinterpreted as negative values, you can add a zero-byte value to the end of the array.
If value is an empty Byte array, the new BigInteger object is initialized to a value of BigInteger.Zero. If value is null, the constructor throws an ArgumentNullException.
See also
Applies to
BigInteger(Decimal)
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
Initializes a new instance of the BigInteger structure using a Decimal value.
public:
BigInteger(System::Decimal value);public BigInteger (decimal value);new System.Numerics.BigInteger : decimal -> System.Numerics.BigIntegerPublic Sub New (value As Decimal)Parameters
- value
- Decimal
A decimal number.
Examples
The following example illustrates the use of the BigInteger(Decimal) constructor to instantiate a BigInteger object. It defines an array of Decimal values, and then passes each value to the BigInteger(Decimal) constructor. Note that the Decimal value is truncated instead of rounded when it is assigned to the BigInteger object.
decimal[] decimalValues = { -1790.533m, -15.1514m, 18903.79m, 9180098.003m };
foreach (decimal decimalValue in decimalValues)
{
BigInteger number = new BigInteger(decimalValue);
Console.WriteLine("Instantiated BigInteger value {0} from the Decimal value {1}.",
number, decimalValue);
}
// The example displays the following output:
// Instantiated BigInteger value -1790 from the Decimal value -1790.533.
// Instantiated BigInteger value -15 from the Decimal value -15.1514.
// Instantiated BigInteger value 18903 from the Decimal value 18903.79.
// Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.
let decimalValues = [ -1790.533m; -15.1514m; 18903.79m; 9180098.003m ]
for decimalValue in decimalValues do
let number = bigint decimalValue
printfn $"Instantiated BigInteger value {number} from the Decimal value {decimalValue}."
// The example displays the following output:
// Instantiated BigInteger value -1790 from the Decimal value -1790.533.
// Instantiated BigInteger value -15 from the Decimal value -15.1514.
// Instantiated BigInteger value 18903 from the Decimal value 18903.79.
// Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.
Dim decimalValues() As Decimal = { -1790.533d, -15.1514d, 18903.79d, 9180098.003d }
For Each decimalValue As Decimal In decimalValues
Dim number As New BigInteger(decimalValue)
Console.WriteLine("Instantiated BigInteger value {0} from the Decimal value {1}.",
number, decimalValue)
Next
' The example displays the following output:
' Instantiated BigInteger value -1790 from the Decimal value -1790.533.
' Instantiated BigInteger value -15 from the Decimal value -15.1514.
' Instantiated BigInteger value 18903 from the Decimal value 18903.79.
' Instantiated BigInteger value 9180098 from the Decimal value 9180098.003.
Remarks
The result of calling this constructor is identical to explicitly assigning a Decimal value to a BigInteger variable.
Calling this constructor can cause data loss; any fractional part of value is truncated when instantiating a BigInteger object.
Applies to
BigInteger(Double)
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
Initializes a new instance of the BigInteger structure using a double-precision floating-point value.
public:
BigInteger(double value);public BigInteger (double value);new System.Numerics.BigInteger : double -> System.Numerics.BigIntegerPublic Sub New (value As Double)Parameters
- value
- Double
A double-precision floating-point value.
Exceptions
value is NaN, NegativeInfinity, or PositiveInfinity.
Examples
The following example illustrates the use of the BigInteger(Double) constructor to instantiate a BigInteger object. It also illustrates the loss of precision that may occur when you use the Double data type. A Double is assigned a large value, which is then assigned to a BigInteger object. As the output shows, this assignment involves a loss of precision. Both values are then incremented by one. The output shows that the BigInteger object reflects the changed value, whereas the Double object does not.
// Create a BigInteger from a large double value.
double doubleValue = -6e20;
BigInteger bigIntValue = new BigInteger(doubleValue);
Console.WriteLine("Original Double value: {0:N0}", doubleValue);
Console.WriteLine("Original BigInteger value: {0:N0}", bigIntValue);
// Increment and then display both values.
doubleValue++;
bigIntValue += BigInteger.One;
Console.WriteLine("Incremented Double value: {0:N0}", doubleValue);
Console.WriteLine("Incremented BigInteger value: {0:N0}", bigIntValue);
// The example displays the following output:
// Original Double value: -600,000,000,000,000,000,000
// Original BigInteger value: -600,000,000,000,000,000,000
// Incremented Double value: -600,000,000,000,000,000,000
// Incremented BigInteger value: -599,999,999,999,999,999,999
// Create a BigInteger from a large double value.
let doubleValue = -6e20
let bigIntValue = bigint doubleValue
printfn $"Original Double value: {doubleValue:N0}"
printfn $"Original BigInteger value: {bigIntValue:N0}"
// Increment and then display both values.
let doubleValue = doubleValue + 1.
let bigIntValue = bigIntValue + BigInteger.One
printfn $"Incremented Double value: {doubleValue:N0}"
printfn $"Incremented BigInteger value: {bigIntValue:N0}"
// The example displays the following output:
// Original Double value: -600,000,000,000,000,000,000
// Original BigInteger value: -600,000,000,000,000,000,000
// Incremented Double value: -600,000,000,000,000,000,000
// Incremented BigInteger value: -599,999,999,999,999,999,999
' Create a BigInteger from a large double value.
Dim doubleValue As Double = -6e20
Dim bigIntValue As New BigInteger(doubleValue)
Console.WriteLine("Original Double value: {0:N0}", doubleValue)
Console.WriteLine("Original BigInteger value: {0:N0}", bigIntValue)
' Increment and then display both values.
doubleValue += 1
bigIntValue += BigInteger.One
Console.WriteLine("Incremented Double value: {0:N0}", doubleValue)
Console.WriteLine("Incremented BigInteger value: {0:N0}", bigIntValue)
' The example displays the following output:
' Original Double value: -600,000,000,000,000,000,000
' Original BigInteger value: -600,000,000,000,000,000,000
' Incremented Double value: -600,000,000,000,000,000,000
' Incremented BigInteger value: -599,999,999,999,999,999,999
Remarks
Any fractional part of the value parameter is truncated when instantiating a BigInteger object.
Because of the lack of precision of the Double data type, calling this constructor can cause data loss.
The BigInteger value that results from calling this constructor is identical to the value that results from explicitly assigning a Double value to a BigInteger.
Applies to
BigInteger(Int32)
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.
public:
BigInteger(int value);public BigInteger (int value);new System.Numerics.BigInteger : int -> System.Numerics.BigIntegerPublic Sub New (value As Integer)Parameters
- value
- Int32
A 32-bit signed integer.
Examples
The following example calls the BigInteger(Int32) constructor to instantiate BigInteger values from an array of 32-bit integers. It also uses implicit conversion to assign each 32-bit integer value to a BigInteger variable. It then compares the two values to establish that the resulting BigInteger values are the same.
int[] integers = { Int32.MinValue, -10534, -189, 0, 17, 113439,
Int32.MaxValue };
BigInteger constructed, assigned;
foreach (int number in integers)
{
constructed = new BigInteger(number);
assigned = number;
Console.WriteLine("{0} = {1}: {2}", constructed, assigned,
constructed.Equals(assigned));
}
// The example displays the following output:
// -2147483648 = -2147483648: True
// -10534 = -10534: True
// -189 = -189: True
// 0 = 0: True
// 17 = 17: True
// 113439 = 113439: True
// 2147483647 = 2147483647: True
let integers = [ Int32.MinValue; -10534; -189; 0; 17; 113439; Int32.MaxValue ]
for number in integers do
let constructed = bigint number
let assigned = number
printfn $"{constructed} = {assigned}: {constructed.Equals assigned}"
// The example displays the following output:
// -2147483648 = -2147483648: True
// -10534 = -10534: True
// -189 = -189: True
// 0 = 0: True
// 17 = 17: True
// 113439 = 113439: True
// 2147483647 = 2147483647: True
Dim integers() As Integer = { Int32.MinValue, -10534, -189, 0, 17, 113439,
Int32.MaxValue }
Dim constructed, assigned As BigInteger
For Each number As Integer In integers
constructed = New BigInteger(number)
assigned = number
Console.WriteLine("{0} = {1}: {2}", constructed, assigned,
constructed.Equals(assigned))
Next
' The example displays the following output:
' -2147483648 = -2147483648: True
' -10534 = -10534: True
' -189 = -189: True
' 0 = 0: True
' 17 = 17: True
' 113439 = 113439: True
' 2147483647 = 2147483647: True
Remarks
There is no loss of precision when instantiating a BigInteger object by using this constructor.
The BigInteger value that results from calling this constructor is identical to the value that results from assigning an Int32 value to a BigInteger.
The BigInteger structure does not include constructors with a parameter of type Byte, Int16, SByte, or UInt16. However, the Int32 type supports the implicit conversion of 8-bit and 16-bit signed and unsigned integers to signed 32-bit integers. As a result, this constructor is called if value is any one of these four integral types.
Applies to
BigInteger(Int64)
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.
public:
BigInteger(long value);public BigInteger (long value);new System.Numerics.BigInteger : int64 -> System.Numerics.BigIntegerPublic Sub New (value As Long)Parameters
- value
- Int64
A 64-bit signed integer.
Examples
The following example calls the BigInteger(Int64) constructor to instantiate BigInteger values from an array of 64-bit integers. It also uses implicit conversion to assign each 64-bit integer value to a BigInteger variable. It then compares the two values to establish that the resulting BigInteger values are the same.
long[] longs = { Int64.MinValue, -10534, -189, 0, 17, 113439,
Int64.MaxValue };
BigInteger constructed, assigned;
foreach (long number in longs)
{
constructed = new BigInteger(number);
assigned = number;
Console.WriteLine("{0} = {1}: {2}", constructed, assigned,
constructed.Equals(assigned));
}
// The example displays the following output:
// -2147483648 = -2147483648: True
// -10534 = -10534: True
// -189 = -189: True
// 0 = 0: True
// 17 = 17: True
// 113439 = 113439: True
// 2147483647 = 2147483647: True
let longs = [ Int64.MinValue; -10534; -189; 0; 17; 113439; Int64.MaxValue ]
for number in longs do
let constructed = bigint number
let assigned = number
printfn $"{constructed} = {assigned}: {constructed.Equals assigned}"
// The example displays the following output:
// -2147483648 = -2147483648: True
// -10534 = -10534: True
// -189 = -189: True
// 0 = 0: True
// 17 = 17: True
// 113439 = 113439: True
// 2147483647 = 2147483647: True
Dim longs() As Long = { Int64.MinValue, -10534, -189, 0, 17, 113439,
Int64.MaxValue }
Dim constructed, assigned As BigInteger
For Each number As Long In longs
constructed = New BigInteger(number)
assigned = number
Console.WriteLine("{0} = {1}: {2}", constructed, assigned,
constructed.Equals(assigned))
Next
' The example displays the following output:
' -2147483648 = -2147483648: True
' -10534 = -10534: True
' -189 = -189: True
' 0 = 0: True
' 17 = 17: True
' 113439 = 113439: True
' 2147483647 = 2147483647: True
Remarks
There is no loss of precision when instantiating a BigInteger object by using this constructor.
The BigInteger value that results from calling this constructor is identical to the value that results from assigning an Int64 value to a BigInteger.
Applies to
BigInteger(Single)
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
Initializes a new instance of the BigInteger structure using a single-precision floating-point value.
public:
BigInteger(float value);public BigInteger (float value);new System.Numerics.BigInteger : single -> System.Numerics.BigIntegerPublic Sub New (value As Single)Parameters
- value
- Single
A single-precision floating-point value.
Exceptions
value is NaN, NegativeInfinity, or PositiveInfinity.
Examples
The following example illustrates the use of the BigInteger(Single) constructor to instantiate a BigInteger object. It also illustrates the loss of precision that may occur when you use the Single data type. A Single is assigned a large negative value, which is then assigned to a BigInteger object. As the output shows, this assignment involves a loss of precision. Both values are then incremented by one. The output shows that the BigInteger object reflects the changed value, whereas the Single object does not.
// Create a BigInteger from a large negative Single value
float negativeSingle = Single.MinValue;
BigInteger negativeNumber = new BigInteger(negativeSingle);
Console.WriteLine(negativeSingle.ToString("N0"));
Console.WriteLine(negativeNumber.ToString("N0"));
negativeSingle++;
negativeNumber++;
Console.WriteLine(negativeSingle.ToString("N0"));
Console.WriteLine(negativeNumber.ToString("N0"));
// The example displays the following output:
// -340,282,300,000,000,000,000,000,000,000,000,000,000
// -340,282,346,638,528,859,811,704,183,484,516,925,440
// -340,282,300,000,000,000,000,000,000,000,000,000,000
// -340,282,346,638,528,859,811,704,183,484,516,925,439
// Create a BigInteger from a large negative Single value
let negativeSingle = Single.MinValue
let negativeNumber = bigint negativeSingle
printfn $"""{negativeSingle.ToString "N0"}"""
printfn $"""{negativeNumber.ToString "N0"}"""
let negativeSingle = negativeSingle + 1f
let negativeNumber = negativeNumber + 1I
printfn $"""{negativeSingle.ToString "N0"}"""
printfn $"""{negativeNumber.ToString "N0"}"""
// The example displays the following output:
// -340,282,300,000,000,000,000,000,000,000,000,000,000
// -340,282,346,638,528,859,811,704,183,484,516,925,440
// -340,282,300,000,000,000,000,000,000,000,000,000,000
// -340,282,346,638,528,859,811,704,183,484,516,925,439
' Create a BigInteger from a large negative Single value
Dim negativeSingle As Single = Single.MinValue
Dim negativeNumber As New BigInteger(negativeSingle)
Console.WriteLine(negativeSingle.ToString("N0"))
Console.WriteLine(negativeNumber.ToString("N0"))
negativeSingle += 1
negativeNumber += 1
Console.WriteLine(negativeSingle.ToString("N0"))
Console.WriteLine(negativeNumber.ToString("N0"))
' The example displays the following output:
' -340,282,300,000,000,000,000,000,000,000,000,000,000
' -340,282,346,638,528,859,811,704,183,484,516,925,440
' -340,282,300,000,000,000,000,000,000,000,000,000,000
' -340,282,346,638,528,859,811,704,183,484,516,925,439
Remarks
Any fractional part of the value parameter is truncated when instantiating a BigInteger object.
Because of the lack of precision of the Single data type, calling this constructor can result in data loss.
The BigInteger value that results from calling this constructor is identical to the value that results from explicitly assigning a Single value to a BigInteger.
Applies to
BigInteger(UInt32)
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
Important
This API is not CLS-compliant.
- CLS-compliant alternative
- System.Numerics.BigInteger.BigInteger(Int64)
Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.
public:
BigInteger(System::UInt32 value);[System.CLSCompliant(false)]
public BigInteger (uint value);[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : uint32 -> System.Numerics.BigIntegerPublic Sub New (value As UInteger)Parameters
- value
- UInt32
An unsigned 32-bit integer value.
- Attributes
Examples
The following example uses the BigInteger(UInt32) constructor and an assignment statement to initialize BigInteger values from an array of unsigned 32-bit integers. It then compares the two values to demonstrate that the two methods of initializing a BigInteger value produce identical results.
uint[] unsignedValues = { 0, 16704, 199365, UInt32.MaxValue };
foreach (uint unsignedValue in unsignedValues)
{
BigInteger constructedNumber = new BigInteger(unsignedValue);
BigInteger assignedNumber = unsignedValue;
if (constructedNumber.Equals(assignedNumber))
Console.WriteLine("Both methods create a BigInteger whose value is {0:N0}.",
constructedNumber);
else
Console.WriteLine("{0:N0} ≠ {1:N0}", constructedNumber, assignedNumber);
}
// The example displays the following output:
// Both methods create a BigInteger whose value is 0.
// Both methods create a BigInteger whose value is 16,704.
// Both methods create a BigInteger whose value is 199,365.
// Both methods create a BigInteger whose value is 4,294,967,295.
let unsignedValues = [ 0u; 16704u; 199365u; UInt32.MaxValue ]
for unsignedValue in unsignedValues do
let constructedNumber = bigint unsignedValue
let assignedNumber = unsignedValue
if constructedNumber.Equals assignedNumber then
printfn $"Both methods create a BigInteger whose value is {constructedNumber:N0}."
else
printfn $"{constructedNumber:N0} ≠ {assignedNumber:N0}"
// The example displays the following output:
// Both methods create a BigInteger whose value is 0.
// Both methods create a BigInteger whose value is 16,704.
// Both methods create a BigInteger whose value is 199,365.
// Both methods create a BigInteger whose value is 4,294,967,295.
Dim unsignedValues() As UInteger = { 0, 16704, 199365, UInt32.MaxValue }
For Each unsignedValue As UInteger In unsignedValues
Dim constructedNumber As New BigInteger(unsignedValue)
Dim assignedNumber As BigInteger = unsignedValue
If constructedNumber.Equals(assignedNumber) Then
Console.WriteLine("Both methods create a BigInteger whose value is {0:N0}.",
constructedNumber)
Else
Console.WriteLine("{0:N0} ≠ {1:N0}", constructedNumber, assignedNumber)
End If
Next
' The example displays the following output:
' Both methods create a BigInteger whose value is 0.
' Both methods create a BigInteger whose value is 16,704.
' Both methods create a BigInteger whose value is 199,365.
' Both methods create a BigInteger whose value is 4,294,967,295.
Remarks
There is no loss of precision when instantiating a BigInteger using this constructor.
The BigInteger value that results from calling this constructor is identical to the value that results from assigning a UInt32 value to a BigInteger.
Applies to
BigInteger(UInt64)
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
Important
This API is not CLS-compliant.
- CLS-compliant alternative
- System.Numerics.BigInteger.BigInteger(Double)
Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.
public:
BigInteger(System::UInt64 value);[System.CLSCompliant(false)]
public BigInteger (ulong value);[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : uint64 -> System.Numerics.BigIntegerPublic Sub New (value As ULong)Parameters
- value
- UInt64
An unsigned 64-bit integer.
- Attributes
Examples
The following example uses the BigInteger(UInt64) constructor to instantiate a BigInteger object whose value is equal to MaxValue.
ulong unsignedValue = UInt64.MaxValue;
BigInteger number = new BigInteger(unsignedValue);
Console.WriteLine(number.ToString("N0"));
// The example displays the following output:
// 18,446,744,073,709,551,615
let unsignedValue = UInt64.MaxValue
let number = bigint unsignedValue
printfn $"{number:N0}"
// The example displays the following output:
// 18,446,744,073,709,551,615
Dim unsignedValue As ULong = UInt64.MaxValue
Dim number As New BigInteger(unsignedValue)
Console.WriteLine(number.ToString("N0"))
' The example displays the following output:
' 18,446,744,073,709,551,615
Remarks
There is no loss of precision when instantiating a BigInteger using this constructor.
The BigInteger value that results from calling this constructor is identical to the value that results from assigning a UInt64 value to a BigInteger.
Applies to
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
- Source:
- BigInteger.cs
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.
public BigInteger (ReadOnlySpan<byte> value, bool isUnsigned = false, bool isBigEndian = false);new System.Numerics.BigInteger : ReadOnlySpan<byte> * bool * bool -> System.Numerics.BigIntegerPublic Sub New (value As ReadOnlySpan(Of Byte), Optional isUnsigned As Boolean = false, Optional isBigEndian As Boolean = false)Parameters
- value
- ReadOnlySpan<Byte>
A read-only span of bytes representing the big integer.
- isUnsigned
- Boolean
true to indicate value uses unsigned encoding; otherwise, false (the default value).
- isBigEndian
- Boolean
true to indicate value is in big-endian byte order; otherwise, false (the default value).
