BigInteger Структура

Определение

Представляет произвольно большое целое число со знаком.

public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, IFormattable
public value class BigInteger : IComparable, IComparable<System::Numerics::BigInteger>, IEquatable<System::Numerics::BigInteger>, ISpanFormattable
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, ISpanFormattable
[System.Serializable]
public struct BigInteger : IComparable, IComparable<System.Numerics.BigInteger>, IEquatable<System.Numerics.BigInteger>, IFormattable
type BigInteger = struct
    interface IFormattable
type BigInteger = struct
    interface ISpanFormattable
    interface IFormattable
[<System.Serializable>]
type BigInteger = struct
    interface IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), IFormattable
Public Structure BigInteger
Implements IComparable, IComparable(Of BigInteger), IEquatable(Of BigInteger), ISpanFormattable
Наследование
BigInteger
Атрибуты
Реализации

Комментарии

BigIntegerТип является неизменяемым типом, представляющим произвольно большое целое число, значение которого теоретически не имеет верхней или нижней границ. Элементы BigInteger типа тесно параллельно с другими целочисленными типами (,,,,,, Byte Int16 Int32 Int64 SByte UInt16 UInt32 и UInt64 ). этот тип отличается от других целочисленных типов в платформа .NET Framework, имеющих диапазон, определяемый их MinValue MaxValue свойствами и.

Примечание

Так как BigInteger тип является неизменяемым (см. раздел «изменяемость » и структура BigInteger) и, поскольку он не имеет верхней или нижней границы, OutOfMemoryException может быть вызван любой операцией, которая приводит к BigInteger чрезмерному увеличению значения.

Создание экземпляра объекта BigInteger

Создать экземпляр BigInteger объекта можно несколькими способами.

  • Можно использовать new ключевое слово и предоставить конструктору любое целое число или значение с плавающей запятой в качестве параметра BigInteger . (Значения с плавающей запятой усекаются до того, как они будут назначены BigInteger .) В следующем примере показано использование new ключевого слова для создания экземпляров BigInteger значений.

    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 переменную и присвоить ей значение точно так же, как любой числовой тип, если это значение является целочисленным типом. В следующем примере используется присваивание для создания BigInteger значения из 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
    
  • BigIntegerПри приведении значения или первом преобразовании его в объект можно присвоить значение Decimal или float. в следующем примере явным образом приводится (в C#) или преобразуется (в Visual Basic) a Double и Decimal значение в 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 объекта, значение которого находится в диапазоне одного из существующих числовых типов. Можно создать экземпляр BigInteger объекта, значение которого может превышать диапазон существующих числовых типов одним из трех способов:

  • Можно использовать new ключевое слово и предоставить конструктору массив байтов любого размера BigInteger.BigInteger . Пример:

    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 . Пример:

    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 результат. В следующем примере это делается путем кубинг UInt64.MaxValue и присваивания результата 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
    

Неинициализированное значение BigInteger равно Zero .

Выполнение операций с BigInteger значениями

Экземпляр можно использовать BigInteger так же, как любой другой целочисленный тип. BigInteger перегружает стандартные числовые операторы, позволяя выполнять базовые математические операции, такие как сложение, вычитание, деление, умножение, вычитание, отрицание и унарное отрицание. Можно также использовать стандартные числовые операторы для сравнения двух BigInteger значений друг с другом. Как и другие целочисленные типы, BigInteger также поддерживает операторы побитового And ,, Or XOr , сдвига влево и сдвига вправо. Для языков, которые не поддерживают пользовательские операторы, BigInteger структура также предоставляет эквивалентные методы для выполнения математических операций. К ним относятся,,,, Add Divide Multiply Negate Subtract и несколько других.

Многие члены BigInteger структуры непосредственно соответствуют элементам других целочисленных типов. Кроме того, BigInteger добавляет следующие элементы:

  • Sign, который возвращает значение, указывающее знак BigInteger значения.

  • Abs, который возвращает абсолютное значение BigInteger значения.

  • DivRem, который возвращает как частную, так и оставшуюся часть операции деления.

  • GreatestCommonDivisor, который возвращает наибольший общий делитель двух BigInteger значений.

Многие из этих дополнительных элементов соответствуют членам Math класса, который предоставляет функциональные возможности для работы с примитивными числовыми типами.

Изменяемость и структура BigInteger

В следующем примере создается экземпляр BigInteger объекта, а затем его значение увеличивается на единицу.

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)

