BigInteger in Hex/Dezimal/Oktal/Binär-strings?

Konvertieren BigInteger - zu-dezimal -, hex -, Binär -, oktal-string:

Beginnen wir mit einem BigInteger Wert:

BigInteger bigint = BigInteger.Parse("123456789012345678901234567890");

Basis 10 und Basis 16

Die integrierte Basis 10 (dezimal) und Basis 16 (hexadezimal) coversions sind einfach:

//Convert to base 10 (decimal):
string base10 = bigint.ToString();

//Convert to base 16 (hexadecimal):
string base16 = bigint.ToString("X");

Führenden Nullen (positive vs. negative BigInteger-Werte)

Beachten Sie, dass ToString("X") sorgt hexadezimale Zeichenfolgen haben eine führende null, wenn der Wert des BigInteger ist positiv. Dies ist im Gegensatz zu dem üblichen Verhalten von ToString("X") bei der Umwandlung von anderen Wert-Typen, wobei führende Nullen unterdrückt werden.

BEISPIEL:

var positiveBigInt = new BigInteger(128);
var negativeBigInt = new BigInteger(-128);
Console.WriteLine(positiveBigInt.ToString("X"));
Console.WriteLine(negativeBigInt.ToString("X"));

ERGEBNIS:

080
80

Es ist ein Zweck für dieses Verhalten als eine führende null zeigt an der BigInteger ist ein positiver Wert--im wesentlichen, die führende null liefert das Zeichen. Dies ist erforderlich (im Gegensatz zu anderen Wert-Typ-Konvertierungen), weil ein BigInteger hat keine Feste Größe; daher gibt es keine ausgewiesenen Vorzeichen-bit. Die führende null kennzeichnet einen positiven Wert, im Gegensatz zu einer negativen. Dies ermöglicht eine "round-tripping" BigInteger Werte durch ToString() und zurück durch Parse(). Dieses Verhalten wird diskutiert über die BigInteger-Struktur - Seite auf MSDN.

Extension Methoden: BigInteger, Binär, Hex, Oktal

Hier ist eine Klasse mit extension-Methoden zum konvertieren von BigInteger Instanzen zu Binär -, hexadezimal-und oktal-strings:

using System;
using System.Numerics;
using System.Text;

///<summary>
///Extension methods to convert <see cref="System.Numerics.BigInteger"/>
///instances to hexadecimal, octal, and binary strings.
///</summary>
public static class BigIntegerExtensions
{
  ///<summary>
  ///Converts a <see cref="BigInteger"/> to a binary string.
  ///</summary>
  ///<param name="bigint">A <see cref="BigInteger"/>.</param>
  ///<returns>
  ///A <see cref="System.String"/> containing a binary
  ///representation of the supplied <see cref="BigInteger"/>.
  ///</returns>
  public static string ToBinaryString(this BigInteger bigint)
  {
    var bytes = bigint.ToByteArray();
    var idx = bytes.Length - 1;

    //Create a StringBuilder having appropriate capacity.
    var base2 = new StringBuilder(bytes.Length * 8);

    //Convert first byte to binary.
    var binary = Convert.ToString(bytes[idx], 2);

    //Ensure leading zero exists if value is positive.
    if (binary[0] != '0' && bigint.Sign == 1)
    {
      base2.Append('0');
    }

    //Append binary string to StringBuilder.
    base2.Append(binary);

    //Convert remaining bytes adding leading zeros.
    for (idx--; idx >= 0; idx--)
    {
      base2.Append(Convert.ToString(bytes[idx], 2).PadLeft(8, '0'));
    }

    return base2.ToString();
  }

  ///<summary>
  ///Converts a <see cref="BigInteger"/> to a hexadecimal string.
  ///</summary>
  ///<param name="bigint">A <see cref="BigInteger"/>.</param>
  ///<returns>
  ///A <see cref="System.String"/> containing a hexadecimal
  ///representation of the supplied <see cref="BigInteger"/>.
  ///</returns>
  public static string ToHexadecimalString(this BigInteger bigint)
  {
    return bigint.ToString("X");
  }

