Fixnums­Cowan

Fixnums are an implementation-defined subset of the exact integers. Every implementation must define its fixnum range as a closed interval [-2^w-1, 2^w-1-1], such that w is an integer w greater than or equal to 24. Every mathematical integer within an implementation's fixnum range must correspond to an exact integer that is representable within the implementation. A fixnum is an exact integer whose value lies within this fixnum range.

Fixnum operations perform integer arithmetic on their fixnum arguments. If any argument is not a fixnum, or if the mathematical result is not representable as a fixnum, it is an error. In particular, this means that fixnum operations may return a mathematically incorrect fixnum in these situations without raising an error.

This section uses fx, fx₁, fx₂, etc., as parameter names for fixnum arguments.

Returns #t if obj is an exact integer within the fixnum range, #f otherwise.

These procedures return w, −2^w−1 and 2^w−1 − 1: the width, minimum and the maximum value of the fixnum range, respectively.

These procedures return #t if their arguments are (respectively): equal, monotonically increasing, monotonically decreasing, monotonically nondecreasing, or monotonically nonincreasing, #f otherwise.

These numerical predicates test a fixnum for a particular property, returning #t or #f. The five properties tested by these procedures are: whether the number object is zero, greater than zero, less than zero, odd, or even.

These procedures return the maximum or minimum of their arguments.

These procedures return the sum or product of their arguments.

With two arguments, this procedure returns the difference fx₁−fx₂.

With one argument, this procedure returns the additive inverse of its argument.

It is an error if fx₂ is zero. These procedures implement integer division and return the results of the corresponding operations specified in DivisionRiastradh.

Returns the two fixnum results of the following computation:

(let* ((s (+ fx₁ fx₂ fx₃))
       (s0 (mod0 s (expt 2 (fixnum-width))))
       (s1 (div0 s (expt 2 (fixnum-width)))))
  (values s0 s1))

Returns the two fixnum results of the following computation:

(let* ((d (- fx₁ fx₂ fx₃))
       (d0 (mod0 d (expt 2 (fixnum-width))))
       (d1 (div0 d (expt 2 (fixnum-width)))))
  (values d0 d1))

Returns the two fixnum results of the following computation:

(let* ((s (+ (* fx₁ fx₂) fx₃))
       (s0 (mod0 s (expt 2 (fixnum-width))))
       (s1 (div0 s (expt 2 (fixnum-width)))))
=  (values s0 s1))

Returns the unique fixnum that is congruent mod 2^w to the one's-complement of fx.

These procedures return the fixnum that is the bit-wise “and”, “inclusive or”, or “exclusive or” of the two's complement representations of their arguments. If they are passed only one argument, they return that argument. If they are passed no arguments, they return the fixnum (either −1 or 0) that acts as identity for the operation.

Returns the fixnum that is the bit-wise “if” of the two's complement representations of its arguments, i.e. for each bit, if it is 1 in fx₁, the corresponding bit in fx₂ becomes the value of the corresponding bit in the result, and if it is 0, the corresponding bit in fx₃ becomes the corresponding bit in the value of the result. This is the fixnum result of the following computation:

(fxior (fxand fx₁ fx₂)
       (fxand (fxnot fx₁) fx₃))

If fx is non-negative, this procedure returns the number of 1 bits in the two's complement representation of fx. Otherwise it returns the result of the following computation:

(fxnot (fxbit-count (fxnot ei)))

Returns the number of bits needed to represent fx if it is positive, and the number of bits needed to represent (fxnot fx) if it is negative, which is the fixnum result of the following computation:

(do ((result 0 (+ result 1))
     (bits (if (fxnegative? fx)
               (fxnot fx)
               fx)
           (fxarithmetic-shift-right bits 1)))
    ((fxzero? bits)
     result))

Returns the index of the least significant 1 bit in the two's complement representation of fx. If fx is 0, then −1 is returned.

(fxfirst-bit-set 0)        ‌⇒  -1
(fxfirst-bit-set 1)        ‌⇒  0
(fxfirst-bit-set -4)       ‌⇒  2

