Структуру System.Numerics.BigInteger

В этой статье приводятся дополнительные замечания к справочной документации по этому API.

Тип BigInteger является неизменяемым типом, который представляет произвольно большое целое число, значение которого в теории не имеет верхних или нижних границ. Члены BigInteger типа тесно параллелит другие целочисленные типы (Byte, SByteInt16Int64UInt16Int32UInt32и UInt64 типы). Этот тип отличается от других целочисленных типов в .NET, которые имеют диапазон, указанный их MinValue и MaxValue свойствами.

Примечание.

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 можно назначить объекту, если присвоить значение или преобразовать его в первую очередь. В следующем примере явно выполняется приведение (в C#) или преобразование (в Visual Basic) 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
  

Неинициализированное значение объекта BigIntegerZero.

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

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

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

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

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

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

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

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

Изменяемость

В следующем примере создается экземпляр 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 является шестнадцатеричным представлением шестнадцатеричного представления 1000 000 или 4 293 967 2966. Так как самый значительный бит последнего байта в этом массиве включен, значение массива байтов будет интерпретировано конструктором BigInteger(Byte[]) как -1000 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, IFormatProvider) методы предполагают, BigInteger.Parse(String, NumberStyles) что если задан самый значительный бит первого байта в строке, или если первая шестнадцатеричная цифра строки представляет нижние четыре бита байтового значения, значение представлено с помощью двух дополнительных представлений. Например, как 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 ByteHexExample2
{
    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 Example2
    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.