BigInteger BigInteger BigInteger BigInteger Struct

정의

부호 있는 임의의 큰 정수를 나타냅니다.Represents an arbitrarily large signed integer.

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IFormattable
[System.Serializable]
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
type BigInteger = struct
    interface IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable
상속
BigIntegerBigIntegerBigIntegerBigInteger
특성
구현

설명

BigInteger 형식은 이론상에서 값에 상한이 나 하 한 범위 없음 임의로 큰 정수를 나타내는 변경할 수 없는 형식입니다.The BigInteger type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. 멤버는 BigInteger 형식에 다른 정수 계열 형식의 항목을 밀접 하 게 병렬 (합니다 Byte, Int16, Int32, Int64SByte, UInt16, UInt32, 및 UInt64 형식).The members of the BigInteger type closely parallel those of other integral types (the Byte, Int16, Int32, Int64, SByte, UInt16, UInt32, and UInt64 types). 이 형식에서 다른 정수 계열 형식에서 다른 합니다 .NET Framework.NET Framework에 표시 되는 범위를 포함 하는 해당 MinValueMaxValue 속성입니다.This type differs from the other integral types in the .NET Framework.NET Framework, which have a range indicated by their MinValue and MaxValue properties.

참고

때문에 BigInteger 유형을 변경할 수 없는 (참조 반복성 및 BigInteger 구조체) 및 상한 또는 하 한 범위 없음 있기 때문에 OutOfMemoryException 시키는 모든 작업에 대해 throw 할 수 있습니다를 BigInteger 너무 증가 하는 값 큰 합니다.Because the BigInteger type is immutable (see Mutability and the BigInteger Structure) and because it has no upper or lower bounds, an OutOfMemoryException can be thrown for any operation that causes a BigInteger value to grow too large.

BigInteger 개체 인스턴스화Instantiating a BigInteger Object

인스턴스화할 수 있습니다는 BigInteger 여러 가지 방법으로 개체:You can instantiate a BigInteger object in several ways:

  • 사용할 수는 new 키워드 정수 계열 또는 부동 소수점 값을 매개 변수로 제공 하 고는 BigInteger 생성자입니다.You can use the new keyword and provide any integral or floating-point value as a parameter to the BigInteger constructor. (부동 소수점 값을 할당 하기 전에 잘립니다는 BigInteger.) 다음 예제를 사용 하는 방법을 합니다 new 인스턴스화할 키워드 BigInteger 값입니다.(Floating-point values are truncated before they are assigned to the BigInteger.) The following example illustrates how to use the new keyword to instantiate BigInteger values.

    BigInteger bigIntFromDouble = new BigInteger(179032.6541);
    Console.WriteLine(bigIntFromDouble);
    BigInteger bigIntFromInt64 = new BigInteger(934157136952);
    Console.WriteLine(bigIntFromInt64);
    // The example displays the following output:
    //   179032
    //   934157136952		
    
    Dim bigIntFromDouble As New BigInteger(179032.6541)
    Console.WriteLine(bigIntFromDouble)
    Dim bigIntFromInt64 As New BigInteger(934157136952)
    Console.WriteLine(bigIntFromInt64)
    ' The example displays the following output:
    '   179032
    '   934157136952		
    
  • 선언할 수는 BigInteger 변수와 값 수는 해당 값이 정수 계열 형식으로 모든 숫자 유형 할당 합니다.You can declare a BigInteger variable and assign it a value just as you would any numeric type, as long as that value is an integral type. 다음 예제에서는 할당을 사용 하 여 만들려는 BigInteger 에서 값을 Int64입니다.The following example uses assignment to create a BigInteger value from an Int64.

    long longValue = 6315489358112;      
    BigInteger assignedFromLong = longValue;
    Console.WriteLine(assignedFromLong);
    // The example displays the following output:
    //   6315489358112
    
    Dim longValue As Long = 6315489358112      
    Dim assignedFromLong As BigInteger = longValue
    Console.WriteLine(assignedFromLong)
    ' The example displays the following output:
    '   6315489358112
    
  • 10 진수 또는 부동 소수점 값을 할당할 수 있습니다는 BigInteger 개체 값을 캐스팅 또는 먼저 변환 하는 경우.You can assign a decimal or floating-point value to a BigInteger object if you cast the value or convert it first. 다음 예제에서는 명시적으로 캐스팅 (C#에서) 또는 변환 (Visual Basic)에서는 DoubleDecimal 값을 BigInteger입니다.The following example explicitly casts (in C#) or converts (in Visual Basic) a Double and a Decimal value to a BigInteger.

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

이러한 메서드를 인스턴스화하는 데 사용 된 BigInteger 값인 하나의 기존 숫자 값의 범위 개체 형식 에서만.These methods enable you to instantiate a BigInteger object whose value is in the range of one of the existing numeric types only. 인스턴스화할 수 있습니다는 BigInteger 개체 값을 갖는 세 가지 방법 중 하나에서 기존 숫자 형식의 범위를 초과할 수 있습니다.You can instantiate a BigInteger object whose value can exceed the range of the existing numeric types in one of three ways:

  • 사용할 수는 new 키워드 수 있는 모든 크기의 바이트 배열을 제공 하 고는 BigInteger.BigInteger 생성자입니다.You can use the new keyword and provide a byte array of any size to the BigInteger.BigInteger constructor. 예:For example:

    byte[] byteArray = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
    BigInteger newBigInt = new BigInteger(byteArray);
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt);    
    // The example displays the following output:
    //   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
    Dim byteArray() As Byte = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
    Dim newBigInt As New BigInteger(byteArray)
    Console.WriteLine("The value of newBigInt is {0} (or 0x{0:x}).", newBigInt)    
    ' The example displays the following output:
    '   The value of newBigInt is 4759477275222530853130 (or 0x102030405060708090a).
    
  • 호출할 수 있습니다 합니다 Parse 또는 TryParse 숫자의 문자열 표현을 변환 하는 메서드를 BigInteger입니다.You can call the Parse or TryParse methods to convert the string representation of a number to a BigInteger. 예:For example:

    string positiveString = "91389681247993671255432112000000";
    string negativeString = "-90315837410896312071002088037140000";
    BigInteger posBigInt = 0;
    BigInteger negBigInt = 0;
    
    try {
       posBigInt = BigInteger.Parse(positiveString);
       Console.WriteLine(posBigInt);
    }
    catch (FormatException)
    {
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", 
                         positiveString);
    }
    
    if (BigInteger.TryParse(negativeString, out negBigInt))
      Console.WriteLine(negBigInt);
    else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", 
                          negativeString);
    
    // The example displays the following output:
    //   9.1389681247993671255432112E+31
    //   -9.0315837410896312071002088037E+34
    
    Dim positiveString As String = "91389681247993671255432112000000"
    Dim negativeString As string = "-90315837410896312071002088037140000"
    Dim posBigInt As BigInteger = 0
    Dim negBigInt As BigInteger = 0
    
    Try
       posBigInt = BigInteger.Parse(positiveString)
       Console.WriteLine(posBigInt)
    Catch e As FormatException
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                         positiveString)
    End Try
    
    If BigInteger.TryParse(negativeString, negBigInt) Then
      Console.WriteLine(negBigInt)
    Else
       Console.WriteLine("Unable to convert the string '{0}' to a BigInteger value.", _
                          negativeString)
    End If         
    ' The example displays the following output:
    '   9.1389681247993671255432112E+31
    '   -9.0315837410896312071002088037E+34
    
  • 호출할 수 있습니다는 static (Shared Visual Basic에서) BigInteger 숫자 식의 일부 작업을 수행 하 고 계산을 반환 하는 메서드 BigInteger 결과입니다.You can call a static (Shared in Visual Basic) BigInteger method that performs some operation on a numeric expression and returns a calculated BigInteger result. 다음 예제는이 큐브를 위해 UInt64.MaxValue 결과를 할당 하 고는 BigInteger합니다.The following example does this by cubing UInt64.MaxValue and assigning the result to a BigInteger.

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

