Bagikan melalui

BigInteger Konstruktor

  • Referensi

Definisi

Ruang nama:
System.Numerics
Rakitan:
System.Runtime.Numerics.dll
Rakitan:
System.Numerics.dll
Rakitan:
netstandard.dll

Menginisialisasi instans BigInteger baru struktur.

Overload

BigInteger(Byte[])

Menginisialisasi instans BigInteger baru struktur menggunakan nilai dalam array byte.
BigInteger(Decimal)

Menginisialisasi instans BigInteger baru struktur menggunakan Decimal nilai.
BigInteger(Double)

Menginisialisasi instans BigInteger baru struktur menggunakan nilai floating-point presisi ganda.
BigInteger(Int32)

Menginisialisasi instans BigInteger baru struktur menggunakan nilai bilangan bulat bertanda tangan 32-bit.
BigInteger(Int64)

Menginisialisasi instans BigInteger baru struktur menggunakan nilai bilangan bulat bertanda tangan 64-bit.
BigInteger(Single)

Menginisialisasi instans BigInteger baru struktur menggunakan nilai floating-point presisi tunggal.
BigInteger(UInt32)

Menginisialisasi instans BigInteger baru struktur menggunakan nilai bilangan bulat 32-bit yang tidak ditandatangani.
BigInteger(UInt64)

Menginisialisasi instans BigInteger baru struktur dengan nilai bilangan bulat 64-bit yang tidak ditandatangani.
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Menginisialisasi instans BigInteger baru struktur menggunakan nilai dalam rentang byte baca-saja, dan secara opsional menunjukkan pengodean penandatanganan dan urutan byte endianness.

BigInteger(Byte[])

Sumber:
BigInteger.cs
Sumber:
BigInteger.cs
Sumber:
BigInteger.cs

Penting

API ini bukan kompatibel CLS.

Menginisialisasi instans BigInteger baru struktur menggunakan nilai dalam array byte.

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

Parameter

value
Byte[]

Array nilai byte dalam urutan little-endian.

Atribut
CLSCompliantAttribute

Pengecualian

ArgumentNullException

valueadalah null.

Contoh

Contoh berikut membuat instans BigInteger objek dari array byte 5 elemen yang nilainya adalah {5, 4, 3, 2, 1}. Kemudian menampilkan nilai , direpresentasikan BigInteger sebagai angka desimal dan heksadesimal, ke konsol. Perbandingan array input dengan output teks memperjelas BigInteger mengapa kelebihan beban BigInteger konstruktor kelas ini membuat objek yang nilainya 4328719365 (atau 0x102030405). Elemen pertama dari array byte, yang nilainya adalah 5, mendefinisikan nilai byte urutan terendah dari BigInteger objek, yang 0x05. Elemen kedua dari array byte, yang nilainya adalah 4, mendefinisikan nilai byte kedua objek BigInteger , yang 0x04, dan sebagainya.

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

Contoh berikut membuat instans nilai positif dan negatif BigInteger , meneruskannya ke ToByteArray metode , lalu memulihkan nilai asli BigInteger dari array byte yang dihasilkan. Perhatikan bahwa dua nilai diwakili oleh array byte yang identik. Satu-satunya perbedaan di antara mereka adalah di bit paling signifikan dari elemen terakhir dalam array byte. Bit ini diatur (nilai byte 0xFF) jika array dibuat dari nilai negatif BigInteger . Bit tidak diatur (nilai byte adalah nol), jika array dibuat dari nilai positif BigInteger .

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

Contoh berikut menggambarkan cara memastikan bahwa nilai positif tidak salah dibuat sebagai nilai negatif dengan menambahkan byte yang nilainya nol hingga akhir 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.

Keterangan

Byte individu dalam value array harus dalam urutan little-endian, dari byte urutan terendah hingga byte urutan tertinggi. Misalnya, nilai numerik 1.000.000.000.000 direpresentasikan seperti yang ditunjukkan dalam tabel berikut:
String heksadesimal E8D4A51000
Byte array (indeks terendah terlebih dahulu) 00 10 A5 D4 E8 00

Sebagian besar metode yang mengonversi nilai numerik menjadi array byte, seperti BigInteger.ToByteArray dan BitConverter.GetBytes, mengembalikan array byte dalam urutan little-endian.

