def mul(n, m):
    prod = 0
    while n != 1:
        if n & 1: prod += m
        m <<= 1
        n >>= 1
    return prod + m

def div(n, m):
    t = m
    while t <= n: t <<= 1
    t, q, r = t >> 1, 0, n
    while t >= m:
        q <<= 1
        if t <= r: q, r = q + 1, r - t
        t >>= 1
    return q, r

def gcd(n, m):
    if n == 0 or m == 0: return m + n
    elif not n & 1 and not m & 1: return gcd(n >> 1, m >> 1) << 1
    elif not n & 1: return gcd(n >> 1, m)
    elif not m & 1: return gcd(n, m >> 1)
    else: return gcd(min(n, m), max(n, m) - min(n, m))

def binmul(p, s):
    prod = 0
    while p>=1:
        if p&1:
            prod += s
        p >>= 1
        s <<= 1
    return prod

def bindiv(n, d):
    t = d
    while t < n:
        t <<= 1
    t >>= 1

    q, r = 0, n
    while t >= d:
        q <<= 1
        if t < r:
            q += 1
            r -= t
        t >>= 1
    return q,r

def bingcd(a, b):
    twos = 0

    while a and b:
        if a&1:
            if b&1:
                a,b = (a-b,b) if a>b else (a,b-a)
            else:
                b >>= 1
        elif b&1:
            a >>= 1
        else:
            twos += 1
            a >>= 1
            b >>= 1

    return (a or b) << twos

#define EVEN(A) (!(A & 1))
#define MAX(A, B) (A > B ? A : B)
#define MIN(A, B) (A > B ? B : A)

int gcd(unsigned int m, unsigned int n)
{
    if ((m == 0) || (n == 0))
        return MAX(m, n);
    if (EVEN(m) && EVEN(n))
        return (gcd((m >> 1), (n >> 1)) << 1);
    if (EVEN(m) || EVEN(n)) { //we've just tested for &&, this is now effectively an XOR
        unsigned int odd, even;
        EVEN(m) ? (even = m, odd = n) : (even = n, odd = m);
        return gcd(odd, (even >> 1));
    }
    return gcd(MAX(m, n) - MIN(m, n), MIN(m, n));
}

I managed to get this one spectacularly wrong initially, by underestimating the difference between preprocessor macros and functions: I’d initially left out the brackets around the expression of the MAX and MIN macros, and obviously the operators precedence was playing a nasty trick on me in the gcd(MAX(m,n) – MIN(m,n), MIN(m,n)). I’d like to think it’s a lesson I won’t forget…

int div(unsigned int n, unsigned int d)
{
    unsigned int q = 0, t = d, r = n;
    while (t <= n)
        t <<= 1;
    while ((t >>= 1) >= d) {
        if (t <= r) {
            q = 1 + (q << 1);
            r -= t;
        }
        else
            q <<= 1;
    }
    printf("quotient %d, remainder %d\n", q, r);
    return 0;
}

Anyway, multiplication:

#define EVEN(A) (!(A & 1))

int mult(unsigned int a, unsigned int b)
{
    int prod = 0;
    do {
        if EVEN(a)
            prod += b;
        a >>= 1;
        b <<= 1;
    } while (a >= 1);
    printf("Le produit est: %d\n", prod);
    return prod;
}

import Data.Bits

left, right :: Bits a => a -> a
left = flip shiftL 1
right = flip shiftR 1

binmult :: (Bits a, Integral a) => a -> a -> a
binmult 1 b = b
binmult a b = binmult (right a) (left b) + if odd a then b else 0

bindiv :: (Bits a, Ord a) => a -> a -> (a, a)
bindiv n d = f (right $ until (> n) left d) 0 n where
    f t q r | t < d     = (q, r)
            | t <= r    = f (right t) (left q + 1) (r - t)
            | otherwise = f (right t) (left q)     r

bingcd :: (Bits a, Integral a) => a -> a -> a
bingcd a 0 = a
bingcd 0 b = b
bingcd a b | even a && even b = 2 * bingcd (right a) (right b)
           | even a           = bingcd (right a) b
           | even b           = bingcd a (right b)
           | a > b            = bingcd (a - b) b
           | otherwise        = bingcd a (b - a)