.NET Conversion of very large numbers to different number base

Question

Is there any way to convert very large binary, decimal and hexadecimal numbers to each other? I have to use it to simulate addressing process up to 256 bits.

I want to do the following conversions (and if it's possible, store them in one object)

very large binary number -> very large decimal number

very large binary number -> very large hexadecimal number

very large decimal number -> very large binary number

very large decimal number -> very large hexadecimal number

very large hexadecimal number -> very large binary number

very large hexadecimal number -> very large decimal number

very large binary number -> string

very large decimal number -> string

very large hexadecimal number -> string

The possibility of splitting and joining very large binary numbers is very important. If it's possible, I would use a class supported solution, and avoid manual conversion from one number base to another using byte[] type.

I've tried the BigInteger class, it can store very large numbers, but can't convert them to another number base.

BigInteger.ToString can convert to hex... but I'm not sure it can do binary. — Jon Skeet, May 17 '13 at 10:57
http://stackoverflow.com/questions/279038/working-with-incredibly-large-numbers-in-net — Dave Bish, May 17 '13 at 10:58
http://stackoverflow.com/questions/14048476/biginteger-to-hex-decimal-octal-binary-strings — Ahmed KRAIEM, May 17 '13 at 11:03

score 0 · Accepted Answer · answered May 17 '13 at 11:09

Solution by Andrew Jonkers :

//Convert number in string representation from base:from to base:to. 
//Return result as a string
public static String Convert(int from, int to, String s)
{
    //Return error if input is empty
    if (String.IsNullOrEmpty(s))
    {
        return ("Error: Nothing in Input String");
    }
    //only allow uppercase input characters in string
    s = s.ToUpper();

    //only do base 2 to base 36 (digit represented by characters 0-Z)"
    if (from < 2 || from > 36 || to < 2 || to > 36) 
    { return ("Base requested outside range"); }

    //convert string to an array of integer digits representing number in base:from
    int il = s.Length;
    int[] fs = new int[il];
    int k = 0;
    for (int i = s.Length - 1; i >= 0; i--)
    {
        if (s[i] >= '0' && s[i] <= '9') { fs[k++] = (int)(s[i] - '0'); }
        else
        {
            if (s[i] >= 'A' && s[i] <= 'Z') { fs[k++] = 10 + (int)(s[i] - 'A'); }
            else
            { return ("Error: Input string must only contain any of 0-9 or A-Z"); } //only allow 0-9 A-Z characters
        }
    }

    //check the input for digits that exceed the allowable for base:from
    foreach(int i in fs)
    {
        if (i >= from) { return ("Error: Not a valid number for this input base"); }
    }

    //find how many digits the output needs
    int ol = il * (from / to+1);
    int[] ts = new int[ol+10]; //assign accumulation array
    int[] cums = new int[ol+10]; //assign the result array
    ts[0] = 1; //initialize array with number 1 

    //evaluate the output
    for (int i = 0; i < il; i++) //for each input digit
    {
        for (int j = 0; j < ol; j++) //add the input digit 
            // times (base:to from^i) to the output cumulator
        {
            cums[j] += ts[j] * fs[i];
            int temp = cums[j];
            int rem = 0;
            int ip = j;
            do // fix up any remainders in base:to
            {
                rem = temp / to;
                cums[ip] = temp-rem*to; ip++;
                cums[ip] += rem;
                temp = cums[ip];
            }
            while (temp >=to);
        }

        //calculate the next power from^i) in base:to format
        for (int j = 0; j < ol; j++)
        {
            ts[j] = ts[j] * from;
        } 
        for(int j=0;j<ol;j++) //check for any remainders
        {
            int temp = ts[j];
            int rem = 0;
            int ip = j;
            do  //fix up any remainders
            {
                rem = temp / to;
                ts[ip] = temp - rem * to; ip++;
                ts[ip] += rem;
                temp = ts[ip];
            }
            while (temp >= to);
        }
    }

    //convert the output to string format (digits 0,to-1 converted to 0-Z characters) 
    String sout = String.Empty; //initialize output string
    bool first = false; //leading zero flag
    for (int i = ol ; i >= 0; i--)
    {
        if (cums[i] != 0) { first = true; }
        if (!first) { continue; }
        if (cums[i] < 10) { sout += (char)(cums[i] + '0'); }
        else { sout += (char)(cums[i] + 'A'-10); }
    }
    if (String.IsNullOrEmpty(sout)) { return "0"; } //input was zero, return 0
    //return the converted string
    return sout;
}

score 0 · Answer 2 · answered Dec 16 '17 at 18:18

I had the same issue once. I wrote simple method which changes array of decimal numbers to array of binary numbers.

 private int[] ConvertDecimalCharArrayToBinaryCharArray(int[] decimalValues)
    {
        List<int> result = new List<int>();
        bool end = false;
        while (end == false)
        {
            result.Add(decimalValues[decimalValues.Length - 1] % 2);

            int previous = 0;
            bool allzeros = true;
            for (int i = 0; i < decimalValues.Length; i++)
            {

                var x = decimalValues[i];
                if (x != 0)
                {
                    allzeros = false;
                }

                if (allzeros && i == decimalValues.Length - 1)
                {
                    end = true;
                }
                var a = (x + previous) / 2;
                if ((x + previous) % 2== 1)
                {
                    previous = 10;
                }
                else
                {
                    previous = 0;
                }
                decimalValues[i] = a;
            }
        }

        result.RemoveAt(result.Count - 1);
        result.Reverse();
        return result.ToArray();
    }

.NET Conversion of very large numbers to different number base

2 Answers2