BigInteger Konstruktory

Definice

Obor názvů:

System.Numerics

Sestavení:

System.Runtime.Numerics.dll

Inicializuje novou instanci BigInteger struktury.

Přetížení

BigInteger(Byte[])	Inicializuje novou instanci BigInteger struktury pomocí hodnot v bajtovém poli.
BigInteger(Decimal)	Inicializuje novou instanci BigInteger struktury pomocí Decimal hodnoty.
BigInteger(Double)	Inicializuje novou instanci BigInteger struktury pomocí hodnoty dvojité přesnosti s plovoucí desetinou čárkou.
BigInteger(Int32)	Inicializuje novou instanci BigInteger struktury pomocí 32bitového celočíselného čísla se sadou se sadou.
BigInteger(Int64)	Inicializuje novou instanci BigInteger struktury pomocí 64bitového celočíselného čísla se sadou se sadou.
BigInteger(Single)	Inicializuje novou instanci BigInteger struktury pomocí hodnoty s plovoucí desetinou čárkou s jednou přesností.
BigInteger(UInt32)	Inicializuje novou instanci BigInteger struktury pomocí 32bitové celočíselné hodnoty bez znaménka.
BigInteger(UInt64)	Inicializuje novou instanci BigInteger struktury s 64bitovou celočíselnou hodnotou bez znaménka.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	Inicializuje novou instanci BigInteger struktury pomocí hodnot v rozsahu bajtů jen pro čtení a volitelně označuje kódování podepisování a pořadí bajtů endianness.

BigInteger(Byte[])

Zdroj:

BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Inicializuje novou instanci BigInteger struktury pomocí hodnot v bajtovém poli.

public:
 BigInteger(cli::array <System::Byte> ^ value);

