Printing multiple integers as one arbitrarily long decimal string

Question

Say I have 16 64-bit unsigned integers. I have been careful to feed the carry as appropriate between them when performing operations. Could I feed them into a method to convert all of them into a single string of decimal digits, as though it was one 1024-bit binary number? In other words, is it possible to make a method that will work for an arbitrary number of integers that represent one larger integer?

I imagine that it would be more difficult for signed integers, as there is the most significant bit to deal with. I suppose it would be that the most significant integer would be the signed integer, and the rest would be unsigned, to represent the remaining 'parts' of the number.

(This is semi-related to another question.)

Answer 1

This is a bit unclear.

Of course, a function such as

void print_1024bit(uint64_t digits[]);

could be written to do this. But if you mean if any of the standard library's printf()-family of functions can do this, then I think the answer is no.

As you probably saw in the other question, the core of converting a binary number into a different base b is made of two operations:

• Modulo b, to figure out the current least significant digit
• Division by b, to remove that digit once it's been generated

When applied until the number is 0, this generates all the digits in reverse order.

So, you need to implement "modulo 10" and "divide by 10" for your 1024-bit number.

For instance, consider the number decimal 4711, which we want to convert to octal just for this example:

1. 4711 % 8 is 7, so the right-most digit is 7
2. 4711 / 8 is 588
3. 588 % 8 is 4, the next digit is 4
4. 588 / 8 is 73
5. 73 % 8 is 1
6. 73 / 8 is 9
7. 9 % 8 is 1
8. 8 / 8 is 1
9. 1 % 8 is 1
10. 1 / 8 is 0, we're done.

So, reading the bold digits from the bottom and up towards the right-most digits, we conclude that 4711₁₀ = 11147₈. You can use a calculator to verify this, or just trust me. :)

Answer 2

You could use the double dabble algorithm, which circumvents the need for multi-precision multiplication and division. In fact, the Wikipedia page contains a C implementation for this algorithm.

Answer 3

It's possible, of course, but not terribly straight-forward.

Rather than reinventing the wheel, how about reusing a library?

The GNU Multi Precision Arithmetic Library is one such possibility. I've not needed such things myself, but it seems to fit your bill.