BigInteger コンストラクター

リファレンス

定義

名前空間:: System.Numerics

アセンブリ:: System.Runtime.Numerics.dll

アセンブリ:: System.Numerics.dll

アセンブリ:: netstandard.dll

重要

一部の情報は、リリース前に大きく変更される可能性があるプレリリースされた製品に関するものです。 Microsoft は、ここに記載されている情報について、明示または黙示を問わず、一切保証しません。

BigInteger 構造体の新しいインスタンスを初期化します。

オーバーロード

BigInteger(Byte[])	バイト配列の値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。
BigInteger(Decimal)	Decimal 値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。
BigInteger(Double)	倍精度浮動小数点値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。
BigInteger(Int32)	32 ビット符号付き整数値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。
BigInteger(Int64)	64 ビット符号付き整数値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。
BigInteger(Single)	単精度浮動小数点値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。
BigInteger(UInt32)	32 ビット符号なし整数値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。
BigInteger(UInt64)	64 ビット符号なし整数値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。
BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)	バイトの読み取り専用スパンを使用して、BigInteger 構造体の新しいインスタンスを初期化します。任意で、符号付きエンコードとエンディアンのバイト順を示します。

BigInteger(Byte[])

ソース:: BigInteger.cs

ソース:: BigInteger.cs

ソース:: BigInteger.cs

重要

この API は CLS 準拠ではありません。

バイト配列の値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。

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

パラメーター

value: Byte[]

リトルエンディアン順に格納されたバイト値の配列。

属性: CLSCompliantAttribute

例外

ArgumentNullException

value が nullです。

例

次の例では、 BigInteger 値が {5、4、3、2、1} の 5 要素バイト配列からオブジェクトをインスタンス化します。その後、10 進数と 16 進数の BigInteger 両方として表される値がコンソールに表示されます。入力配列とテキスト出力を比較すると、クラスコンストラクターのこのオーバーロード BigInteger によって、値が4328719365 (または0x102030405) のオブジェクトが作成 BigInteger される理由が明確になります。バイト配列の最初の要素 (値が 5) は、0x05されるオブジェクトの最下位バイトの BigInteger 値を定義します。バイト配列の 2 番目の要素 (値が 4) は、オブジェクトの 2 番目のバイトの BigInteger 値 (0x04など) を定義します。

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

次の例では、正の値と負 BigInteger の値をインスタンス化し、メソッドに ToByteArray 渡し、結果のバイト配列から元 BigInteger の値を復元します。 2 つの値は同じバイト配列で表されることに注意してください。それらの唯一の違いは、バイト配列の最後の要素の最上位ビットにあります。配列が負 BigInteger の値から作成された場合、このビットは設定されます (バイトの値は0xFF)。配列が正 BigInteger の値から作成された場合、ビットは設定されません (バイトの値は 0 です)。

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

次の例は、配列の末尾に値が 0 のバイトを追加することで、正の値が正の値が負の値として正しくインスタンス化されないようにする方法を示しています。

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.

注釈

配列内の個々の value バイトは、最下位バイトから最上位バイトまで、リトルエンディアン順である必要があります。たとえば、次の表に示すように、数値 1,000,000,000,000,000 が表されます。


16 進数文字列	E8D4A51000
バイト配列 (最初に最も低いインデックス)	00 10 A5 D4 E8 00

数値をバイト配列に変換するほとんどのメソッド ( や BitConverter.GetBytesなどBigInteger.ToByteArray) は、バイト配列をリトルエンディアン順で返します。

コンストラクターは、バイト配列内の正の値が符号と大きさの表現を使用し、負の値が 2 の補数表現を使用することを想定しています。つまり、の最上位バイト value の最上位ビットが設定されている場合、結果 BigInteger の値は負になります。バイト配列のソースによっては、正の値が負の値として誤って解釈される可能性があります。バイト配列は通常、次の方法で生成されます。

BigInteger.ToByteArray メソッドを呼び出す。このメソッドは、配列内の最上位バイトの最上位ビットが正の値の場合に 0 に設定されたバイト配列を返すため、正の値を負と誤って解釈する可能性はありません。メソッドによって作成された変更されていないバイト配列は ToByteArray 、コンストラクターに渡されると常にラウンドトリップに BigInteger(Byte[]) 成功します。
メソッドを BitConverter.GetBytes 呼び出し、パラメーターとして符号付き整数を渡します。符号付き整数は符号と大きさの表現と 2 の補数表現の両方を処理するため、正の値を負と誤って解釈する可能性はありません。
メソッドを BitConverter.GetBytes 呼び出し、パラメーターとして符号なし整数を渡します。符号なし整数は大きさのみで表されるため、正の値は負の値として誤って解釈される可能性があります。この解釈の誤りを防ぐために、配列の末尾に 0 バイトの値を追加できます。次のセクションの例では、図を示します。
前のメソッドを必ずしも呼び出さずに動的または静的にバイト配列を作成するか、既存のバイト配列を変更します。正の値が負の値と誤って解釈されないようにするには、配列の末尾に 0 バイトの値を追加します。