  ///<summary>
  ///Converts a <see cref="BigInteger"/> to a octal string.
  ///</summary>
  ///<param name="bigint">A <see cref="BigInteger"/>.</param>
  ///<returns>
  ///A <see cref="System.String"/> containing an octal
  ///representation of the supplied <see cref="BigInteger"/>.
  ///</returns>
  public static string ToOctalString(this BigInteger bigint)
  {
    var bytes = bigint.ToByteArray();
    var idx = bytes.Length - 1;

    //Create a StringBuilder having appropriate capacity.
    var base8 = new StringBuilder(((bytes.Length / 3) + 1) * 8);

    //Calculate how many bytes are extra when byte array is split
    //into three-byte (24-bit) chunks.
    var extra = bytes.Length % 3;

    //If no bytes are extra, use three bytes for first chunk.
    if (extra == 0)
    {
      extra = 3;
    }

    //Convert first chunk (24-bits) to integer value.
    int int24 = 0;
    for (; extra != 0; extra--)
    {
      int24 <<= 8;
      int24 += bytes[idx--];
    }

    //Convert 24-bit integer to octal without adding leading zeros.
    var octal = Convert.ToString(int24, 8);

    //Ensure leading zero exists if value is positive.
    if (octal[0] != '0' && bigint.Sign == 1)
    {
      base8.Append('0');
    }

    //Append first converted chunk to StringBuilder.
    base8.Append(octal);

    //Convert remaining 24-bit chunks, adding leading zeros.
    for (; idx >= 0; idx -= 3)
    {
      int24 = (bytes[idx] << 16) + (bytes[idx - 1] << 8) + bytes[idx - 2];
      base8.Append(Convert.ToString(int24, 8).PadLeft(8, '0'));
    }

    return base8.ToString();
  }
}

Auf den ersten Blick, die diese Methoden scheinen komplexer als notwendig. Ein bisschen zusätzliche Komplexität ist, in der Tat, Hinzugefügt, um sicherzustellen, dass die entsprechenden führenden Nullen vorhanden sind, in die konvertiert strings.

Betrachten wir jeden Erweiterung Methode um zu sehen, wie Sie arbeiten:

BigInteger.ToBinaryString()

Hier ist, wie diese Erweiterung Methode zum konvertieren von BigInteger in einen Binär-string:

//Convert BigInteger to binary string.
bigint.ToBinaryString();

Den wesentlichen Kern jedes dieser Erweiterung Methoden ist die BigInteger.ToByteArray() Methode. Diese Methode wandelt eine BigInteger ein byte-array, das, wie wir bekommen können die binäre Darstellung eines BigInteger Wert:

var bytes = bigint.ToByteArray();

Beachten Sie aber, das zurückgegebene ByteArray im little-endian-Reihenfolge, so dass das erste array-element ist das least significant byte (LSB) des BigInteger. Seit ein StringBuilder wird genutzt, um den Ausgabe-string--beginnt bei den meisten-signifikante Ziffer (MSB)--das byte-array müssen Durchlaufen werden in umgekehrter so, dass das most significant byte ist erst konvertiert.

So, ein index-Zeiger gesetzt ist, zu der die meisten signifikanten Stelle (das Letzte element) in das byte-array:

var idx = bytes.Length - 1;

Zur Erfassung der umgewandelten bytes, ein StringBuilder erstellt:

var base2 = new StringBuilder(bytes.Length * 8);

Den StringBuilder Konstruktor nimmt die Kapazität für die StringBuilder. Die Kapazität für die StringBuilder wird berechnet, indem die Anzahl von bytes zu konvertieren, multipliziert mit acht (acht binären Ziffern, die das Ergebnis von jedem byte konvertiert).

Das erste byte wird dann in einen Binär-string:

var binary = Convert.ToString(bytes[idx], 2);

Zu diesem Zeitpunkt ist es notwendig, um sicherzustellen, dass eine führende null existiert, wenn die BigInteger ist ein positiver Wert (siehe Diskussion oben). Wenn die erste umgebaute Ziffer ist keine null, und bigint positiv ist, dann eine '0' an die StringBuilder:

//Ensure leading zero exists if value is positive.
if (binary[0] != '0' && bigint.Sign == 1)
{
  base2.Append('0');
}

Nächsten, die konvertiert byte angehängt, um die StringBuilder:

base2.Append(binary);

Konvertieren Sie die verbleibenden bytes, die eine Schleife durchläuft den Rest des byte-Arrays in umgekehrter Reihenfolge:

for (idx--; idx >= 0; idx--)
{
  base16.Append(Convert.ToString(bytes[idx], 2).PadLeft(8, '0'));
}