초기화 되지 않은 값을 BigIntegerZero합니다.The uninitialized value of a BigInteger is Zero.

BigInteger 값에 대 한 작업을 수행합니다.Performing Operations on BigInteger Values

사용할 수는 BigInteger 다른 정수 계열 형식을 사용 하는 인스턴스.You can use a BigInteger instance as you would use any other integral type. BigInteger 더하기, 빼기, 나누기, 곱하기, 빼기, 부정, 및 단항 부정 연산자와 같은 기본 수치 연산을 수행할 수 있도록 표준 숫자 연산자 오버 로드 합니다.BigInteger overloads the standard numeric operators to enable you to perform basic mathematical operations such as addition, subtraction, division, multiplication, subtraction, negation, and unary negation. 비교할 두 개의 표준 숫자 연산자를 사용할 수도 있습니다 BigInteger 서로 값입니다.You can also use the standard numeric operators to compare two BigInteger values with each other. 다른 정수 계열 형식과 마찬가지로 BigInteger 비트 지원 AndOr, XOr, 왼쪽 시프트 및 오른쪽 시프트 연산자입니다.Like the other integral types, BigInteger also supports the bitwise And, Or, XOr, left shift, and right shift operators. 사용자 지정 연산자를 지원 하지 않는 언어를 BigInteger 구조 수치 연산을 수행 하기 위한 동등한 메서드도 제공 합니다.For languages that do not support custom operators, the BigInteger structure also provides equivalent methods for performing mathematical operations. 여기에 포함 됩니다 Add, DivideMultiplyNegate, Subtract, 등입니다.These include Add, Divide, Multiply, Negate, Subtract, and several others.

많은 멤버를 BigInteger 구조 다른 정수 계열 형식의 멤버에 직접 해당 합니다.Many members of the BigInteger structure correspond directly to members of the other integral types. 또한 BigInteger 다음과 같은 멤버를 추가 합니다.In addition, BigInteger adds members such as the following:

멤버에 해당 하는 대부분의 이러한 추가 멤버를 Math 기본 숫자 형식을 사용 하는 기능을 제공 하는 클래스입니다.Many of these additional members correspond to the members of the Math class, which provides the functionality to work with the primitive numeric types.

반복성 및 BigInteger 구조체Mutability and the BigInteger Structure

다음 예제에서는 BigInteger 개체 및 해당 값 1 씩 증가 시킵니다.The following example instantiates a BigInteger object and then increments its value by one.

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

이 예제에서는 기존 개체의 값을 수정 하려면 나타나지만, 대/소문자 아닙니다.Although this example appears to modify the value of the existing object, this is not the case. BigInteger 개체는, 즉 내부적으로, 공용 언어 런타임에서 실제로 새로 만들고 BigInteger 개체 및 이전 값 보다 하나 더 큰 값을 할당 합니다.BigInteger objects are immutable, which means that internally, the common language runtime actually creates a new BigInteger object and assigns it a value one greater than its previous value. 이 새 개체를 호출자에 게 반환 됩니다.This new object is then returned to the caller.

참고

.NET Framework의 다른 숫자 형식도 변경할 수 없습니다.The other numeric types in the .NET Framework are also immutable. 그러나 때문에 BigInteger 형식은 상한 또는 하 한 범위 없음, 해당 값 매우 커질 및 성능에 크게 영향을 미칠 수 있습니다.However, because the BigInteger type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance.

이 프로세스를 호출자에 게 투명 하지만 성능 저하를 유발 하지는 않습니다.Although this process is transparent to the caller, it does incur a performance penalty. 일부 경우에 특히 경우 반복된 작업은 수행 루프에서 매우 큰 BigInteger 값을 해당 성능이 중요할 수 있습니다.In some cases, especially when repeated operations are performed in a loop on very large BigInteger values, that performance penalty can be significant. 예를 들어, 다음 예제에서 작업이 수행 되는 백만 번을 반복적으로 BigInteger 될 때마다 작업에 성공 하면 값이 1 씩 증가 합니다.For example, in the following example, an operation is performed repetitively up to a million times, and a BigInteger value is incremented by one every time the operation succeeds.

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