が空Byteの配列の場合value、新しいBigIntegerオブジェクトはのBigInteger.Zero値に初期化されます。が nullの場合value、コンストラクターはをArgumentNullExceptionスローします。

こちらもご覧ください

ToByteArray()

適用対象

BigInteger(Decimal)

ソース:: BigInteger.cs

ソース:: BigInteger.cs

ソース:: BigInteger.cs

Decimal 値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。

public:
 BigInteger(System::Decimal value);

public BigInteger (decimal value);

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

Public Sub New (value As Decimal)

パラメーター

value: Decimal

10 進数。

例

次の例は、コンストラクターを使用してオブジェクトを BigInteger(Decimal) インスタンス化する方法を BigInteger 示しています。値の Decimal 配列を定義し、各値をコンストラクターに BigInteger(Decimal) 渡します。値がオブジェクトに Decimal 割り当てられると、値は丸めではなく切り捨てられる BigInteger ことに注意してください。

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.

注釈

このコンストラクターを呼び出した結果は、変数に値を Decimal 明示的に割り当てるのと BigInteger 同じです。

このコンストラクターを呼び出すと、データが失われる可能性があります。の小数部 value は、オブジェクトを BigInteger インスタンス化するときに切り捨てられます。

適用対象

BigInteger(Double)

ソース:: BigInteger.cs

ソース:: BigInteger.cs

ソース:: BigInteger.cs

倍精度浮動小数点値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。

public:
 BigInteger(double value);

public BigInteger (double value);

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

Public Sub New (value As Double)

パラメーター

value: Double

倍精度浮動小数点数値。

例外

OverflowException

value が NaN、NegativeInfinity、または PositiveInfinity です。

例

次の例は、コンストラクターを使用してオブジェクトを BigInteger(Double) インスタンス化する方法を BigInteger 示しています。また、データ型を使用するときに発生する可能性がある精度の損失も Double 示しています。 Doubleには大きな値が割り当てられ、オブジェクトにBigInteger割り当てられます。出力が示すように、この割り当ては精度の低下を伴います。その後、両方の値が 1 ずつインクリメントされます。出力は、オブジェクトが BigInteger 変更された値を反映しているのに対し Double 、オブジェクトは反映しないことを示しています。

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

注釈

オブジェクトをインスタンス化BigIntegerすると、valueパラメーターの小数部はすべて切り捨てられます。

データ型の精度がないため、このコンストラクターを Double 呼び出すとデータが失われる可能性があります。

このコンストラクターを呼び出した結果の値は BigInteger 、に値を明示的に割り当てた Double 結果の値 BigIntegerと同じです。

適用対象

BigInteger(Int32)

ソース:: BigInteger.cs

ソース:: BigInteger.cs

ソース:: BigInteger.cs

32 ビット符号付き整数値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。

public:
 BigInteger(int value);

public BigInteger (int value);

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

Public Sub New (value As Integer)

パラメーター

value: Int32

32 ビット符号付き整数。

例

次の例では、コンストラクターを BigInteger(Int32) 呼び出して、32 ビット整数の配列から値をインスタンス化 BigInteger します。また、暗黙的な変換を使用して、各 32 ビット整数値を BigInteger 変数に割り当てます。次に、2 つの値を比較して、結果 BigInteger の値が同じであることを確認します。

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

注釈

このコンストラクターを使用してオブジェクトを BigInteger インスタンス化しても、精度は失われません。

このコンストラクターを呼び出した結果の値は BigInteger 、に値を割り当てた Int32 結果の値 BigIntegerと同じです。

構造体にはBigInteger、または UInt16型Byte Int16 SByteのパラメーターを持つコンストラクターは含まれません。ただし、この型では Int32 、8 ビットおよび 16 ビット符号付き整数と符号なし整数から符号付き 32 ビット整数への暗黙的な変換がサポートされています。その結果、このコンストラクターは、がこれら 4 つの整数型のいずれかである場合 value に呼び出されます。

適用対象

BigInteger(Int64)

ソース:: BigInteger.cs

ソース:: BigInteger.cs

ソース:: BigInteger.cs

64 ビット符号付き整数値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。

public:
 BigInteger(long value);

public BigInteger (long value);

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

Public Sub New (value As Long)

パラメーター

value: Int64

64 ビット符号付き整数。

例

次の例では、コンストラクターを BigInteger(Int64) 呼び出して、64 ビット整数の配列から値をインスタンス化 BigInteger します。また、暗黙的な変換を使用して、各 64 ビット整数値を BigInteger 変数に割り当てます。次に、2 つの値を比較して、結果 BigInteger の値が同じであることを確認します。

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

注釈

