C++: Binary to Decimal Conversion

Question

I am trying to convert a binary array to decimal in following way:

uint8_t array[8] = {1,1,1,1,0,1,1,1} ;
int decimal = 0 ;    

for(int i = 0 ; i < 8 ; i++)
    decimal = (decimal << 1) + array[i] ;

Actually I have to convert 64 bit binary array to decimal and I have to do it for million times.

Can anybody help me, is there any faster way to do the above ? Or is the above one is nice ?

Answer 1

Your method is adequate, to call it nice I would just not mix bitwise operations and "mathematical" way of converting to decimal, i.e. use either

    decimal = decimal << 1 | array[i];

or

    decimal = decimal * 2 + array[i];

Answer 2

It is important, before attempting any optimisation, to profile the code. Time it, look at the code being generated, and optimise only when you understand what is going on.

And as already pointed out, the best optimisation is to not do something, but to make a higher level change that removes the need.

However...

Most changes you might want to trivially make here, are likely to be things the compiler has already done (a shift is the same as a multiply to the compiler). Some may actually prevent the compiler from making an optimisation (changing an add to an or will restrict the compiler - there are more ways to add numbers, and only you know that in this case the result will be the same).

Pointer arithmetic may be better, but the compiler is not stupid - it ought to already be producing decent code for dereferencing the array, so you need to check that you have not in fact made matters worse by introducing an additional variable.

In this case the loop count is well defined and limited, so unrolling probably makes sense.

Further more it depends on how dependent you want the result to be on your target architecture. If you want portability, it is hard(er) to optimise.

For example, the following produces better code here:

unsigned int x0 = *(unsigned int *)array;
unsigned int x1 = *(unsigned int *)(array+4);

int decimal = ((x0 * 0x8040201) >> 20) + ((x1 * 0x8040201) >> 24);

I could probably also roll a 64-bit version that did 8 bits at a time instead of 4.

But it is very definitely not portable code. I might use that locally if I knew what I was running on and I just wanted to crunch numbers quickly. But I probably wouldn't put it in production code. Certainly not without documenting what it did, and without the accompanying unit test that checks that it actually works.

Answer 3

You could use accumulate, with a doubling and adding binary operation:

int doubleSumAndAdd(const int& sum, const int& next) {
    return (sum * 2) + next;
}

int decimal = accumulate(array, array+ARRAY_SIZE,
                         doubleSumAndAdd);

This produces big-endian integers, whereas OP code produces little-endian.

Answer 4

The binary 'compression' can be generalized as a problem of weighted sum -- and for that there are some interesting techniques.

• X mod (255) means essentially summing of all independent 8-bit numbers.

• X mod 254 means summing each digit with a doubling weight, since 1 mod 254 = 1, 256 mod 254 = 2, 256*256 mod 254 = 2*2 = 4, etc.

  If the encoding was big endian, then *(unsigned long long)array % 254 would produce a weighted sum (with truncated range of 0..253). Then removing the value with weight 2 and adding it manually would produce the correct result:

  uint64_t a = *(uint64_t *)array; return (a & ~256) % 254 + ((a>>9) & 2);

Other mechanism to get the weight is to premultiply each binary digit by 255 and masking the correct bit:

uint64_t a = (*(uint64_t *)array * 255) & 0x0102040810204080ULL; // little endian
uint64_t a = (*(uint64_t *)array * 255) & 0x8040201008040201ULL; // big endian  

In both cases one can then take the remainder of 255 (and correct now with weight 1):

return (a & 0x00ffffffffffffff) % 255 + (a>>56); // little endian, or  
return (a & ~1) % 255 + (a&1);  

For the sceptical mind: I actually did profile the modulus version to be (slightly) faster than iteration on x64.

To continue from the answer of JasonD, parallel bit selection can be iteratively utilized. But first expressing the equation in full form would help the compiler to remove the artificial dependency created by the iterative approach using accumulation:

ret =  ((a[0]<<7) | (a[1]<<6) | (a[2]<<5) | (a[3]<<4) |
        (a[4]<<3) | (a[5]<<2) | (a[6]<<1) | (a[7]<<0));

vs.

HI=*(uint32_t)array, LO=*(uint32_t)&array[4];
LO |= (HI<<4);    // The HI dword has a weight 16 relative to Lo bytes
LO |= (LO>>14);   // High word has 4x weight compared to low word
LO |= (LO>>9);    // high byte has 2x weight compared to lower byte
return LO & 255;

One more interesting technique would be to utilize crc32 as a compression function; then it just happens that the result would be LookUpTable[crc32(array) & 255]; as there is no collision with this given small subset of 256 distinct arrays. However to apply that, one has already chosen the road of even less portability and could as well end up using SSE intrinsics.

Answer 5

Try this, I converted a binary digit of up to 1020 bits

#include <sstream>
#include <string>
#include <math.h>
#include <iostream>
using namespace std;

long binary_decimal(string num) /* Function to convert binary to dec */
{
    long dec = 0, n = 1, exp = 0;
    string bin = num;
       if(bin.length() > 1020){
          cout << "Binary Digit too large" << endl;
       }
       else {

            for(int i = bin.length() - 1; i > -1; i--)
            {
                 n = pow(2,exp++);
                 if(bin.at(i) == '1')
                 dec += n;
            }

       }
  return dec;
}

Theoretically this method will work for a binary digit of infinate length