이러한 경우에 대 한 모든 중간 할당을 수행 하 여 성능을 개선할 수 있습니다는 Int32 변수입니다.In such a case, you can improve performance by performing all intermediate assignments to an Int32 variable. 변수의 최종 값 다음 할당할 수는 BigInteger 루프 종료 될 때 개체입니다.The final value of the variable can then be assigned to the BigInteger object when the loop exits. 다음 예제에서 이에 대해 설명합니다.The following example provides an illustration.

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

16 진수 문자열과 바이트 배열 사용Working with Byte Arrays and Hexadecimal Strings

변환 하는 경우 BigInteger 값을 바이트 배열로, 바이트 배열에 변환 하는 경우 또는 BigInteger 값을 바이트의 순서를 고려해 야 합니다.If you convert BigInteger values to byte arrays, or if you convert byte arrays to BigInteger values, you must consider the order of bytes. BigInteger 구조 little endian 순서로 표시할 바이트 배열에서 개별 바이트를 예상 합니다 (즉, 값의 낮은 순서 바이트 앞에 야 고차 바이트)입니다.The BigInteger structure expects the individual bytes in a byte array to appear in little-endian order (that is, the lower-order bytes of the value precede the higher-order bytes). 왕복할 수 있습니다는 BigInteger 호출 하 여 값을 ToByteArray 메서드와 전달 결과 바이트 배열을 BigInteger(Byte[]) 다음 예제와 같이 생성자.You can round-trip a BigInteger value by calling the ToByteArray method and then passing the resulting byte array to the BigInteger(Byte[]) constructor, as the following example shows.

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

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

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

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

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

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

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

인스턴스화하는 BigInteger 값 다른 정수 계열 형식의 값을 나타내는 바이트 배열에서 정수 계열 값을 전달할 수 있습니다 합니다 BitConverter.GetBytes 메서드를 전달 하 고 결과 바이트 배열를 BigInteger(Byte[]) 생성자.To instantiate a BigInteger value from a byte array that represents a value of some other integral type, you can pass the integral value to the BitConverter.GetBytes method, and then pass the resulting byte array to the BigInteger(Byte[]) constructor. 다음 예제에서는 한 BigInteger 나타내는 바이트 배열에서 값을 Int16 값입니다.The following example instantiates a BigInteger value from a byte array that represents an Int16 value.

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

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

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

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

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

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

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

BigInteger 구조 음수 값 2의 보수 표현을 사용 하 여 저장 된 있다고 가정 합니다.The BigInteger structure assumes that negative values are stored by using two's complement representation. 때문에 BigInteger 구조에 없는 고정된 길이 숫자 값을 나타내는 BigInteger(Byte[]) 생성자에는 항상 가장 중요 한 비트를 부호 비트로 배열의 마지막 바이트의 해석 합니다.Because the BigInteger structure represents a numeric value with no fixed length, the BigInteger(Byte[]) constructor always interprets the most significant bit of the last byte in the array as a sign bit. 방지 하기 위해는 BigInteger(Byte[]) 2의 보수 표현한 음수 값을 양수 값 이면 양수의 크기와 부호가 표현으로 혼동의 생성자는 가장 값 비트가 바이트 배열에서 마지막 바이트 일반적으로 추가 바이트 값이 0 인 집합에 포함 되어야 합니다.To prevent the BigInteger(Byte[]) constructor from confusing the two's complement representation of a negative value with the sign and magnitude representation of a positive value, positive values in which the most significant bit of the last byte in the byte array would ordinarily be set should include an additional byte whose value is 0. 예를 들어 0xC0 0xBD 0xF0 0xFF-1,000,000 또는 4,293,967,296 little endian 16 진수 표현입니다.For example, 0xC0 0xBD 0xF0 0xFF is the little-endian hexadecimal representation of either -1,000,000 or 4,293,967,296. 바이트 배열의 값으로 해석이 배열의 마지막 바이트의 가장 중요 한 비트 이기 때문에 BigInteger(Byte[]) -1,000,000 생성자입니다.Because the most significant bit of the last byte in this array is on, the value of the byte array would be interpreted by the BigInteger(Byte[]) constructor as -1,000,000. 인스턴스화하는 BigInteger 해당 값이 양수 이면 요소가 0xC0 바이트 배열 0xBD 0xF0 0xFF 0x00 생성자에 전달 해야 합니다.To instantiate a BigInteger whose value is positive, a byte array whose elements are 0xC0 0xBD 0xF0 0xFF 0x00 must be passed to the constructor. 다음은 이에 대한 예입니다.The following example illustrates this.

int negativeNumber = -1000000;
uint positiveNumber = 4293967296;

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

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

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

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

생성 된 바이트 배열은 ToByteArray 메서드에서 양수 값이 추가 0 값 바이트를 포함 합니다.Byte arrays created by the ToByteArray method from positive values include this extra zero-value byte. 따라서는 BigInteger 구조를 할당 하 고 다음 예제와 같이 바이트 배열에서 복원 하 여 성공적으로 라운드트립 값 수입니다.Therefore, the BigInteger structure can successfully round-trip values by assigning them to, and then restoring them from, byte arrays, as the following example shows.

BigInteger positiveValue = 15777216;
BigInteger negativeValue  = -1000000;

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

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

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

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

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

개발자가 동적으로 만들어지는 또는 부호 없는 정수를 바이트 배열로 변환 하는 메서드에서 반환 되는 바이트 배열에이 추가 값 0 바이트를 추가 해야 하는 반면 (같은 BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32), 및 BitConverter.GetBytes(UInt64)).However, you may need to add this additional zero-value byte to byte arrays that are created dynamically by the developer or that are returned by methods that convert unsigned integers to byte arrays (such as BitConverter.GetBytes(UInt16), BitConverter.GetBytes(UInt32), and BitConverter.GetBytes(UInt64)).