Хотя в этом примере возникает изменение значения существующего объекта, это не так. BigInteger объекты являются неизменяемыми, а это означает, что среда CLR фактически создает новый BigInteger объект и присваивает ему значение, которое больше предыдущего значения. Затем этот новый объект возвращается вызывающему объекту.

Примечание

Другие числовые типы в .NET также являются неизменяемыми. Однако, поскольку BigInteger тип не имеет верхней или нижней границы, его значения могут увеличиваться очень большими и повлиять на производительность.

Хотя этот процесс является прозрачным для вызывающего, он приводит к снижению производительности. В некоторых случаях, особенно если повторяющиеся операции выполняются в цикле на очень больших BigInteger значениях, снижение производительности может быть значительным. Например, в следующем примере операция выполняется повторно до миллиона раз, а BigInteger значение увеличивается на единицу каждый раз, когда операция выполняется.

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 переменной. Конечное значение переменной может быть назначено BigInteger объекту при выходе из цикла. Ниже приведен пример.

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

Работа с массивами байтов и шестнадцатеричными строками

При преобразовании BigInteger значений в массивы байтов или при преобразовании массивов байтов в BigInteger значения необходимо учитывать порядок байтов. BigIntegerСтруктура требует, чтобы отдельные байты в массиве байтов отображались в порядке с прямым порядком байтов (то есть байты нижнего порядка в значении предшествуют байтам более высокого порядка). Можно округлить BigInteger значение, вызвав ToByteArray метод, а затем передав полученный массив байтов в BigInteger(Byte[]) конструктор, как показано в следующем примере.

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[]) конструктор. В следующем примере создается экземпляр BigInteger значения из массива байтов, представляющего Int16 значение.

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Структура предполагает, что отрицательные значения хранятся с помощью представления дополнения двух. Поскольку BigInteger структура представляет числовое значение без фиксированной длины, BigInteger(Byte[]) конструктор всегда интерпретирует наиболее значимый бит последнего байта в массиве как бит знака. Чтобы предотвратить BigInteger(Byte[]) путаницу в конструкторе для представления отрицательного значения в двух дополнениех с помощью знака и величины положительного значения, положительные значения, в которых обычно устанавливается наиболее значимый бит последнего байта в массиве байтов, должны включать дополнительный байт, значение которого равно 0. Например, 0xC0 0xBD 0xF0 0xFF — это шестнадцатеричное представление с прямым порядком байтов 1 000 000 или 4 293 967 296. Поскольку наиболее значимый бит последнего байта в этом массиве равен ON, значение массива байтов интерпретируется BigInteger(Byte[]) конструктором как-1 000 000. Для создания экземпляра, BigInteger значение которого является положительным, массив байтов, элементы которого 0XC0 0XBD 0XF0 0xFF 0x00, должны передаваться в конструктор. Это показано в следующем примере.

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 методом из положительных значений, включают этот дополнительный байт нулевого значения. Таким образом, BigInteger структура может успешно выполнять циклические значения, назначив их в, а затем восстановив из байтовых массивов, как показано в следующем примере.

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

Однако может потребоваться добавить этот дополнительный байт нулевого значения в массивы байтов, создаваемые разработчиком динамически или возвращаемые методами, которые преобразуют целые числа без знака в байтовые массивы (например BitConverter.GetBytes(UInt16) ,, BitConverter.GetBytes(UInt32) и BitConverter.GetBytes(UInt64) ).

При синтаксическом анализе шестнадцатеричной строки BigInteger.Parse(String, NumberStyles) методы и BigInteger.Parse(String, NumberStyles, IFormatProvider) предполагают, что если наиболее значимый бит первого байта в строке задан, или если первая шестнадцатеричная цифра строки представляет младшие четыре бита байтового значения, значение представлено с использованием представления дополнения двух. Например, "FF01" и "F01" представляют десятичное значение-255. Чтобы отличить положительные значения от отрицательных, положительные значения должны включать ноль в начале. Соответствующие перегрузки ToString метода, когда они передаются в виде строки формата "X", добавляют в возвращаемую шестнадцатеричную строку в качестве положительных значений ноль в начале. Это позволяет значениям циклического приема BigInteger значений с помощью ToString Parse методов и, как показано в следующем примере.

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.