Beachten Sie, dass jedes konvertiert byte aufgefüllt wird Links mit Nullen ('0'), als notwendig, so dass die konvertierte Zeichenfolge ist acht binären Zeichen. Dies ist äußerst wichtig. Ohne diese Polsterung, die den hexadezimalen Wert '101' konvertiert einen binären Wert '11'. Die führenden Nullen sicherzustellen, dass die Konvertierung '100000001'.

Wenn alle bytes werden umgewandelt, die StringBuilder enthält die vollständige Binär-string, der zurückgegeben wird, durch den extension-Methode:

return base2.ToString();

BigInteger.ToOctalString

Umwandlung einer BigInteger um eine oktale (Basis 8) der string ist komplizierter. Das problem ist, oktal-Zahl werden die drei bits, die nicht einem vielfachen von acht bits hielt in jedem element des byte-Arrays erstellt von BigInteger.ToByteArray(). Um dieses problem zu lösen, drei bytes aus dem array kombiniert werden, in Stücken von 24-bit. Jeder 24-bit-chunk gleichmäßig konvertiert zu acht oktal-Zeichen.

Den ersten 24-bit-chunk erfordert einige modulo-Mathe:

var extra = bytes.Length % 3;

Dieser Berechnung wird bestimmt, wie viele bytes sind "extra", wenn die gesamte byte-array ist aufgeteilt in drei byte (24-bit) zu realisieren. Die erste Umwandlung in eine Oktalzahl (das am meisten signifikante Ziffern) erhält die "extra" - bytes, so dass alle restlichen Umbauten werden drei bytes jeder.

Wenn es keine "extra" - Byte, dann das erste Stück bekommt eine volle drei bytes:

if (extra == 0)
{
  extra = 3;
}

Den ersten chunk geladen wird in eine integer-variable namens int24 hält bis zu 24-bit. Jedes byte der chunk geladen ist. Als zusätzliche bytes, die geladen werden, werden die vorherigen bit in int24 Links verschoben um 8 bits, um Platz zu machen:

int int24 = 0;
for (; extra != 0; extra--)
{
  int24 <<= 8;
  int24 += bytes[idx--];
}

Konvertierung eines 24-bit-chunk oktal erfolgt durch:

var octal = Convert.ToString(int24, 8);

Wieder, die erste Ziffer muss eine führende null, wenn der BigInteger ist ein positiver Wert:

//Ensure leading zero exists if value is positive.
if (octal[0] != '0' && bigint.Sign == 1)
{
  base8.Append('0');
}

Die erste umgebaute Stück ist angehängt an die StringBuilder:

base8.Append(octal);

Den verbleibenden 24-bit-Blöcken umgewandelt werden in eine Schleife:

for (; idx >= 0; idx -= 3)
{
  int24 = (bytes[idx] << 16) + (bytes[idx -1] << 8) + bytes[idx - 2];
  base8.Append(Convert.ToString(int24, 8).PadLeft(8, '0'));
}

Wie die binäre Konvertierung, jede konvertierte oktal-string von Links mit Nullen aufgefüllt, so dass die '7' wird '00000007'. Dieser sorgt dafür, dass die Nullen nicht gelöscht werden aus der Mitte des umgewandelten strings (d.h., '17', statt '100000007').

Umstellung auf Base x?

Umwandlung einer BigInteger zu anderen Zahlensystemen könnte viel komplizierter. Solange die Anzahl Basis ist eine Potenz von zwei ist (D. H., 2, 4, 8, 16) das byte-array erstellt durch BigInteger.ToByteArray() angemessen aufgeteilt in Blöcken von bits und umgesetzt.

Jedoch, wenn die Zahl, die Basis ist nicht eine Potenz von zwei ist, wird das problem viel komplizierter und erfordert viel looping und division. Als solcher Zahl, base-conversions sind selten, ich habe nur die gängigen computing-Anzahl Basen hier.

InformationsquelleAutor Kevin P. Rice

Dies ist eine einfache Methode zum konvertieren von BigInteger zu jeder base:

public static string ToNBase(BigInteger a, int n)
        {
            StringBuilder sb = new StringBuilder();
            while (a > 0)
            {
                sb.Insert(0,a % n);
                a /= n;
            }
            return sb.ToString();
        }

Es funktioniert perfekt für base 2-10. Wenn Sie möchten, es zu produzieren, hexadezimal-oder andere höhere Basis-Zeichenfolgen, die Sie ändern müssen, um a % b's form nach der Basis, bevor Sie es.

InformationsquelleAutor gkovacs90