Konstruktor mengharapkan nilai positif dalam array byte menggunakan representasi tanda dan besar, dan nilai negatif untuk menggunakan representasi pelengkap dua. Dengan kata lain, jika bit urutan tertinggi dari byte urutan tertinggi di value diatur, nilai yang dihasilkan BigInteger adalah negatif. Bergantung pada sumber array byte, ini dapat menyebabkan nilai positif disalahartikan sebagai nilai negatif. Array byte biasanya dihasilkan dengan cara berikut:

  • Dengan memanggil BigInteger.ToByteArray metode . Karena metode ini mengembalikan array byte dengan bit urutan tertinggi dari byte urutan tertinggi dalam array yang diatur ke nol untuk nilai positif, tidak ada kemungkinan salah menafsirkan nilai positif sebagai negatif. Array byte yang tidak dimodifikasi yang dibuat oleh ToByteArray metode selalu berhasil melakukan komunikasi dua arah ketika diteruskan ke BigInteger(Byte[]) konstruktor.

  • Dengan memanggil BitConverter.GetBytes metode dan meneruskannya bilangan bulat bertanda tangan sebagai parameter. Karena bilangan bulat yang ditandatangani menangani representasi tanda dan besar dan representasi pelengkap dua, tidak ada kemungkinan salah menafsirkan nilai positif sebagai negatif.

  • Dengan memanggil BitConverter.GetBytes metode dan meneruskannya bilangan bulat yang tidak ditandatangani sebagai parameter. Karena bilangan bulat yang tidak ditandatangani hanya diwakili oleh besarnya, nilai positif dapat disalahartikan sebagai nilai negatif. Untuk mencegah misinterpretasi ini, Anda dapat menambahkan nilai nol byte ke akhir array. Contoh di bagian berikutnya memberikan ilustrasi.

  • Dengan membuat array byte baik secara dinamis atau statis tanpa harus memanggil salah satu metode sebelumnya, atau dengan memodifikasi array byte yang ada. Untuk mencegah nilai positif disalahartikan sebagai nilai negatif, Anda dapat menambahkan nilai nol byte ke akhir array.

Jika value adalah array kosong Byte , objek baru BigInteger diinisialisasi ke nilai BigInteger.Zero. Jika value adalah null, konstruktor melempar ArgumentNullException.

Lihat juga

Berlaku untuk

BigInteger(Decimal)

Sumber:
BigInteger.cs
Sumber:
BigInteger.cs
Sumber:
BigInteger.cs

Menginisialisasi instans BigInteger baru struktur menggunakan Decimal nilai.

public:
 BigInteger(System::Decimal value);
public BigInteger (decimal value);
new System.Numerics.BigInteger : decimal -> System.Numerics.BigInteger
Public Sub New (value As Decimal)

Parameter

value
Decimal

Angka desimal.

Contoh

Contoh berikut mengilustrasikan penggunaan BigInteger(Decimal) konstruktor untuk membuat instans BigInteger objek. Ini mendefinisikan array Decimal nilai, lalu meneruskan setiap nilai ke BigInteger(Decimal) konstruktor. Perhatikan bahwa Decimal nilai dipotok alih-alih dibulatkan saat ditetapkan ke BigInteger objek.

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.

Keterangan

Hasil pemanggilan konstruktor ini identik dengan secara eksplisit menetapkan Decimal nilai ke BigInteger variabel.

Memanggil konstruktor ini dapat menyebabkan kehilangan data; bagian pecahan apa pun dari value dipotok saat membuat BigInteger instans objek.

Berlaku untuk

BigInteger(Double)

Sumber:
BigInteger.cs
Sumber:
BigInteger.cs
Sumber:
BigInteger.cs

Menginisialisasi instans BigInteger baru struktur menggunakan nilai floating-point presisi ganda.

public:
 BigInteger(double value);
public BigInteger (double value);
new System.Numerics.BigInteger : double -> System.Numerics.BigInteger
Public Sub New (value As Double)

Parameter

value
Double

Nilai floating-point presisi ganda.

Pengecualian

OverflowException

value adalah NaN, NegativeInfinity, atau PositiveInfinity.

Contoh