Однако шестнадцатеричные строки, созданные путем вызова ToString методов других целочисленных типов или перегрузок ToString метода, включающих toBase параметр, не обозначают знак значения или исходный тип данных, от которого была получена шестнадцатеричная строка. Для успешного создания экземпляра BigInteger значения из такой строки требуется дополнительная логика. В следующем примере показана одна возможная реализация.

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

Инициализирует новый экземпляр структуры BigInteger, используя значение Decimal.

BigInteger(Double)

Инициализирует новый экземпляр структуры BigInteger, используя значение с плавающей запятой двойной точности.

BigInteger(Int32)

Инициализирует новый экземпляр структуры BigInteger, используя 32-разрядное знаковое целое число.

BigInteger(Int64)

Инициализирует новый экземпляр структуры BigInteger, используя 64-разрядное целое число со знаком.

BigInteger(ReadOnlySpan<Byte>, Boolean, Boolean)

Инициализирует новый экземпляр структуры BigInteger, используя значения в диапазоне байтов, доступном только для чтения, и при необходимости указывая кодировку подписи и порядок следования байтов.

BigInteger(Single)

Инициализирует новый экземпляр структуры BigInteger, используя значение с плавающей запятой одиночной точности.

BigInteger(UInt32)

Инициализирует новый экземпляр структуры BigInteger, используя 32-разрядное целое число без знака.

BigInteger(UInt64)

Инициализирует новый экземпляр структуры BigInteger, используя 64-разрядное целое число без знака.

Свойства

IsEven

Указывает, равно ли значение текущего объекта BigInteger четному числу.

IsOne

Указывает, равно ли значение текущего объекта BigInteger значению One.

IsPowerOfTwo

Указывает, равно ли значение текущего объекта BigInteger степени двух.

IsZero

Указывает, равно ли значение текущего объекта BigInteger значению Zero.

MinusOne

Получает значение, представляющее минус единицу (-1).

One

Получает значение, представляющее единицу (1).

Sign

Получает число, указывающее знак (минус, плюс или нуль) текущего объекта BigInteger.

Zero

Получает значение, представляющее 0 (нуль).

Методы

Abs(BigInteger)

Получает абсолютное значение объекта BigInteger.

Add(BigInteger, BigInteger)

Складывает два значения BigInteger и возвращает результат.

Compare(BigInteger, BigInteger)

Сравнивает два значения BigInteger и возвращает целое значение, которое показывает, больше или меньше первое значение по сравнению со вторым или равно ему.

CompareTo(BigInteger)

Сравнивает данный экземпляр с другим экземпляром BigInteger и возвращает целое число, которое показывает, является ли значение данного экземпляра меньшим, большим или равным значению указанного объекта.

CompareTo(Int64)

Сравнивает данный экземпляр с 64-разрядным знаковым целым числом и возвращает целое число, которое показывает, является ли значение данного экземпляра меньшим, большим или равным значению 64-битового знакового целого числа.

CompareTo(Object)

Сравнивает данный экземпляр с указанным объектом и возвращает целое число, которое показывает, является ли значение данного экземпляра меньше, больше или равно значению заданного объекта.

CompareTo(UInt64)

Сравнивает данный экземпляр с 64-разрядным целым числом без знака и возвращает целое число, которое показывает, является ли значение данного экземпляра меньшим или большим по сравнению со значением 64-битового целого числа без знака или равным ему.

Divide(BigInteger, BigInteger)

Делит одно значение BigInteger на другое и возвращает результат.

DivRem(BigInteger, BigInteger, BigInteger)

Делит одно значение BigInteger на другое, возвращает результат, а также возвращает остаток в виде параметра вывода.

Equals(BigInteger)

Возвращает значение, определяющее равны ли текущий экземпляр и указанный объект BigInteger.

Equals(Int64)

Возвращает значение, определяющее, равны ли текущий экземпляр и 64-разрядное целое число со знаком.

Equals(Object)

Возвращает значение, определяющее, равны ли текущий экземпляр и указанный объект.

Equals(UInt64)

Возвращает значение, определяющее, равны ли текущий экземпляр и 64-разрядное целое число без знака.

GetBitLength()

Возвращает число бит, необходимых для самого короткого представления текущего экземпляра в дополнительном коде без знакового бита.

GetByteCount(Boolean)

Возвращает число байтов, которое будет выводиться ToByteArray(Boolean, Boolean) и TryWriteBytes(Span<Byte>, Int32, Boolean, Boolean).