16 진수 문자열을 구문 분석 하는 경우는 BigInteger.Parse(String, NumberStyles)BigInteger.Parse(String, NumberStyles, IFormatProvider) 메서드 가정 문자열의 첫 번째 바이트의 가장 중요 한 비트가 설정 된 경우 값은 문자열의 첫 번째 16 진수 바이트 값의 낮은 4 개의 비트를 나타내는 경우 2의 보수 표현을 사용 하 여 표시 합니다.When parsing a hexadecimal string, the BigInteger.Parse(String, NumberStyles) and BigInteger.Parse(String, NumberStyles, IFormatProvider) methods assume that if the most significant bit of the first byte in the string is set, or if the first hexadecimal digit of the string represents the lower four bits of a byte value, the value is represented by using two's complement representation. 예를 들어, "FF01" 및 "F01" 나타내는 10 진수 값-255를 나타냅니다.For example, both "FF01" and "F01" represent the decimal value -255. 음수 값에서 양수를 구별 하려면 양수 값 앞에 0이 포함 되어야 합니다.To differentiate positive from negative values, positive values should include a leading zero. 관련 된 오버 로드는 ToString 메서드를 "X" 형식 문자열에 전달 될 때 양수 값에 대해 반환 되는 16 진수 문자열에 선행 0을 추가 합니다.The relevant overloads of the ToString method, when they are passed the "X" format string, add a leading zero to the returned hexadecimal string for positive values. 따라서 왕복 BigInteger 를 사용 하 여 값을 ToStringParse 메서드를 다음 예제와 같이 합니다.This makes it possible to round-trip BigInteger values by using the ToString and Parse methods, as the following example shows.

BigInteger negativeNumber = -1000000;
BigInteger positiveNumber  = 15777216;

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

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

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

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

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

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

호출 하 여 16 진수 문자열을 생성 하는 반면를 ToString 다른 정수 형식 또는 오버 로드의 메서드를 ToString 포함 하는 메서드를 toBase 매개 변수는 원본 데이터 형식 또는 값의 부호를 나타내지 않습니다 16 진수 문자열 파생 되었습니다.However, the hexadecimal strings created by calling the ToString methods of the other integral types or the overloads of the ToString method that include a toBase parameter do not indicate the sign of the value or the source data type from which the hexadecimal string was derived. 성공적으로 인스턴스화하는 BigInteger 이러한 문자열의 값에는 몇 가지 추가 논리가 필요 합니다.Successfully instantiating a BigInteger value from such a string requires some additional logic. 다음 예제에서는 한 가지 구현을 제공 합니다.The following example provides one possible implementation.

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

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

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

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

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

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

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

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

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

생성자

BigInteger(Byte[]) BigInteger(Byte[]) BigInteger(Byte[]) BigInteger(Byte[])

바이트 배열의 값을 사용하여 BigInteger 구조체의 새 인스턴스를 초기화합니다.Initializes a new instance of the BigInteger structure using the values in a byte array.

BigInteger(Decimal) BigInteger(Decimal) BigInteger(Decimal) BigInteger(Decimal)

BigInteger 값을 사용하여 Decimal 구조체의 새 인스턴스를 초기화합니다.Initializes a new instance of the BigInteger structure using a Decimal value.

BigInteger(Double) BigInteger(Double) BigInteger(Double) BigInteger(Double)

배정밀도 부동 소수점 값을 사용하여 BigInteger 구조체의 새 인스턴스를 초기화합니다.Initializes a new instance of the BigInteger structure using a double-precision floating-point value.

BigInteger(Int32) BigInteger(Int32) BigInteger(Int32) BigInteger(Int32)

부호 있는 32비트 정수 값을 사용하여 BigInteger 구조체의 새 인스턴스를 초기화합니다.Initializes a new instance of the BigInteger structure using a 32-bit signed integer value.

BigInteger(Int64) BigInteger(Int64) BigInteger(Int64) BigInteger(Int64)

부호 있는 64비트 정수 값을 사용하여 BigInteger 구조체의 새 인스턴스를 초기화합니다.Initializes a new instance of the BigInteger structure using a 64-bit signed integer value.

BigInteger(Single) BigInteger(Single) BigInteger(Single) BigInteger(Single)

단정밀도 부동 소수점 값을 사용하여 BigInteger 구조체의 새 인스턴스를 초기화합니다.Initializes a new instance of the BigInteger structure using a single-precision floating-point value.

BigInteger(UInt32) BigInteger(UInt32) BigInteger(UInt32) BigInteger(UInt32)

부호 없는 32비트 정수 값을 사용하여 BigInteger 구조체의 새 인스턴스를 초기화합니다.Initializes a new instance of the BigInteger structure using an unsigned 32-bit integer value.

BigInteger(UInt64) BigInteger(UInt64) BigInteger(UInt64) BigInteger(UInt64)

부호 없는 64비트 정수 값을 사용하여 BigInteger 구조체의 새 인스턴스를 초기화합니다.Initializes a new instance of the BigInteger structure with an unsigned 64-bit integer value.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean) BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

속성

IsEven IsEven IsEven IsEven

현재 BigInteger 개체의 값이 짝수인지 여부를 나타냅니다.Indicates whether the value of the current BigInteger object is an even number.

IsOne IsOne IsOne IsOne

현재 BigInteger 개체의 값이 One인지 여부를 나타냅니다.Indicates whether the value of the current BigInteger object is One.

IsPowerOfTwo IsPowerOfTwo IsPowerOfTwo IsPowerOfTwo

현재 BigInteger 개체의 2의 거듭제곱인지 여부를 나타냅니다.Indicates whether the value of the current BigInteger object is a power of two.

IsZero IsZero IsZero IsZero

현재 BigInteger 개체의 값이 Zero인지 여부를 나타냅니다.Indicates whether the value of the current BigInteger object is Zero.

MinusOne MinusOne MinusOne MinusOne

숫자 -1을 나타내는 값을 가져옵니다.Gets a value that represents the number negative one (-1).

One One One One

숫자 1을 나타내는 값을 가져옵니다.Gets a value that represents the number one (1).

Sign Sign Sign Sign

현재 BigInteger 개체의 부호(음수, 양수 또는 0)를 나타내는 숫자를 가져옵니다.Gets a number that indicates the sign (negative, positive, or zero) of the current BigInteger object.

Zero Zero Zero Zero

숫자 0을 나타내는 값을 가져옵니다.Gets a value that represents the number 0 (zero).

메서드

Abs(BigInteger) Abs(BigInteger) Abs(BigInteger) Abs(BigInteger)