[System.CLSCompliant(false)]
public BigInteger (byte[] value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : byte[] -> System.Numerics.BigInteger

Public Sub New (value As Byte())

Parametry

value

Byte[]

Pole hodnot bajtů v pořadí little-endian.

Atributy

CLSCompliantAttribute

Výjimky

ArgumentNullException

value je null.

Příklady

Následující příklad vytvoří instanci objektu BigInteger z pole 5 prvků bajtů, jehož hodnota je {5, 4, 3, 2, 1}. Pak v konzole zobrazí BigInteger hodnotu vyjádřenou jako desetinná i šestnáctková čísla. Z porovnání vstupního pole s textovým výstupem je zřejmé, proč toto přetížení konstruktoru BigInteger třídy vytváří BigInteger objekt, jehož hodnota je 4328719365 (nebo 0x102030405). První prvek pole bajtů, jehož hodnota je 5, definuje hodnotu nejnižšího pořadí bajtů objektu BigInteger , která je 0x05. Druhý prvek pole bajtů, jehož hodnota je 4, definuje hodnotu druhého bajtu objektu BigInteger , který je 0x04 atd.

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

Následující příklad vytvoří instanci kladné a záporné BigInteger hodnoty, předá je metodě ToByteArray a poté obnoví původní BigInteger hodnoty z výsledného pole bajtů. Všimněte si, že tyto dvě hodnoty jsou reprezentovány identickými poli bajtů. Jediný rozdíl mezi nimi je v nejvýznamnější části posledního prvku v bajtovém poli. Tento bit je nastaven (hodnota bajtu je 0xFF), pokud je pole vytvořeno ze záporné BigInteger hodnoty. Bit není nastaven (hodnota bajtu je nula), pokud je pole vytvořeno z kladné BigInteger hodnoty.

// 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

Následující příklad ukazuje, jak zajistit, aby kladná hodnota nebyla nesprávně vytvořena jako záporná hodnota přidáním bajtu, jehož hodnota je nula na konec pole.

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.

Poznámky

Jednotlivé bajty v value poli by měly být v pořadí little-endian, od bajtů nejnižšího řádu až po bajt nejvyššího pořadí. Například číselná hodnota 1 000 000 000 000 000 je znázorněna jako v následující tabulce:

Šestnáctkový řetězec	E8D4A51000
Bajtové pole (první nejnižší index)	00 10 A5 D4 E8 00

Většina metod, které převádějí číselné hodnoty na pole bajtů, například BigInteger.ToByteArray a BitConverter.GetBytes, vrací pole bajtů v pořadí little-endian.

Konstruktor očekává, že kladné hodnoty v bajtovém poli budou používat reprezentaci znaménka a velikosti a záporné hodnoty budou používat reprezentaci doplňku dvojky. Jinými slovy, pokud je nastaven bit nejvyššího pořadí bajtů nejvyššího pořadí v value , výsledná BigInteger hodnota je záporná. V závislosti na zdroji pole bajtů to může způsobit, že kladná hodnota bude nesprávně interpretována jako záporná hodnota. Bajtová pole se obvykle generují následujícími způsoby:

• Voláním BigInteger.ToByteArray metody . Vzhledem k tomu, že tato metoda vrátí pole bajtů s bitem nejvyššího pořadí bajtů v poli nastaveném na nulu pro kladné hodnoty, není možné chybně interpretovat kladnou hodnotu jako zápornou. Neupravená pole bajtů vytvořená metodou ToByteArray vždy úspěšně zaokrouhlují, když jsou předány konstruktoru BigInteger(Byte[]) .

• Voláním BitConverter.GetBytes metody a předáním podepsaného celého čísla jako parametru. Vzhledem k tomu, že znaménko celá čísla zpracovávají reprezentaci znaménka i velikosti a reprezentaci dvojky, neexistuje žádná šance, že by se kladná hodnota interpretovala jako záporná.

• Voláním BitConverter.GetBytes metody a předáním celého čísla unsigned jako parametru. Vzhledem k tomu, že celá čísla bez znaménka jsou reprezentována pouze jejich velikostí, mohou být kladné hodnoty chybně interpretovány jako záporné hodnoty. Chcete-li zabránit této chybné interpretaci, můžete přidat hodnotu nula bajtů na konec pole. Příklad v další části obsahuje obrázek.

• Vytvořením pole bajtů dynamicky nebo staticky bez nutnosti volání některé z předchozích metod, nebo úpravou existujícího pole bajtů. Chcete-li zabránit chybné interpretaci kladných hodnot jako záporných hodnot, můžete přidat hodnotu nula bajtů na konec pole.

Pokud value je pole prázdné Byte , inicializuje se nový BigInteger objekt na hodnotu BigInteger.Zero. Pokud value je null, konstruktor vyvolá .ArgumentNullException

Viz také

• ToByteArray()

BigInteger(Decimal)

Zdroj:

BigInteger.cs

Inicializuje novou instanci BigInteger struktury pomocí Decimal hodnoty.

public:
 BigInteger(System::Decimal value);

public BigInteger (decimal value);

new System.Numerics.BigInteger : decimal -> System.Numerics.BigInteger

Public Sub New (value As Decimal)

Parametry

value

Decimal

Desetinné číslo

Příklady

Následující příklad ukazuje použití konstruktoru BigInteger(Decimal) k vytvoření instance objektu BigInteger . Definuje pole Decimal hodnot a poté předá každou hodnotu konstruktoru BigInteger(Decimal) . Všimněte si, že při přiřazení k objektu DecimalBigInteger je hodnota zkrácena místo zaokrouhlení.

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.

Poznámky

Výsledek volání tohoto konstruktoru je stejný jako explicitní Decimal přiřazení hodnoty proměnné BigInteger .

Volání tohoto konstruktoru může způsobit ztrátu dat; při vytváření instance objektu value se zkrátí jakákoli zlomková BigInteger část.

BigInteger(Double)

Zdroj:

BigInteger.cs

Inicializuje novou instanci BigInteger struktury pomocí hodnoty dvojité přesnosti s plovoucí desetinou čárkou.

public:
 BigInteger(double value);

public BigInteger (double value);

new System.Numerics.BigInteger : double -> System.Numerics.BigInteger

Public Sub New (value As Double)

Parametry

value

Double

Hodnota s plovoucí desetinou čárkou s dvojitou přesností.

Výjimky

OverflowException

value je NaN, NegativeInfinitynebo PositiveInfinity.

Příklady

Následující příklad ukazuje použití konstruktoru BigInteger(Double) k vytvoření instance objektu BigInteger . Znázorňuje také ztrátu přesnosti, ke které může dojít při použití datového Double typu. Objektu Double je přiřazena velká hodnota, která je pak přiřazena k objektu BigInteger . Jak ukazuje výstup, toto přiřazení zahrnuje ztrátu přesnosti. Obě hodnoty se pak navýší o jednu. Výstup ukazuje, že BigInteger objekt odráží změněnou hodnotu, zatímco Double objekt nikoli.

// 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

Poznámky

Při vytváření instance objektu value se zkrátí jakákoli zlomková část parametru BigInteger .

Vzhledem k nedostatku přesnosti datového typu může volání tohoto konstruktoru Double způsobit ztrátu dat.

Hodnota BigInteger , která je výsledkem volání tohoto konstruktoru, je shodná s hodnotou, která je výsledkem explicitního přiřazení Double hodnoty k BigInteger.

BigInteger(Int32)

Zdroj:

BigInteger.cs

Inicializuje novou instanci BigInteger struktury pomocí 32bitového celočíselného čísla se sadou se sadou.

public:
 BigInteger(int value);

public BigInteger (int value);

new System.Numerics.BigInteger : int -> System.Numerics.BigInteger

Public Sub New (value As Integer)

Parametry

value

Int32

32bitové celé číslo se signoumimi sadou.

Příklady

Následující příklad volá BigInteger(Int32) konstruktor k vytvoření BigInteger instance hodnot z pole 32bitových celých čísel. Používá také implicitní převod k přiřazení každé 32bitové celočíselné hodnoty proměnné BigInteger . Potom tyto dvě hodnoty porovná a zjistí, že výsledné BigInteger hodnoty jsou stejné.

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

Poznámky

Při vytváření instance objektu pomocí tohoto konstruktoru BigInteger nedojde ke ztrátě přesnosti.

Hodnota BigInteger , která je výsledkem volání tohoto konstruktoru, je shodná s hodnotou, která je výsledkem přiřazení Int32 hodnoty k BigInteger.

Struktura BigInteger neobsahuje konstruktory s parametrem typu Byte, Int16, SBytenebo UInt16. Int32 Typ však podporuje implicitní převod 8bitových a 16bitových celých čísel se znaménkem a bez znaménka na 32bitová celá čísla se znaménkem. V důsledku toho je tento konstruktor volána, pokud value je některý z těchto čtyř integrálních typů.

BigInteger(Int64)

Zdroj:

BigInteger.cs

Inicializuje novou instanci BigInteger struktury pomocí 64bitového celočíselného čísla se sadou se sadou.

public:
 BigInteger(long value);

public BigInteger (long value);

new System.Numerics.BigInteger : int64 -> System.Numerics.BigInteger

Public Sub New (value As Long)

Parametry

value

Int64

64bitové celé číslo se signoum

Příklady

Následující příklad volá BigInteger(Int64) konstruktor k vytvoření BigInteger instance hodnot z pole 64bitových celých čísel. Používá také implicitní převod k přiřazení každé 64bitové celočíselné hodnoty proměnné BigInteger . Potom tyto dvě hodnoty porovná a zjistí, že výsledné BigInteger hodnoty jsou stejné.

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

Poznámky

Při vytváření instance objektu pomocí tohoto konstruktoru BigInteger nedojde ke ztrátě přesnosti.

Hodnota BigInteger , která je výsledkem volání tohoto konstruktoru, je shodná s hodnotou, která je výsledkem přiřazení Int64 hodnoty k BigInteger.

BigInteger(Single)

Zdroj:

BigInteger.cs

Inicializuje novou instanci BigInteger struktury pomocí hodnoty s plovoucí desetinou čárkou s jednou přesností.

public:
 BigInteger(float value);

public BigInteger (float value);

new System.Numerics.BigInteger : single -> System.Numerics.BigInteger

Public Sub New (value As Single)

Parametry

value

Single

Hodnota s plovoucí desetinou čárkou s jednoduchou přesností.

Výjimky

OverflowException

value je NaN, NegativeInfinitynebo PositiveInfinity.

Příklady

Následující příklad ukazuje použití konstruktoru BigInteger(Single) k vytvoření instance objektu BigInteger . Znázorňuje také ztrátu přesnosti, ke které může dojít při použití datového Single typu. Objektu Single je přiřazena velká záporná hodnota, která se pak přiřadí k objektu BigInteger . Jak ukazuje výstup, toto přiřazení zahrnuje ztrátu přesnosti. Obě hodnoty se pak navýší o jednu. Výstup ukazuje, že BigInteger objekt odráží změněnou hodnotu, zatímco Single objekt nikoli.

// 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

Poznámky

Při vytváření instance objektu value se zkrátí jakákoli zlomková část parametru BigInteger .

Vzhledem k nedostatku přesnosti datového Single typu může volání tohoto konstruktoru způsobit ztrátu dat.

Hodnota BigInteger , která je výsledkem volání tohoto konstruktoru, je shodná s hodnotou, která je výsledkem explicitního přiřazení Single hodnoty k BigInteger.

BigInteger(UInt32)

Zdroj:

BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Numerics.BigInteger.BigInteger(Int64)

Inicializuje novou instanci BigInteger struktury pomocí 32bitové celočíselné hodnoty bez znaménka.

public:
 BigInteger(System::UInt32 value);

[System.CLSCompliant(false)]
public BigInteger (uint value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : uint32 -> System.Numerics.BigInteger

Public Sub New (value As UInteger)

Parametry

value

UInt32

32bitová celočíselná hodnota bez znaménka.

Atributy

CLSCompliantAttribute

Příklady

Následující příklad používá BigInteger(UInt32) konstruktor a příkaz assignment k inicializaci BigInteger hodnot z pole 32bitových celých čísel bez znaménka. Potom tyto dvě hodnoty porovná a demonstruje, že obě metody inicializace BigInteger hodnoty generují identické výsledky.

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.

Poznámky

Při vytváření instance pomocí tohoto konstruktoru BigInteger nedojde ke ztrátě přesnosti.

Hodnota BigInteger , která je výsledkem volání tohoto konstruktoru, je shodná s hodnotou, která je výsledkem přiřazení UInt32 hodnoty k BigInteger.

BigInteger(UInt64)

Zdroj:

BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS

System.Numerics.BigInteger.BigInteger(Double)

Inicializuje novou instanci BigInteger struktury s 64bitovou celočíselnou hodnotou bez znaménka.

public:
 BigInteger(System::UInt64 value);

[System.CLSCompliant(false)]
public BigInteger (ulong value);

[<System.CLSCompliant(false)>]
new System.Numerics.BigInteger : uint64 -> System.Numerics.BigInteger

Public Sub New (value As ULong)

Parametry

value

UInt64

64bitové celé číslo bez znaménka.

Atributy

CLSCompliantAttribute

Příklady

Následující příklad používá BigInteger(UInt64) konstruktor k vytvoření instance objektu BigInteger , jehož hodnota se rovná 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

Poznámky

Při vytváření instance pomocí tohoto konstruktoru BigInteger nedojde ke ztrátě přesnosti.

Hodnota BigInteger , která je výsledkem volání tohoto konstruktoru, je shodná s hodnotou, která je výsledkem přiřazení UInt64 hodnoty k BigInteger.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Zdroj:

BigInteger.cs

Inicializuje novou instanci BigInteger struktury pomocí hodnot v rozsahu bajtů jen pro čtení a volitelně označuje kódování podepisování a pořadí bajtů endianness.

public BigInteger (ReadOnlySpan<byte> value, bool isUnsigned = false, bool isBigEndian = false);

new System.Numerics.BigInteger : ReadOnlySpan<byte> * bool * bool -> System.Numerics.BigInteger

Public Sub New (value As ReadOnlySpan(Of Byte), Optional isUnsigned As Boolean = false, Optional isBigEndian As Boolean = false)

Parametry

value

ReadOnlySpan<Byte>

Rozsah bajtů jen pro čtení představující velké celé číslo.

isUnsigned

Boolean

true k označení value používá kódování bez znaménka, false jinak (výchozí hodnota).

isBigEndian

Boolean

true označuje, že value je v bajtovém pořadí big-endian, false jinak (výchozí hodnota).