🚀 go-pugleaf

In article <3ho7a6$lhv@hermes.synopsys.com>,
Joe Buck <jbuck@synopsys.com> wrote:
>cbloom@mail.utexas.edu (Charles Bloom) writes:
>multiprecision integer arithmetic ("bignums", to use the Lisp term)
>inherently inefficient.  Among these features is the notion that when you
>multiply two 32-bit integers together you get a 32-bit result (long*long
>is long).  In reality, multiplying two N-bit integers together gives a
>2N-bit result, and this fact is often reflected at the assembly language
>level.  Furthermore, in assembly language you have carry bits and
>add-with-carry instructions, which you can't get to from higher level
>languages.

Though I don't disagree with most of this, it has to be added, that
the penalty for using carry bits must be paid in the processor design.
The veteran of RISC processors, MIPS R2/3000, doesn't have these bits
at all, because they interfere with a pipelined processor design. Other
processors are heavily complicated by implementing a carry bit.
And, I doubt that accessing the carry bit makes the computation faster
in modern processors. Though the instructions to do the carry computations
seem to be more complicated, they are probably more efficient than
branching on carry.

Of course, if there are carry bits, which can be used to make processing
more efficient, it is perfectly legitimate to use them.
-- 
Dipl.-Math. Wilhelm Bernhard Kloke
Institut fuer Arbeitsphysiologie an der Universitaet Dortmund
Ardeystrasse 67, D-44139 Dortmund, Tel. 0231-1084-257