BigInteger 개체의 절대 값을 가져옵니다.Gets the absolute value of a BigInteger object.

Add(BigInteger, BigInteger) Add(BigInteger, BigInteger) Add(BigInteger, BigInteger) Add(BigInteger, BigInteger)

두 개의 BigInteger 값을 더한 다음 결과를 반환합니다.Adds two BigInteger values and returns the result.

Compare(BigInteger, BigInteger) Compare(BigInteger, BigInteger) Compare(BigInteger, BigInteger) Compare(BigInteger, BigInteger)

BigInteger 값을 비교하고 첫 번째 값이 두 번째 값보다 작은지, 같은지 또는 큰지를 나타내는 정수를 반환합니다.Compares two BigInteger values and returns an integer that indicates whether the first value is less than, equal to, or greater than the second value.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

이 인스턴스를 지정된 개체와 비교하고 이 인스턴스의 값이 지정된 개체의 값보다 작은지, 같은지 또는 큰지를 나타내는 정수를 반환합니다.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(UInt64) CompareTo(UInt64) CompareTo(UInt64) CompareTo(UInt64)

이 인스턴스를 부호 없는 64비트 정수와 비교하고 이 인스턴스의 값이 부호 없는 64비트 정수 값보다 작은지, 같은지 또는 큰지를 나타내는 정수를 반환합니다.Compares this instance to an unsigned 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the unsigned 64-bit integer.

CompareTo(Int64) CompareTo(Int64) CompareTo(Int64) CompareTo(Int64)

이 인스턴스를 부호 있는 64비트 정수와 비교하고 이 인스턴스의 값이 부호 있는 64비트 정수 값보다 작은지, 같은지 또는 큰지를 나타내는 정수를 반환합니다.Compares this instance to a signed 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the signed 64-bit integer.

CompareTo(BigInteger) CompareTo(BigInteger) CompareTo(BigInteger) CompareTo(BigInteger)

이 인스턴스를 두 번째 BigInteger와 비교하고 이 인스턴스의 값이 지정된 개체의 값보다 작은지, 같은지 또는 큰지를 나타내는 정수를 반환합니다.Compares this instance to a second BigInteger and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger) Divide(BigInteger, BigInteger)

하나의 BigInteger 값을 다른 값으로 나눈 후 결과를 반환합니다.Divides one BigInteger value by another and returns the result.

DivRem(BigInteger, BigInteger, BigInteger) DivRem(BigInteger, BigInteger, BigInteger) DivRem(BigInteger, BigInteger, BigInteger) DivRem(BigInteger, BigInteger, BigInteger)

하나의 BigInteger 값을 다른 값으로 나눈 후 결과를 반환하고 출력 매개 변수에 나머지를 반환합니다.Divides one BigInteger value by another, returns the result, and returns the remainder in an output parameter.

Equals(Int64) Equals(Int64) Equals(Int64) Equals(Int64)

현재 인스턴스와 부호 있는 64비트 정수의 값이 같은지를 나타내는 값을 반환합니다.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

Equals(BigInteger) Equals(BigInteger) Equals(BigInteger) Equals(BigInteger)

현재 인스턴스와 지정된 BigInteger 개체의 값이 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

현재 인스턴스와 지정된 개체의 값이 같은지를 나타내는 값을 반환합니다.Returns a value that indicates whether the current instance and a specified object have the same value.

Equals(UInt64) Equals(UInt64) Equals(UInt64) Equals(UInt64)

현재 인스턴스와 부호 없는 64비트 정수의 값이 같은지를 나타내는 값을 반환합니다.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

GetByteCount(Boolean) GetByteCount(Boolean) GetByteCount(Boolean) GetByteCount(Boolean)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

현재 BigInteger 개체에 대한 해시 코드를 반환합니다.Returns the hash code for the current BigInteger object.

GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger) GreatestCommonDivisor(BigInteger, BigInteger)

BigInteger 값의 최대 공약수를 구합니다.Finds the greatest common divisor of two BigInteger values.

Log(BigInteger) Log(BigInteger) Log(BigInteger) Log(BigInteger)

지정된 숫자의 자연(밑 e) 로그를 반환합니다.Returns the natural (base e) logarithm of a specified number.

Log(BigInteger, Double) Log(BigInteger, Double) Log(BigInteger, Double) Log(BigInteger, Double)

지정된 밑을 사용하여 지정된 숫자의 로그를 반환합니다.Returns the logarithm of a specified number in a specified base.

Log10(BigInteger) Log10(BigInteger) Log10(BigInteger) Log10(BigInteger)

밑을 10으로 사용하여 지정된 숫자의 로그를 반환합니다.Returns the base 10 logarithm of a specified number.

Max(BigInteger, BigInteger) Max(BigInteger, BigInteger) Max(BigInteger, BigInteger) Max(BigInteger, BigInteger)

BigInteger 값 중 더 큰 값을 반환합니다.Returns the larger of two BigInteger values.

Min(BigInteger, BigInteger) Min(BigInteger, BigInteger) Min(BigInteger, BigInteger) Min(BigInteger, BigInteger)

BigInteger 값 중 더 작은 값을 반환합니다.Returns the smaller of two BigInteger values.

ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger) ModPow(BigInteger, BigInteger, BigInteger)

다른 숫자의 승수로 거듭제곱한 숫자에 대해 모듈러스 나누기를 수행합니다.Performs modulus division on a number raised to the power of another number.

Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger)

BigInteger 값의 곱을 반환합니다.Returns the product of two BigInteger values.

Negate(BigInteger) Negate(BigInteger) Negate(BigInteger) Negate(BigInteger)

지정된 BigInteger 값을 부정합니다.Negates a specified BigInteger value.

Parse(String) Parse(String) Parse(String) Parse(String)

숫자의 문자열 표현을 해당하는 BigInteger로 변환합니다.Converts the string representation of a number to its BigInteger equivalent.

Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles)

숫자를 지정된 스타일로 나타낸 문자열 표현을 해당 BigInteger로 변환합니다.Converts the string representation of a number in a specified style to its BigInteger equivalent.

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider)