GetHashCode()

Возвращает хэш-код для текущего объекта BigInteger.

GreatestCommonDivisor(BigInteger, BigInteger)

Находит наибольший общий делитель двух значений BigInteger.

Log(BigInteger)

Возвращает натуральный логарифм (с основанием e) указанного числа.

Log(BigInteger, Double)

Возвращает логарифм указанного числа в системе счисления с указанным основанием.

Log10(BigInteger)

Возвращает логарифм с основанием 10 указанного числа.

Max(BigInteger, BigInteger)

Возвращает наибольшее из двух значений BigInteger.

Min(BigInteger, BigInteger)

Возвращает наименьшее из двух значений BigInteger.

ModPow(BigInteger, BigInteger, BigInteger)

Выполняет модульное деление числа, возведенного в степень другого числа.

Multiply(BigInteger, BigInteger)

Возвращает произведение двух значений BigInteger.

Negate(BigInteger)

Меняет знак указанного значения BigInteger.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Преобразует представление числа, содержащегося в указанном диапазоне символов только для чтения в указанном стиле в его эквивалент BigInteger.

Parse(String)

Преобразует строковое представление числа в его эквивалент типа BigInteger.

Parse(String, IFormatProvider)

Преобразует строковое представление числа в указанном формате, связанном с определенным языком и региональными параметрами, в его эквивалент типа BigInteger.

Parse(String, NumberStyles)

Преобразует строковое представление числа с указанным стилем в его эквивалент в формате BigInteger.

Parse(String, NumberStyles, IFormatProvider)

Преобразует строковое представление числа в указанном стиле и формате, связанном с определенным языком и региональными параметрами, в его эквивалент типа BigInteger.

Pow(BigInteger, Int32)

Возводит значение BigInteger в заданную степень.

Remainder(BigInteger, BigInteger)

Выполняет целочисленное деление двух значений BigInteger и возвращает остаток.

Subtract(BigInteger, BigInteger)

Вычитает одно значение BigInteger из другого и возвращает результат.

ToByteArray()

Преобразует значение BigInteger в массив байтов.

ToByteArray(Boolean, Boolean)

Возвращает значение этого BigInteger в виде массива байтов, используя наименьшее количество байтов. Если значение равно нулю, возвращает массив из одного байта, элемент которого равен 0x00.

ToString()

Преобразует числовое значение текущего объекта BigInteger в эквивалентное ему строковое представление.

ToString(IFormatProvider)

Преобразует числовое значение текущего объекта BigInteger в эквивалентное ему строковое представление, используя указанные сведения об особенностях форматирования для данного языка и региональных параметров.

ToString(String)

Преобразует числовое значение текущего объекта BigInteger в эквивалентное строковое представление с использованием указанного формата.

ToString(String, IFormatProvider)

Преобразует значение текущего объекта BigInteger в эквивалентное ему строковое представление с использованием указанного формата и сведений об особенностях формата для определенного языка и региональных параметров.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Форматирует этот экземпляр длинного целого числа в диапазон символов.

TryParse(ReadOnlySpan<Char>, BigInteger)

Пытается преобразовать представление числа, содержащегося в указанном диапазоне символов только для чтения, в его эквивалент типа BigInteger и возвращает значение, определяющее, успешно ли выполнено преобразование.

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

Предпринимает попытку преобразования строкового представления числа в его эквивалент типа BigInteger и возвращает значение, позволяющее определить, успешно ли выполнено преобразование.

TryParse(String, BigInteger)

Предпринимает попытку преобразования строкового представления числа в его эквивалент типа BigInteger и возвращает значение, позволяющее определить, успешно ли выполнено преобразование.

TryParse(String, NumberStyles, IFormatProvider, BigInteger)

Предпринимает попытку преобразования числа в формате, который определяется заданным стилем и языком и региональными параметрами, в эквивалент типа BigInteger и возвращает значение, определяющее, успешно ли выполнено преобразование.

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

Копирует значение этого BigInteger в парные байты с прямым порядком, используя наименьшее количество байт. Если значение равно нулю, возвращает один байт, элемент которого равен 0x00.

Операторы

Addition(BigInteger, BigInteger)

Складывает значения двух указанных объектов BigInteger.

BitwiseAnd(BigInteger, BigInteger)

Выполняет битовую операцию And для двух значений BigInteger.

BitwiseOr(BigInteger, BigInteger)