Contoh berikut mengilustrasikan penggunaan BigInteger(Double) konstruktor untuk membuat instans BigInteger objek. Ini juga menggambarkan hilangnya presisi yang mungkin terjadi ketika Anda menggunakan Double jenis data. Double diberi nilai besar, yang kemudian ditetapkan ke BigInteger objek . Seperti yang ditunjukkan oleh output, penugasan ini melibatkan hilangnya presisi. Kedua nilai kemudian bertambah satu. Output menunjukkan bahwa BigInteger objek mencerminkan nilai yang diubah, sedangkan Double objek tidak.

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

Keterangan

Setiap bagian pecahan dari value parameter dipotok saat membuat instans BigInteger objek.

Karena kurangnya presisi Double jenis data, memanggil konstruktor ini dapat menyebabkan kehilangan data.

Nilai BigInteger yang dihasilkan dari memanggil konstruktor ini identik dengan nilai yang dihasilkan dari secara eksplisit Double menetapkan nilai ke BigInteger.

Berlaku untuk

BigInteger(Int32)

Sumber:
BigInteger.cs
Sumber:
BigInteger.cs
Sumber:
BigInteger.cs

Menginisialisasi instans BigInteger baru struktur menggunakan nilai bilangan bulat bertanda tangan 32-bit.

public:
 BigInteger(int value);
public BigInteger (int value);
new System.Numerics.BigInteger : int -> System.Numerics.BigInteger
Public Sub New (value As Integer)

Parameter

value
Int32

Bilangan bulat bertanda 32-bit.

Contoh

Contoh berikut memanggil BigInteger(Int32) konstruktor untuk membuat BigInteger instans nilai dari array bilangan bulat 32-bit. Ini juga menggunakan konversi implisit untuk menetapkan setiap nilai bilangan bulat 32-bit ke BigInteger variabel. Kemudian membandingkan dua nilai untuk menetapkan bahwa nilai yang dihasilkan BigInteger sama.

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

Keterangan

Tidak ada kehilangan presisi saat membuat BigInteger instans objek dengan menggunakan konstruktor ini.

Nilai BigInteger yang dihasilkan dari memanggil konstruktor ini identik dengan nilai yang dihasilkan dari menetapkan Int32 nilai ke BigInteger.

Struktur BigInteger tidak termasuk konstruktor dengan parameter jenis Byte, , Int16SByte, atau UInt16. Namun, jenis ini Int32 mendukung konversi implisit bilangan bulat 8-bit dan 16-bit yang ditandatangani dan tidak ditandatangani ke bilangan bulat 32-bit yang ditandatangani. Akibatnya, konstruktor ini dipanggil jika value adalah salah satu dari empat jenis integral ini.

Berlaku untuk

BigInteger(Int64)

Sumber:
BigInteger.cs
Sumber:
BigInteger.cs
Sumber:
BigInteger.cs

Menginisialisasi instans BigInteger baru struktur menggunakan nilai bilangan bulat bertanda tangan 64-bit.

public:
 BigInteger(long value);
public BigInteger (long value);
new System.Numerics.BigInteger : int64 -> System.Numerics.BigInteger
Public Sub New (value As Long)

Parameter

value
Int64

Bilangan bulat bertanda 64-bit.

Contoh

Contoh berikut memanggil BigInteger(Int64) konstruktor untuk membuat BigInteger instans nilai dari array bilangan bulat 64-bit. Ini juga menggunakan konversi implisit untuk menetapkan setiap nilai bilangan bulat 64-bit ke BigInteger variabel. Kemudian membandingkan dua nilai untuk menetapkan bahwa nilai yang dihasilkan BigInteger sama.

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

Keterangan

Tidak ada kehilangan presisi saat membuat BigInteger instans objek dengan menggunakan konstruktor ini.

Nilai BigInteger yang dihasilkan dari memanggil konstruktor ini identik dengan nilai yang dihasilkan dari menetapkan Int64 nilai ke BigInteger.

Berlaku untuk

BigInteger(Single)

Sumber:
BigInteger.cs
Sumber:
BigInteger.cs
Sumber:
BigInteger.cs

Menginisialisasi instans BigInteger baru struktur menggunakan nilai floating-point presisi tunggal.

public:
 BigInteger(float value);
public BigInteger (float value);
new System.Numerics.BigInteger : single -> System.Numerics.BigInteger
Public Sub New (value As Single)