숫자를 지정된 문화권별 형식으로 나타낸 문자열 표현을 해당 BigInteger로 변환합니다.Converts the string representation of a number in a specified culture-specific format to its BigInteger equivalent.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider)

지정된 스타일 및 문화권별 형식으로 된 숫자의 문자열 표현을 해당하는 BigInteger로 변환합니다.Converts the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent.

Pow(BigInteger, Int32) Pow(BigInteger, Int32) Pow(BigInteger, Int32) Pow(BigInteger, Int32)

BigInteger 값을 지정된 값의 거듭제곱으로 변환합니다.Raises a BigInteger value to the power of a specified value.

Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger) Remainder(BigInteger, BigInteger)

BigInteger 값에 대해 정수 나누기를 수행합니다.Performs integer division on two BigInteger values and returns the remainder.

Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger) Subtract(BigInteger, BigInteger)

다른 값에서 하나의 BigInteger 값을 뺀 결과를 반환합니다.Subtracts one BigInteger value from another and returns the result.

ToByteArray() ToByteArray() ToByteArray() ToByteArray()

BigInteger 값을 바이트 배열로 변환합니다.Converts a BigInteger value to a byte array.

ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean) ToByteArray(Boolean, Boolean)
ToString() ToString() ToString() ToString()

현재 BigInteger 개체의 숫자 값을 해당하는 문자열 표현으로 변환합니다.Converts the numeric value of the current BigInteger object to its equivalent string representation.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

지정된 문화권별 서식 지정 정보를 사용하여 현재 BigInteger 개체의 숫자 값을 해당 문자열 표현으로 변환합니다.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified culture-specific formatting information.

ToString(String) ToString(String) ToString(String) ToString(String)

지정된 서식을 사용하여 현재 BigInteger 개체의 숫자 값을 해당하는 문자열 표현으로 변환합니다.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format.

ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider)

지정된 형식 및 문화권별 형식 정보를 사용하여 현재 BigInteger 개체의 숫자 값을 해당 문자열 표현으로 변환합니다.Converts the numeric value of the current BigInteger object to its equivalent string representation by using the specified format and culture-specific format information.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger) TryParse(ReadOnlySpan<Char>, BigInteger)
TryParse(String, BigInteger) TryParse(String, BigInteger) TryParse(String, BigInteger) TryParse(String, BigInteger)

숫자의 문자열 표현을 해당 BigInteger로 변환하고, 변환에 성공했는지를 나타내는 값을 반환합니다.Tries to convert the string representation of a number to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)
TryParse(String, NumberStyles, IFormatProvider, BigInteger) TryParse(String, NumberStyles, IFormatProvider, BigInteger) TryParse(String, NumberStyles, IFormatProvider, BigInteger) TryParse(String, NumberStyles, IFormatProvider, BigInteger)

지정된 문화권별 형식과 지정된 스타일을 사용한 숫자의 문자열 표현을 해당 BigInteger로 변환해 보고, 변환에 성공했는지를 나타내는 값을 반환합니다.Tries to convert the string representation of a number in a specified style and culture-specific format to its BigInteger equivalent, and returns a value that indicates whether the conversion succeeded.

TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean) TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean)

연산자

Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger) Addition(BigInteger, BigInteger)

지정한 두 BigInteger의 값을 더합니다.Adds the values of two specified BigInteger objects.

BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger) BitwiseAnd(BigInteger, BigInteger)

BigInteger 값에 대해 비트 And 연산을 수행합니다.Performs a bitwise And operation on two BigInteger values.

BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger) BitwiseOr(BigInteger, BigInteger)

BigInteger 값에 대해 비트 Or 연산을 수행합니다.Performs a bitwise Or operation on two BigInteger values.

Decrement(BigInteger) Decrement(BigInteger) Decrement(BigInteger) Decrement(BigInteger)

BigInteger 값을 1씩 감소합니다.Decrements a BigInteger value by 1.

Division(BigInteger, BigInteger) Division(BigInteger, BigInteger) Division(BigInteger, BigInteger) Division(BigInteger, BigInteger)

정수 나누기를 사용하여 지정된 BigInteger 값을 지정된 다른 BigInteger 값으로 나눕니다.Divides a specified BigInteger value by another specified BigInteger value by using integer division.

Equality(Int64, BigInteger) Equality(Int64, BigInteger) Equality(Int64, BigInteger) Equality(Int64, BigInteger)

부호 있는 정수(Long) 값과 BigInteger 값이 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a signed long integer value and a BigInteger value are equal.

Equality(BigInteger, Int64) Equality(BigInteger, Int64) Equality(BigInteger, Int64) Equality(BigInteger, Int64)

BigInteger 값과 부호 있는 정수(Long) 값이 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value and a signed long integer value are equal.

Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger) Equality(BigInteger, BigInteger)

BigInteger 개체의 값이 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether the values of two BigInteger objects are equal.

Equality(BigInteger, UInt64) Equality(BigInteger, UInt64) Equality(BigInteger, UInt64) Equality(BigInteger, UInt64)

BigInteger 값과 부호 없는 정수(Long) 값이 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value and an unsigned long integer value are equal.

Equality(UInt64, BigInteger) Equality(UInt64, BigInteger) Equality(UInt64, BigInteger) Equality(UInt64, BigInteger)

부호 없는 정수(Long) 값과 BigInteger 값이 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether an unsigned long integer value and a BigInteger value are equal.

ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger) ExclusiveOr(BigInteger, BigInteger)

BigInteger 값에 대해 비트 배타적 Or(XOr) 연산을 수행합니다.Performs a bitwise exclusive Or (XOr) operation on two BigInteger values.

Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger) Explicit(Decimal to BigInteger)

Decimal 개체를 BigInteger 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a Decimal object to a BigInteger value.

Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger) Explicit(Double to BigInteger)

Double 값을 BigInteger 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a Double value to a BigInteger value.

Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte) Explicit(BigInteger to Byte)

BigInteger 개체를 부호 없는 바이트 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to an unsigned byte value.

Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal) Explicit(BigInteger to Decimal)

BigInteger 개체를 Decimal 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a Decimal value.

Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double) Explicit(BigInteger to Double)

