🚀 go-pugleaf

In article <1992Nov20.135747.4642@sun0.urz.uni-heidelberg.de> dentzer@clio.iwr.uni-heidelberg.de (Ralf Dentzer) writes:

   As some sort of compromise between portability and efficiency I would make
   the following proposal for a set of basic functions to deal with multiple
   digit integers. The main restriction for them is the imposition to have a 
   C-function interface, but only thus portability can be guaranteed.

Good; that's the right way to go.

   First there should be a data type "Digit_t" e.g., usually unsigned long
   or what else fits into one register, and a constant BitsPerDigit.
   Then come six functions for calculating with Digits, these provide
   access to carrys, the higher digit of a product and a division
   with two digit dividend:

   Digit_t DigitAdd(Digit_t *sum, Digit_t a, Digit_t b, Digit_t carry);
	   /* *sum=LOW-DIGIT(a+b+carry);
	      return HIGH-DIGIT(a+b+carry); 
	   */
   [...]

   These functions are sufficient to build a multiple digit arithmetic,
   but due to function call overhead they are too slow.
   (More or less, depending on the processor; on a Sparc their
   performance is not that bad.)

You could standardize these as macros, not functions.  The main
user-visible difference would be in not being able to take the
address. Even if you do define these as functions, your compiler
could (and should) inline them.

Also, a slightly better interface might be to turn this into a
conditional construct, conditional on the carry bit:

	CPU_WORD result,a,b;
	...
	ADD_WITH_CARRY(result,a,b) { /* carry==1 */ }
	else { /* carry==0 */ }


					Thomas.