このコンストラクターを使用してオブジェクトを BigInteger インスタンス化しても、精度は失われません。

このコンストラクターを呼び出した結果の値は BigInteger 、に値を割り当てた Int64 結果の値 BigIntegerと同じです。

適用対象

BigInteger(Single)

ソース:: BigInteger.cs

ソース:: BigInteger.cs

ソース:: BigInteger.cs

単精度浮動小数点値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。

public:
 BigInteger(float value);

public BigInteger (float value);

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

Public Sub New (value As Single)

パラメーター

value: Single

単精度浮動小数点数値。

例外

OverflowException

value が NaN、NegativeInfinity、または PositiveInfinity です。

例

次の例は、コンストラクターを使用してオブジェクトを BigInteger(Single) インスタンス化する方法を BigInteger 示しています。また、データ型を使用するときに発生する可能性がある精度の損失も Single 示しています。 Singleには大きな負の値が割り当てられ、オブジェクトにBigInteger割り当てられます。出力が示すように、この割り当てには精度の損失が伴います。その後、両方の値が 1 ずつインクリメントされます。出力は、オブジェクトが BigInteger 変更された値を反映しているのに対し Single 、オブジェクトは反映しないことを示しています。

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

注釈

オブジェクトをインスタンス化BigIntegerすると、valueパラメーターの小数部はすべて切り捨てられます。

データ型の精度がないため、このコンストラクターを Single 呼び出すとデータが失われる可能性があります。

BigIntegerこのコンストラクターの呼び出しの結果の値は、に値を明示的に割り当てたSingle結果の値BigIntegerと同じです。

適用対象

BigInteger(UInt32)

ソース:: BigInteger.cs

ソース:: BigInteger.cs

ソース:: BigInteger.cs

重要

この API は CLS 準拠ではありません。

CLS 準拠の代替: System.Numerics.BigInteger.BigInteger(Int64)

32 ビット符号なし整数値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。

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)

パラメーター

value: UInt32

32 ビットの符号なし整数値。

属性: CLSCompliantAttribute

例

次の例では、 BigInteger(UInt32) コンストラクターと代入ステートメントを使用して、符号なし 32 ビット整数の配列から値を初期化 BigInteger します。次に、2 つの値を比較して、値を初期化 BigInteger する 2 つの方法で同じ結果が生成されることを示します。

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.

注釈

このコンストラクターを使用してをインスタンス化するときに、精度が BigInteger 失われる可能性はありません。

BigIntegerこのコンストラクターを呼び出した結果の値は、に値を割り当てたUInt32結果の値BigIntegerと同じです。

適用対象

BigInteger(UInt64)

ソース:: BigInteger.cs

ソース:: BigInteger.cs

ソース:: BigInteger.cs

重要

この API は CLS 準拠ではありません。

CLS 準拠の代替: System.Numerics.BigInteger.BigInteger(Double)

64 ビット符号なし整数値を使用して、BigInteger 構造体の新しいインスタンスを初期化します。

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)

パラメーター

value: UInt64

符号なし 64 ビット整数。

属性: CLSCompliantAttribute

例

次の例では、コンストラクターを BigInteger(UInt64) 使用して、 BigInteger 値がと等しいオブジェクトを 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

注釈

このコンストラクターを使用してをインスタンス化するときに、精度が BigInteger 失われる可能性はありません。

BigIntegerこのコンストラクターを呼び出した結果の値は、に値を割り当てたUInt64結果の値BigIntegerと同じです。

適用対象

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

ソース:: BigInteger.cs

ソース:: BigInteger.cs

ソース:: BigInteger.cs

バイトの読み取り専用スパンを使用して、BigInteger 構造体の新しいインスタンスを初期化します。任意で、符号付きエンコードとエンディアンのバイト順を示します。

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)

パラメーター

value: ReadOnlySpan<Byte>

多倍長整数を表すバイトの読み取り専用のスパン。

isUnsigned: Boolean

value で符号なしのエンコードを使用することを示す場合は true。それ以外の場合は false (既定値)。

isBigEndian: Boolean

true がビッグエンディアンバイト順であることを示す value 場合は。それ以外の場合 false は (既定値)。

適用対象

次の方法で共有

BigInteger コンストラクター

定義

オーバーロード

BigInteger(Byte[])

パラメーター

例外

例

注釈

こちらもご覧ください

適用対象

BigInteger(Decimal)

パラメーター

例

注釈

適用対象

BigInteger(Double)

パラメーター

例外

例

注釈

適用対象

BigInteger(Int32)

パラメーター

例

注釈

適用対象

BigInteger(Int64)

パラメーター

例

注釈

適用対象

BigInteger(Single)

パラメーター

例外

例

注釈

適用対象

BigInteger(UInt32)

パラメーター

例

注釈

適用対象

BigInteger(UInt64)

パラメーター

例

注釈

適用対象

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

パラメーター

適用対象

その他のリソース