BigInteger 개체를 Double 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a Double value.

Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16) Explicit(BigInteger to Int16)

BigInteger 개체를 부호 있는 16비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a 16-bit signed integer value.

Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32) Explicit(BigInteger to Int32)

BigInteger 개체를 부호 있는 32비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a 32-bit signed integer value.

Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64) Explicit(BigInteger to Int64)

BigInteger 개체를 부호 있는 64비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a 64-bit signed integer value.

Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte) Explicit(BigInteger to SByte)

BigInteger 개체를 부호 있는 8비트 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a signed 8-bit value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 Int16입니다.The compliant alternative is Int16.

Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single) Explicit(BigInteger to Single)

BigInteger 개체를 단정밀도 부동 소수점 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to a single-precision floating-point value.

Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16) Explicit(BigInteger to UInt16)

BigInteger 개체를 부호 없는 16비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to an unsigned 16-bit integer value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 Int32입니다.The compliant alternative is Int32.

Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32) Explicit(BigInteger to UInt32)

BigInteger 개체를 부호 없는 32비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to an unsigned 32-bit integer value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 Int64입니다.The compliant alternative is Int64.

Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64) Explicit(BigInteger to UInt64)

BigInteger 개체를 부호 없는 64비트 정수 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a BigInteger object to an unsigned 64-bit integer value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 Double입니다.The compliant alternative is Double.

Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger) Explicit(Single to BigInteger)

Single 값을 BigInteger 값으로 변환하는 명시적 변환을 정의합니다.Defines an explicit conversion of a Single value to a BigInteger value.

GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger) GreaterThan(UInt64, BigInteger)

BigInteger 값이 부호 없는 64비트 정수보다 큰지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64) GreaterThan(BigInteger, UInt64)

BigInteger 값이 부호 없는 64비트 정수보다 큰지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is greater than a 64-bit unsigned integer.

GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger) GreaterThan(Int64, BigInteger)

부호 있는 64비트 정수가 BigInteger 값보다 큰지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a 64-bit signed integer is greater than a BigInteger value.

GreaterThan(BigInteger, Int64) GreaterThan(BigInteger, Int64) GreaterThan(BigInteger, Int64) GreaterThan(BigInteger, Int64)

BigInteger가 부호 있는 64 정수 값보다 큰지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger is greater than a 64-bit signed integer value.

GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger) GreaterThan(BigInteger, BigInteger)

BigInteger 값이 다른 BigInteger 값보다 큰지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is greater than another BigInteger value.

GreaterThanOrEqual(Int64, BigInteger) GreaterThanOrEqual(Int64, BigInteger) GreaterThanOrEqual(Int64, BigInteger) GreaterThanOrEqual(Int64, BigInteger)

부호 있는 64비트 정수가 BigInteger 값보다 크거나 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a 64-bit signed integer is greater than or equal to a BigInteger value.

GreaterThanOrEqual(BigInteger, Int64) GreaterThanOrEqual(BigInteger, Int64) GreaterThanOrEqual(BigInteger, Int64) GreaterThanOrEqual(BigInteger, Int64)

BigInteger 값이 부호 있는 64비트 정수 값보다 크거나 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit signed integer value.

GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger) GreaterThanOrEqual(BigInteger, BigInteger)

BigInteger 값이 다른 BigInteger 값보다 크거나 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is greater than or equal to another BigInteger value.

GreaterThanOrEqual(BigInteger, UInt64) GreaterThanOrEqual(BigInteger, UInt64) GreaterThanOrEqual(BigInteger, UInt64) GreaterThanOrEqual(BigInteger, UInt64)

BigInteger 값이 부호 없는 64비트 정수 값보다 크거나 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is greater than or equal to a 64-bit unsigned integer value.

GreaterThanOrEqual(UInt64, BigInteger) GreaterThanOrEqual(UInt64, BigInteger) GreaterThanOrEqual(UInt64, BigInteger) GreaterThanOrEqual(UInt64, BigInteger)

부호 없는 64비트 정수가 BigInteger 값보다 크거나 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a 64-bit unsigned integer is greater than or equal to a BigInteger value.

Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger) Implicit(UInt32 to BigInteger)

부호 없는 32비트 정수를 BigInteger 값으로 변환하는 암시적 변환을 정의합니다.Defines an implicit conversion of a 32-bit unsigned integer to a BigInteger value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 Implicit(Int64 to BigInteger)입니다.The compliant alternative is Implicit(Int64 to BigInteger).

Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger) Implicit(UInt16 to BigInteger)

부호 없는 16비트 정수를 BigInteger 값으로 변환하는 암시적 변환을 정의합니다.Defines an implicit conversion of a 16-bit unsigned integer to a BigInteger value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 Implicit(Int32 to BigInteger)입니다.The compliant alternative is Implicit(Int32 to BigInteger).

Implicit(SByte to BigInteger) Implicit(SByte to BigInteger) Implicit(SByte to BigInteger) Implicit(SByte to BigInteger)

부호 있는 8비트 정수를 BigInteger 값으로 변환하는 암시적 변환을 정의합니다.Defines an implicit conversion of an 8-bit signed integer to a BigInteger value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 BigInteger(Int32)입니다.The compliant alternative is BigInteger(Int32).

Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger) Implicit(UInt64 to BigInteger)

부호 없는 64비트 정수를 BigInteger 값으로 변환하는 암시적 변환을 정의합니다.Defines an implicit conversion of a 64-bit unsigned integer to a BigInteger value.

이 API는 CLS 규격이 아닙니다.This API is not CLS-compliant. 규격 대체 항목은 Double입니다.The compliant alternative is Double.

Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger) Implicit(Int32 to BigInteger)

부호 있는 32비트 정수를 BigInteger 값으로 변환하는 암시적 변환을 정의합니다.Defines an implicit conversion of a signed 32-bit integer to a BigInteger value.

Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger) Implicit(Int16 to BigInteger)

부호 있는 16비트 정수를 BigInteger 값으로 변환하는 암시적 변환을 정의합니다.Defines an implicit conversion of a signed 16-bit integer to a BigInteger value.