Выполняет битовую операцию Or для двух значений BigInteger.

Decrement(BigInteger)

Уменьшает значение BigInteger на 1.

Division(BigInteger, BigInteger)

Делит указанное значение BigInteger на другое указанное значение BigInteger, используя целочисленное деление.

Equality(BigInteger, BigInteger)

Возвращает значение, указывающее, равны ли значения двух объектов BigInteger.

Equality(BigInteger, Int64)

Возвращает значение, указывающее, равны ли значение BigInteger и длинное знаковое целое число.

Equality(BigInteger, UInt64)

Возвращает значение, указывающее, равны ли значение BigInteger и длинное целое число без знака.

Equality(Int64, BigInteger)

Возвращает значение, указывающее, равны ли длинное знаковое целое число и значение BigInteger.

Equality(UInt64, BigInteger)

Возвращает значение, указывающее, равны ли длинное целое число без знака и значение BigInteger.

ExclusiveOr(BigInteger, BigInteger)

Выполняет битовую операцию исключающего Or (XOr) для двух значений BigInteger.

Explicit(BigInteger to Byte)

Определяет явное преобразование объекта BigInteger в байтовое значение без знака.

Explicit(BigInteger to Decimal)

Определяет явное преобразование объекта BigInteger в значение Decimal.

Explicit(BigInteger to Double)

Определяет явное преобразование объекта BigInteger в значение Double.

Explicit(BigInteger to Int16)

Определяет явное преобразование объекта BigInteger в значение 16-битового знакового целого числа.

Explicit(BigInteger to Int32)

Определяет явное преобразование объекта BigInteger в значение 32-разрядного целого числа со знаком.

Explicit(BigInteger to Int64)

Определяет явное преобразование объекта BigInteger в значение 64-разрядного целого числа со знаком.

Explicit(BigInteger to SByte)

Определяет явное преобразование объекта BigInteger в значение 8-битового числа со знаком.

Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Int16.

Explicit(BigInteger to Single)

Определяет явное преобразование объекта BigInteger в значение числа с плавающей запятой одиночной точности.

Explicit(BigInteger to UInt16)

Определяет явное преобразование объекта BigInteger в значение 16-битового целого числа без знака.

Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Int32.

Explicit(BigInteger to UInt32)

Определяет явное преобразование объекта BigInteger в значение 32-разрядного целого числа без знака.

Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Int64.

Explicit(BigInteger to UInt64)

Определяет явное преобразование объекта BigInteger в значение 64-разрядного целого числа без знака.

Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Double.

Explicit(Decimal to BigInteger)

Определяет явное преобразование объекта Decimal в значение BigInteger.

Explicit(Double to BigInteger)

Определяет явное преобразование значения Double в значение BigInteger.

Explicit(Single to BigInteger)

Определяет явное преобразование значения Single в значение BigInteger.

GreaterThan(BigInteger, BigInteger)

Возвращает значение, определяющее, действительно ли значение типа BigInteger больше другого значения типа BigInteger.

GreaterThan(BigInteger, Int64)

Возвращает значение, определяющее, действительно ли значение BigInteger больше значения 64-битового знакового целого числа.

GreaterThan(BigInteger, UInt64)

Возвращает значение, определяющее действительно ли значение BigInteger больше 64-битового целого числа без знака.

GreaterThan(Int64, BigInteger)

Возвращает значение, определяющее, действительно 64-разрядное знаковое целое число больше или равно значению BigInteger.

GreaterThan(UInt64, BigInteger)

Возвращает значение, определяющее действительно ли значение BigInteger больше 64-битового целого числа без знака.

GreaterThanOrEqual(BigInteger, BigInteger)

Возвращает значение, определяющее, действительно ли значение типа BigInteger больше или равно другому значению типа BigInteger.

GreaterThanOrEqual(BigInteger, Int64)

Возвращает значение, определяющее, действительно ли значение BigInteger больше или равно значению 64-битового знакового целого числа.

GreaterThanOrEqual(BigInteger, UInt64)

Возвращает значение, определяющее, действительно ли значение BigInteger больше или равно значению 64-битового целого числа без знака.

