Implementing Addition, Multiplication, and so on

Arithmetic In Binary

We can do arithmetic in binary or hex by hand just like we do in decimal. To add, line up the digits, add corresponding digits, and if the per-digit sum is greater than the base, carry to the next digit. Easy, right? To subtract, do the exact same thing, but "borrow" from the next digit if the per-digit difference is less than 0.

For example, in binary 01+01=10 because the first digit overflows, and the extra "1" is carried to the next digit. Similarly, 1111+1=10000 because all the digits overflow in sequence. In general, adding a "1" will cause carries to ripple up through ones, flipping them to zeros, until it finally reaches a zero, which it will flip to a one.

Addition in hex is exactly the same--it's a bit tricker to add the larger digits involved, but carries work exactly the same. So 0x8+0x8=0x10, and 0xffff+0x1=0x10000.

Subtraction in binary seems really bizarre until you remember than 10-1=1 in binary--that is, "1" is the one-less-than-zero digit in binary; just like "9" is the corresponding one-below-zero digit in decimal. So when you have to borrow, you just flip the zeros to ones until you hit a one.

Multi-Precision Arithmetic

You can do register-register addition in a single instruction (add). But if you want to add numbers bigger than the registers, you need to break up the addition into register-sized pieces, ordered from lowest value to highest. You'd also have to make sure the carry bits will actually pass between the pieces. There's a handy instruction called 'adc' (add with carry) that looks just like add, but it reads the (semi-secret) 'carry flag' bit from the flags register. Two add a two-int multiprecision number, then, you'd

add loA,loB
adc hiA,hiB

This way, the carry bit coming out of the low addition would be read by the higher addition.

To do this "for real", there are several excellent libraries, such as GMP.

Fast Exponentiation Trick

Say you want to compute x to the power y. This is just x*x*x*...*x, with a total of y copies of x:

The obvious way to do this is really quite slow for big values of y:
    int prod=1;
    for (int i=1;i<=y;i++) prod*=x;
    return prod;

But it's *way* faster to compute x raised to the powers of two by repeated squaring, then combine those powers of two to get x to the y. For example, you can compute x to the 16th by squaring x four times, like so:
    int x2=x*x;
    int x4=x2*x2;
    int x8=x4*x4;
    int x16=x8*x8;

Harkening back to our bitwise operators, we can just decompose y into the corresponding powers-of-two of x, by looking at the bits of y:

/* Return x raised to the power y */
double mypow(double x,int y) 
{
    double prod=1; /* will hold x to the y power */
    double xpow=x; /* will take powers of x */
    for (unsigned int bit=0;bit<sizeof(int)*8;bit++) {
       int mask=(1<<bit);
       if (y&mask) prod=prod*xpow; /* include this power of x */
       if (y<mask) break; /* no higher powers of x included in y */
       xpow=xpow*xpow; /* find next higher square */
    }
    return prod;
}

(Try this in NetRun now!)

For example, raising 2 to the 100th power takes only 8 iterations with this "fast exponentiation" method, but over 100 iterations with slow exponentiation.

The fast exponentiation trick applies to all sorts of stuff--and there's an exact analog for multiplication!