Next: Floating Point Efficiency, Previous: Fixnums, Up: Numbers [Contents][Index]

Python is unique in its efficient implementation of arithmetic on full-word integers through non-descriptor representations and open coding. Arithmetic on any subtype of these types:

(signed-byte 32) (unsigned-byte 32)

is reasonably efficient, although subtypes of `fixnum`

remain
somewhat more efficient.

If a word integer must be represented as a descriptor, then the
`bignum`

representation is used, with its associated consing
overhead. The support for word integers in no way changes the
language semantics, it just makes arithmetic on small bignums vastly
more efficient. It is fine to do arithmetic operations with mixed
`fixnum`

and word integer operands; just declare the most
specific integer type you can, and let the compiler decide what
representation to use.

In fact, to most users, the greatest advantage of word integer arithmetic is that it effectively provides a few guard bits on the fixnum representation. If there are missing assertions on intermediate values in a fixnum expression, the intermediate results can usually be proved to fit in a word. After the whole expression is evaluated, there will often be a fixnum assertion on the final result, allowing creation of a fixnum result without even checking for overflow.

The remarks in section fixnums about fixnum result type also
apply to word integers; you must be careful to give the compiler
enough information to prove that the result is still a word integer.
This time, though, when we blow out of word integers we land in into
generic bignum arithmetic, which is much worse than sleazing from
`fixnum`

s to word integers. Note that mixing
`(unsigned-byte 32)`

arguments with arguments of any signed
type (such as `fixnum`

) is a no-no, since the result might not be
unsigned.

Next: Floating Point Efficiency, Previous: Fixnums, Up: Numbers [Contents][Index]