GreaterThanOrEqual(Int64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное знаковое целое число больше или равно значению BigInteger.

GreaterThanOrEqual(UInt64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака больше или равно значению BigInteger.

Implicit(Byte to BigInteger)

Определяет неявное преобразование значения типа byte без знака в значение BigInteger.

Implicit(Int16 to BigInteger)

Определяет неявное преобразование 16-битового знакового целого числа в значение BigInteger.

Implicit(Int32 to BigInteger)

Определяет неявное преобразование 32-разрядного целого числа со знаком в значение BigInteger.

Implicit(Int64 to BigInteger)

Определяет неявное преобразование 64-разрядного целого числа со знаком в значение BigInteger.

Implicit(SByte to BigInteger)

Определяет неявное преобразование 8-битового знакового целого числа в значение BigInteger.

Этот интерфейс API CLS-несовместим. Совместимая альтернатива — BigInteger(Int32).

Implicit(UInt16 to BigInteger)

Определяет неявное преобразование 16-битового целого числа без знака в значение BigInteger.

Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Implicit(Int32 to BigInteger).

Implicit(UInt32 to BigInteger)

Определяет неявное преобразование 32-разрядного целого числа без знака в значение BigInteger.

Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Implicit(Int64 to BigInteger).

Implicit(UInt64 to BigInteger)

Определяет неявное преобразование 64-разрядного целого числа без знака в значение BigInteger.

Этот интерфейс API CLS-несовместим. Совместимая альтернатива — Double.

Increment(BigInteger)

Увеличивает значение BigInteger на 1.

Inequality(BigInteger, BigInteger)

Возвращает значение, указывающее, имеют ли два объекта BigInteger различные значения.

Inequality(BigInteger, Int64)

Возвращает значение, определяющее, действительно ли значение BigInteger и 64-разрядное знаковое целое число не равны.

Inequality(BigInteger, UInt64)

Возвращает значение, определяющее, действительно ли значение BigInteger и 64-разрядное целое число без знака не равны.

Inequality(Int64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное знаковое целое число и значение BigInteger не равны.

Inequality(UInt64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака и значение BigInteger не равны.

LeftShift(BigInteger, Int32)

Сдвигает значение BigInteger на указанное число битов влево.

LessThan(BigInteger, BigInteger)

Возвращает значение, определяющее, действительно ли значение типа BigInteger меньше другого значения типа BigInteger.

LessThan(BigInteger, Int64)

Возвращает значение, определяющее, действительно ли значение BigInteger меньше 64-битового знакового целого числа.

LessThan(BigInteger, UInt64)

Возвращает значение, определяющее, действительно ли значение BigInteger меньше 64-битового целого числа без знака.

LessThan(Int64, BigInteger)

Возвращает значение, определяющее, действительно 64-разрядное знаковое целое число меньше значения BigInteger.

LessThan(UInt64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака меньше значения BigInteger.

LessThanOrEqual(BigInteger, BigInteger)

Возвращает значение, определяющее, действительно ли значение типа BigInteger меньше или равно другому значению типа BigInteger.

LessThanOrEqual(BigInteger, Int64)

Возвращает значение, определяющее, действительно ли значение BigInteger меньше или равно 64-разрядному знаковому целому числу.

LessThanOrEqual(BigInteger, UInt64)

Возвращает значение, определяющее, действительно ли значение BigInteger меньше или равно 64-разрядному целому числу без знака.

LessThanOrEqual(Int64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное знаковое целое число меньше или равно значению BigInteger.

LessThanOrEqual(UInt64, BigInteger)

Возвращает значение, определяющее, действительно ли 64-разрядное целое число без знака меньше или равно значению BigInteger.

Modulus(BigInteger, BigInteger)

Возвращает остаток от деления двух заданных значений BigInteger.

Multiply(BigInteger, BigInteger)

Умножает два заданных значения BigInteger.

OnesComplement(BigInteger)

Возвращает результат битовой операции дополнения до единицы для значения BigInteger.

RightShift(BigInteger, Int32)

Сдвигает значение BigInteger на указанное число битов вправо.

Subtraction(BigInteger, BigInteger)

Вычитает значение BigInteger из другого значения BigInteger.

UnaryNegation(BigInteger)

Меняет знак указанного значения BigInteger.

UnaryPlus(BigInteger)

Возвращает значение операнда BigInteger. (Знак операнда не изменяется.)

Явные реализации интерфейса

IComparable.CompareTo(Object)

Сравнивает данный экземпляр с указанным объектом и возвращает целое число, которое показывает, является ли значение данного экземпляра меньше, больше или равно значению заданного объекта.

Применяется к