Implicit(Byte to BigInteger) Implicit(Byte to BigInteger) Implicit(Byte to BigInteger) Implicit(Byte to BigInteger)

부호 없는 바이트를 BigInteger 값으로 변환하는 암시적 변환을 정의합니다.Defines an implicit conversion of an unsigned byte to a BigInteger value.

Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger) Implicit(Int64 to BigInteger)

부호 있는 64비트 정수를 BigInteger 값으로 변환하는 암시적 변환을 정의합니다.Defines an implicit conversion of a signed 64-bit integer to a BigInteger value.

Increment(BigInteger) Increment(BigInteger) Increment(BigInteger) Increment(BigInteger)

BigInteger 값을 1씩 증가합니다.Increments a BigInteger value by 1.

Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger) Inequality(UInt64, BigInteger)

부호 없는 64비트 정수와 BigInteger 값이 다른지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a 64-bit unsigned integer and a BigInteger value are not equal.

Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger) Inequality(BigInteger, BigInteger)

BigInteger 개체의 값이 다른지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether two BigInteger objects have different values.

Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64) Inequality(BigInteger, UInt64)

BigInteger 값과 부호 없는 64비트 정수가 다른지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value and a 64-bit unsigned integer are not equal.

Inequality(Int64, BigInteger) Inequality(Int64, BigInteger) Inequality(Int64, BigInteger) Inequality(Int64, BigInteger)

부호 있는 64비트 정수와 BigInteger 값이 다른지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a 64-bit signed integer and a BigInteger value are not equal.

Inequality(BigInteger, Int64) Inequality(BigInteger, Int64) Inequality(BigInteger, Int64) Inequality(BigInteger, Int64)

BigInteger 값과 부호 있는 64비트 정수가 다른지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value and a 64-bit signed integer are not equal.

LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32) LeftShift(BigInteger, Int32)

BigInteger 값을 지정된 비트 수만큼 왼쪽으로 이동합니다.Shifts a BigInteger value a specified number of bits to the left.

LessThan(Int64, BigInteger) LessThan(Int64, BigInteger) LessThan(Int64, BigInteger) LessThan(Int64, BigInteger)

부호 있는 64비트 정수가 BigInteger 값보다 작은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a 64-bit signed integer is less than a BigInteger value.

LessThan(BigInteger, Int64) LessThan(BigInteger, Int64) LessThan(BigInteger, Int64) LessThan(BigInteger, Int64)

BigInteger 값이 부호 있는 64비트 정수보다 작은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is less than a 64-bit signed integer.

LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger) LessThan(BigInteger, BigInteger)

BigInteger 값이 다른 BigInteger 값보다 작은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is less than another BigInteger value.

LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64) LessThan(BigInteger, UInt64)

BigInteger 값이 부호 없는 64비트 정수보다 작은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is less than a 64-bit unsigned integer.

LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger) LessThan(UInt64, BigInteger)

부호 없는 64비트 정수가 BigInteger 값보다 작은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a 64-bit unsigned integer is less than a BigInteger value.

LessThanOrEqual(UInt64, BigInteger) LessThanOrEqual(UInt64, BigInteger) LessThanOrEqual(UInt64, BigInteger) LessThanOrEqual(UInt64, BigInteger)

부호 없는 64비트 정수가 BigInteger 값보다 작거나 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a 64-bit unsigned integer is less than or equal to a BigInteger value.

LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger) LessThanOrEqual(BigInteger, BigInteger)

BigInteger 값이 다른 BigInteger 값보다 작거나 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is less than or equal to another BigInteger value.

LessThanOrEqual(BigInteger, UInt64) LessThanOrEqual(BigInteger, UInt64) LessThanOrEqual(BigInteger, UInt64) LessThanOrEqual(BigInteger, UInt64)

BigInteger 값이 부호 없는 64비트 정수보다 작거나 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit unsigned integer.

LessThanOrEqual(Int64, BigInteger) LessThanOrEqual(Int64, BigInteger) LessThanOrEqual(Int64, BigInteger) LessThanOrEqual(Int64, BigInteger)

부호 있는 64비트 정수가 BigInteger 값보다 작거나 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a 64-bit signed integer is less than or equal to a BigInteger value.

LessThanOrEqual(BigInteger, Int64) LessThanOrEqual(BigInteger, Int64) LessThanOrEqual(BigInteger, Int64) LessThanOrEqual(BigInteger, Int64)

BigInteger 값이 부호 있는 64비트 정수보다 작거나 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether a BigInteger value is less than or equal to a 64-bit signed integer.

Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger) Modulus(BigInteger, BigInteger)

지정된 두 BigInteger 값을 나눈 나머지를 반환합니다.Returns the remainder that results from division with two specified BigInteger values.

Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger) Multiply(BigInteger, BigInteger)

지정된 두 BigInteger 값을 곱합니다.Multiplies two specified BigInteger values.

OnesComplement(BigInteger) OnesComplement(BigInteger) OnesComplement(BigInteger) OnesComplement(BigInteger)

BigInteger 값에 대한 비트 1의 보수를 반환합니다.Returns the bitwise one's complement of a BigInteger value.

RightShift(BigInteger, Int32) RightShift(BigInteger, Int32) RightShift(BigInteger, Int32) RightShift(BigInteger, Int32)

BigInteger 값을 지정된 비트 수만큼 오른쪽으로 이동합니다.Shifts a BigInteger value a specified number of bits to the right.

Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger) Subtraction(BigInteger, BigInteger)

다른 BigInteger 값에서 BigInteger 값을 뺍니다.Subtracts a BigInteger value from another BigInteger value.

UnaryNegation(BigInteger) UnaryNegation(BigInteger) UnaryNegation(BigInteger) UnaryNegation(BigInteger)

지정된 BigInteger 값을 부정합니다.Negates a specified BigInteger value.

UnaryPlus(BigInteger) UnaryPlus(BigInteger) UnaryPlus(BigInteger) UnaryPlus(BigInteger)

BigInteger 피연산자의 값을 반환합니다.Returns the value of the BigInteger operand. 피연산자의 부호는 변경되지 않습니다.(The sign of the operand is unchanged.)

명시적 인터페이스 구현

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)

적용 대상