Double dabble

In computer science, the double dabble algorithm is used to convert binary numbers into binary-coded decimal (BCD) notation. It is also known as the shift-and-add-3 algorithm, and can be implemented using a small number of gates in computer hardware, but at the expense of high latency.

Algorithm
The algorithm operates as follows:

Suppose the original number to be converted is stored in a register that is n bits wide. Reserve a scratch space wide enough to hold both the original number and its BCD representation; $n + 4×ceil(n/3)$ bits will be enough. It takes a maximum of 4 bits in binary to store each decimal digit.

Then partition the scratch space into BCD digits (on the left) and the original register (on the right). For example, if the original number to be converted is eight bits wide, the scratch space would be partitioned as follows:

Hundreds Tens Ones  Original 0010  0100 0011   11110011

The diagram above shows the binary representation of 24310 in the original register, and the BCD representation of 243 on the left.

The scratch space is initialized to all zeros, and then the value to be converted is copied into the "original register" space on the right.

0000 0000 0000  11110011

The algorithm then iterates n times. On each iteration, any BCD digit which is at least 5 (0101 in binary) is incremented by 3 (0011); then the entire scratch space is left-shifted one bit. The increment ensures that a value of 5, incremented and left-shifted, becomes 16 (10000), thus correctly "carrying" into the next BCD digit.

Essentially, the algorithm operates by doubling the BCD value on the left each iteration and adding either one or zero according to the original bit pattern. Shifting left accomplishes both tasks simultaneously. If any digit is five or above, three is added to ensure the value "carries" in base 10.

The double-dabble algorithm, performed on the value 24310, looks like this:

0000 0000 0000  11110011   Initialization 0000 0000 0001  11100110   Shift 0000 0000 0011  11001100   Shift 0000 0000 0111  10011000   Shift 0000 0000 1010  10011000   Add 3 to ONES, since it was 7 0000 0001 0101  00110000   Shift 0000 0001 1000  00110000   Add 3 to ONES, since it was 5 0000 0011 0000  01100000   Shift 0000 0110 0000  11000000   Shift 0000 1001 0000  11000000   Add 3 to TENS, since it was 6 0001 0010 0001  10000000   Shift 0010 0100 0011  00000000   Shift 2   4    3        BCD

Now eight shifts have been performed, so the algorithm terminates. The BCD digits to the left of the "original register" space display the BCD encoding of the original value 243.

Another example for the double dabble algorithm – value 6524410.

104 103  102   101  100    Original binary 0000 0000 0000 0000 0000  1111111011011100   Initialization 0000 0000 0000 0000 0001  1111110110111000   Shift left (1st) 0000 0000 0000 0000 0011  1111101101110000   Shift left (2nd) 0000 0000 0000 0000 0111  1111011011100000   Shift left (3rd) 0000 0000 0000 0000 1010  1111011011100000   Add 3 to 100, since it was 7 0000 0000 0000 0001 0101  1110110111000000   Shift left (4th) 0000 0000 0000 0001 1000  1110110111000000   Add 3 to 100, since it was 5 0000 0000 0000 0011 0001  1101101110000000   Shift left (5th) 0000 0000 0000 0110 0011  1011011100000000   Shift left (6th) 0000 0000 0000 1001 0011  1011011100000000   Add 3 to 101, since it was 6 0000 0000 0001 0010 0111  0110111000000000   Shift left (7th) 0000 0000 0001 0010 1010  0110111000000000   Add 3 to 100, since it was 7 0000 0000 0010 0101 0100  1101110000000000   Shift left (8th) 0000 0000 0010 1000 0100  1101110000000000   Add 3 to 101, since it was 5 0000 0000 0101 0000 1001  1011100000000000   Shift left (9th) 0000 0000 1000 0000 1001  1011100000000000   Add 3 to 102, since it was 5 0000 0000 1000 0000 1100  1011100000000000   Add 3 to 100, since it was 9 0000 0001 0000 0001 1001  0111000000000000   Shift left (10th) 0000 0001 0000 0001 1100  0111000000000000   Add 3 to 100, since it was 9 0000 0010 0000 0011 1000  1110000000000000   Shift left (11th) 0000 0010 0000 0011 1011  1110000000000000   Add 3 to 100, since it was 8 0000 0100 0000 0111 0111  1100000000000000   Shift left (12th) 0000 0100 0000 1010 0111  1100000000000000   Add 3 to 101, since it was 7 0000 0100 0000 1010 1010  1100000000000000   Add 3 to 100, since it was 7 0000 1000 0001 0101 0101  1000000000000000   Shift left (13th) 0000 1011 0001 0101 0101  1000000000000000   Add 3 to 103, since it was 8 0000 1011 0001 1000 0101  1000000000000000   Add 3 to 101, since it was 5 0000 1011 0001 1000 1000  1000000000000000   Add 3 to 100, since it was 5 0001 0110 0011 0001 0001  0000000000000000   Shift left (14th) 0001 1001 0011 0001 0001  0000000000000000   Add 3 to 103, since it was 6 0011 0010 0110 0010 0010  0000000000000000   Shift left (15th) 0011 0010 1001 0010 0010  0000000000000000   Add 3 to 102, since it was 6 0110 0101 0010 0100 0100  0000000000000000   Shift left (16th) 6   5    2    4    4             BCD

Sixteen shifts have been performed, so the algorithm terminates. The decimal value of the BCD digits is: 6*104 + 5*103 + 2*102 + 4*101 + 4*100 = 65244.

Reverse double dabble
The algorithm is fully reversible. By applying the reverse double dabble algorithm a BCD number can be converted to binary. Reversing the algorithm is done by reversing the principal steps of the algorithm:

Reverse double dabble example
The reverse double dabble algorithm, performed on the three BCD digits 2-4-3, looks like this:

BCD Input     Binary Output 2   4    3  0010 0100 0011   00000000   Initialization 0001 0010 0001  10000000   Shifted right 0000 1001 0000  11000000   Shifted right 0000 0110 0000  11000000   Subtracted 3 from 2nd group, because it was 9 0000 0011 0000  01100000   Shifted right 0000 0001 1000  00110000   Shifted right 0000 0001 0101  00110000   Subtracted 3 from 3rd group, because it was 8 0000 0000 1010  10011000   Shifted right 0000 0000 0111  10011000   Subtracted 3 from 3rd group, because it was 10 0000 0000 0011  11001100   Shifted right 0000 0000 0001  11100110   Shifted right 0000 0000 0000  11110011   Shifted right ==========================                        24310

Historical
In the 1960s, the term double dabble was also used for a different mental algorithm, used by programmers to convert a binary number to decimal. It is performed by reading the binary number from left to right, doubling if the next bit is zero, and doubling and adding one if the next bit is one. In the example above, 11110011, the thought process would be: "one, three, seven, fifteen, thirty, sixty, one hundred twenty-one, two hundred forty-three", the same result as that obtained above.