Multiplying/Adding 2 numbers without '*'/'+'

/**********************************************************************/
/* By Jos A. Horsmeier 
/* © 1998 Jos A. Horsmeier 
/**********************************************************************/

#include <stdio.h>

/* add two numbers without using the '+' operator */
unsigned int add(unsigned int a, unsigned int b)
{
  unsigned int c= 0;
  unsigned int r= 0;
  unsigned int t= ~0;
  for (t= ~0; t; t>>= 1)
  {
    r<<= 1;
    r|= (a^b^c)&1;
    c= ((a|b)&c|a&b)&1;
    a>>= 1;
    b>>= 1;
  }
  for (t= ~0, c= ~t; t; t>>= 1)
  {
    c<<= 1;
    c|= r&1;
    r>>= 1;
  }
  return c;
}

/* multiply two numbers without using the '*' operator */
unsigned int mul(unsigned int a, unsigned int b)
{
  unsigned int r;
  for (r= 0; a; b <<= 1, a >>= 1)
    if (a&1)
      r = add(r, b);
  return r;
}

useful ?

looks like the same i invented on my own once.

useful? indeed. for learning how that thing works, and for implementing it in hw.. at least an adder will possibly be my next step in school, horray!

we had all kinds of adders last term in hardware

here's my take on the Sum function:

private int Sum(int a, int b) {
	int x = a ^ b;
	while ((a & b) != 0) {
		b = (a & b) << 1;
		a = x;
		x = a ^ b;
	}
	return x;
}

private uint Product(uint a, uint b) {
	uint p = 0;
	while (b != 0) {
		if ((b & 1) == 1) p = Sum(p, a);
		a <<= 1;
		b >>= 1;
	}
	return p;
}

smaller huh? :P

Okay, this doesn't sound really friendly, but it was the first thing that came in my mind:

WHO ** CARES?

(Also notice that this reply is carefully crafted: it doesn't contain the letter x. Okay, that is a paradox. Oh crap, another one. Well, it doesn't contain a q either.)

Well, I can imagine that not using the multiply operator does indeed make sense on some CPU's. I've got an old 8086 assembly book which states that using the above method for multiplication using a (normal) add command was faster than using the mul operation. Recent PC CPU's do not have this behaviour any more, a Pentium type CPU needs some 5 or 6 cycles for a mul (where the 8086 used around 100). But this rule could still apply for some embedded CPU's.

Really? The Product function multiplies exactly like one does when multiplying on paper, only now in binary. How can a hardware mul be slower than that? Okay, this code has probably a better best-case execution time while the hardware mul has probably a best-case = worst-case time, but even then... the sum function is still useless, I guess, even 20 years ago.