Parameter

value
Single

Nilai floating-point presisi tunggal.

Pengecualian

OverflowException

value adalah NaN, NegativeInfinity, atau PositiveInfinity.

Contoh

Contoh berikut mengilustrasikan penggunaan BigInteger(Single) konstruktor untuk membuat instans BigInteger objek. Ini juga menggambarkan hilangnya presisi yang mungkin terjadi ketika Anda menggunakan Single jenis data. Single diberi nilai negatif besar, yang kemudian ditetapkan ke BigInteger objek. Seperti yang ditunjukkan oleh output, penugasan ini melibatkan hilangnya presisi. Kedua nilai kemudian bertambah satu. Output menunjukkan bahwa BigInteger objek mencerminkan nilai yang diubah, sedangkan Single objek tidak.

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

Keterangan

Setiap bagian pecahan dari value parameter dipotok saat membuat instans BigInteger objek.

Karena kurangnya presisi Single jenis data, memanggil konstruktor ini dapat mengakibatkan hilangnya data.

Nilai BigInteger yang dihasilkan dari memanggil konstruktor ini identik dengan nilai yang dihasilkan dari secara eksplisit Single menetapkan nilai ke BigInteger.

Berlaku untuk

BigInteger(UInt32)

Sumber:
BigInteger.cs
Sumber:
BigInteger.cs
Sumber:
BigInteger.cs

Penting

API ini bukan kompatibel CLS.

Alternatif kompatibel CLS
System.Numerics.BigInteger.BigInteger(Int64)

Menginisialisasi instans BigInteger baru struktur menggunakan nilai bilangan bulat 32-bit yang tidak ditandatangani.

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)

Parameter

value
UInt32

Nilai bilangan bulat 32-bit yang tidak bertanda.

Atribut
CLSCompliantAttribute

Contoh

Contoh berikut menggunakan BigInteger(UInt32) konstruktor dan pernyataan penugasan untuk menginisialisasi BigInteger nilai dari array bilangan bulat 32-bit yang tidak ditandatangani. Kemudian membandingkan dua nilai untuk menunjukkan bahwa dua metode inisialisasi nilai menghasilkan hasil yang BigInteger identik.

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.

Keterangan

Tidak ada kehilangan presisi saat membuat instans BigInteger menggunakan konstruktor ini.

Nilai BigInteger yang dihasilkan dari memanggil konstruktor ini identik dengan nilai yang dihasilkan dari menetapkan UInt32 nilai ke BigInteger.

Berlaku untuk

BigInteger(UInt64)

Sumber:
BigInteger.cs
Sumber:
BigInteger.cs
Sumber:
BigInteger.cs

Penting

API ini bukan kompatibel CLS.

Alternatif kompatibel CLS
System.Numerics.BigInteger.BigInteger(Double)

Menginisialisasi instans BigInteger baru struktur dengan nilai bilangan bulat 64-bit yang tidak ditandatangani.

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)

Parameter

value
UInt64

Bilangan bulat 64-bit yang tidak ditandatangani.

Atribut
CLSCompliantAttribute

Contoh

Contoh berikut menggunakan BigInteger(UInt64) konstruktor untuk membuat BigInteger instans objek yang nilainya sama dengan 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

Keterangan

Tidak ada kehilangan presisi saat membuat instans BigInteger menggunakan konstruktor ini.

Nilai BigInteger yang dihasilkan dari memanggil konstruktor ini identik dengan nilai yang dihasilkan dari menetapkan UInt64 nilai ke BigInteger.

Berlaku untuk

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Sumber:
BigInteger.cs
Sumber:
BigInteger.cs
Sumber:
BigInteger.cs

Menginisialisasi instans BigInteger baru struktur menggunakan nilai dalam rentang byte baca-saja, dan secara opsional menunjukkan pengodean penandatanganan dan urutan byte 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)

Parameter

value
ReadOnlySpan<Byte>

Rentang byte baca-saja yang mewakili bilangan bulat besar.

isUnsigned
Boolean

true untuk menunjukkan value menggunakan pengodean yang tidak ditandatangani; jika tidak, false (nilai default).

isBigEndian
Boolean

true untuk menunjukkan value dalam urutan byte big-endian; jika tidak, false (nilai default).

Berlaku untuk