It is an error if fx₂ is negative, or is greater than or equal to (fixnum-width). The fxbit-set? procedure returns #t if the fx₂th bit is 1 in the two's complement representation of fx₁, and #f otherwise. This is the fixnum result of the following computation:

(not
  (fxzero?

    (fxand fx₁
           (fxarithmetic-shift-left 1 fx₂))))

It is an error if fx₂ is negative, or is greater than or equal to (fixnum-width). It is also an error if Fx₃ is neither 0 nor 1. The fxcopy-bit procedure returns the result of replacing the fx₂th bit of fx₁ by fx₃, which is the result of the following computation:

(let* ((mask (fxarithmetic-shift-left 1 fx₂)))
  (fxif mask
        (fxarithmetic-shift-left fx₃ fx₂)
        fx₁))

It is an error if either of Fx₂ and fx₃ is negative, or if either is greater than or equal to (fixnum-width). It is also an error if fx₂ is greater than fx₃. The fxbit-field procedure returns the number represented by the bits at the positions from fx₂ (inclusive) to fx₃ (exclusive), which is the fixnum result of the following computation:

(let* ((mask (fxnot
              (fxarithmetic-shift-left -1 fx₃))))
  (fxarithmetic-shift-right (fxand fx₁ mask)
                            fx₂))

It is an error if either fx₂ or fx₃ or if either is greater than (fixnum-width). It is also an error if fx₂ is greater than fx₃. The fxcopy-bit-field procedure returns the result of replacing in fx₁ the bits at positions from fx₂ (inclusive) to fx₃ (exclusive) by the corresponding bits in fx₄, which is the fixnum result of the following computation:

(let* ((to    fx₁)
       (start fx₂)
       (end   fx₃)
       (from  fx₄)
       (mask1 (fxarithmetic-shift-left -1 start))
       (mask2 (fxnot
               (fxarithmetic-shift-left -1 end)))
       (mask (fxand mask1 mask2)))
  (fxif mask
        (fxarithmetic-shift-left from start)
        to))

It is an error if the absolute value of fx₂ is greater than or equal to (fixnum-width). If

(floor (* fx₁ (expt 2 fx₂)))

is a fixnum, then that fixnum is returned; otherwise it is an error.

It is an error if fx₂ is negative, or is greater than or equal to (fixnum-width). The fxarithmetic-shift-left procedure behaves the same as fxarithmetic-shift, and (fxarithmetic-shift-right fx₁ fx₂) behaves the same as (fxarithmetic-shift fx₁ (fx- fx₂)).

It is an error if any of Fx₂, fx₃, and fx₄ are negative, or are greater than or equal to (fixnum-width). It is also an error if Fx₂ is greater than fx₃, or if Fx₄ is greater than or equal to the difference between fx₃ and fx₂. The fxrotate-bit-field procedure returns the result of cyclically permuting in fx₁ the bits at positions from fx₂ (inclusive) to fx₃ (exclusive) by fx₄ bits towards the more significant bits, which is the result of the following computation:

(let* ((n     fx₁)
       (start fx₂)
       (end   fx₃)
       (count fx₄)
       (width (fx- end start)))
  (if (fxpositive? width)
      (let* ((count (fxmod count width))
             (field0
               (fxbit-field n start end))
             (field1
               (fxarithmetic-shift-left
                 field0 count))
             (field2
               (fxarithmetic-shift-right
                 field0 (fx- width count)))
             (field (fxior field1 field2)))
        (fxcopy-bit-field n start end field))
      n))

It is an error if either of Fx₂ and fx₃ is negative, or if either is greater than (fixnum-width). It is also an error if fx₂ is greater than fx₃. The fxreverse-bit-field procedure returns the fixnum obtained from fx₁ by reversing the order of the bits at positions from fx₂ (inclusive) to fx₃ (exclusive).

(fxreverse-bit-field #b1010010 1 4)    
‌‌⇒  88 ; #b1011000