2.10.1 Numeric types

ECL supports all of the Common Lisp numeric tower, which is shown in Table 2.5. The details, however, depend both on the platform on which ECL runs and on the configuration which was chosen when building ECL.

In general, the size of a fixnum is determined by the word size of a machine, which ranges from 32 to 64 bits. Integers larger than this are implemented using the GNU Multiprecision library. Rationals are implemented using two integers, without caring whether they are fixnum or not. Floating point numbers include at least the two IEEE types of 32 and 64 bits respectively.

In machines where it is supported, it is possible to associate the lisp long-float with the machine type long double whose size ranges from 96 to 128 bits, and which are a bit slower.

In machines where a type <float> _Complex is supported numbers of type (complex float) are implemented with it, otherwise like ratios all complex numbers are pairs of numbers.

2.10.2 Floating point exceptions

ECL supports two ways of dealing with special floating point values, such as Not a Number (NaN), infinity or denormalized floats, which can occur in floating point computations. Either a condition is signaled or the value is silently used as it is. There are multiple options controlling which behaviour is selected: If ECL is built with the --without-ieee-fp configure option, then a condition is signaled for every infinity or NaN encountered. If not, floating point exceptions can be disabled at build time using the --without-fpe configure option. Otherwise, if both --with-ieee-fp and --with-fpe options are on, by default, a condition is signaled for invalid operation, division by zero and floating point overflows. This can be changed at runtime by using ext:trap-fpe. If the ECL_OPT_TRAP_SIGFPE boot option is false (see Table 1.1), no conditions are signaled by default (Note that in this case, if you enable trapping of floating point exceptions with ext:trap-fpe, then you have to install your own signal handler).

Function: ext:trap-fpe condition flag ¶

Control the signaling of the floating point exceptions

Synopsis

condition

a symbol - one of cl:last, cl:t, cl:division-by-zero, cl:floating-point-overflow, cl:floating-point-underflow, cl:floating-point-invalid-operation, cl:floating-point-inexact or an integer.

flag

a generalized boolean

Description

If condition is last, flag is ignored and the currently enabled floating point exceptions are returned in an implementation depended format (currently an integer). Otherwise, flag determines whether the current thread will signal a floating point exception for the conditions passed in condition. condition can be either a symbol denoting a single condition, t for all conditions that are enabled by default or a value obtained from an earlier call to ext:trap-fpe with last.

See also

ECL_WITH_LISP_FPE

2.10.3 Random-States

ECL relies internally on a 32-bit Mersenne-Twister random number generator, using a relatively large buffer to precompute about 5000 pseudo-random bytes. This implies also that random states can be printed readably and also read, using the #$ macro. There is no provision to create random states from user arrays, though. Random state is printed unreadably by default.

The #$ macro can be used to initialize the generator with a random seed (an integer), an array of random bytes (mainly used for reading back printed random-state) and another random-state (syntactic sugar for copying the random-state).

2.10.4 Infinity and Not a Number

The ANSI Common-Lisp standard does not specify the behaviour of numeric functions for infinite or not number valued floating point numbers. If ECL is configured to support these special values (see the --with-ieee-fp configure option) and floating point exceptions are disabled, numeric functions generally return the same value as the corresponding C function. This means, that the output will be a NaN for a NaN input, and the “mathematically correct” value (which may be NaN, e.g. for ∞-∞) for an infinite real input. For complex floats, however, the return value of a numeric function called with a complex number for which the real or imaginary part is infinite, is undefined¹.

For other functions dealing with numbers, we adopt the following behaviour:

Comparison functions

All numeric comparisons with =,<,<=,>,>= involving NaN return false. Comparing two NaNs of the same type with eql returns true.

min/max

NaN values are ignored, i.e. the maximum/minimum is taken only over the number valued parameters.

Rounding functions

All rounding functions signal an arithmetic-error if any of the given parameters are not number valued or infinite.

2.10.5 Branch cuts and signed zero

For multi-valued complex functions like asin, acos, etc. the ANSI Common-Lisp standard specifies in detail the location of the branch cuts and in particular the value of these functions on the branch cuts. ECL diverges from the standard in that the sign of zero distinguishes two sides of a branch cut. For example, the asin function includes a branch cut running from 1 to ∞ on the real axis. The ANSI standard specifies a negative imaginary part for asin on this branch cut consistent with approaching the cut from below. Evaluating (asin z) in ECL, on the other hand, returns a result with positive imaginary part if the imaginary part of z is +0.0 (consistent with approaching the cut from above) and a result with negative imaginary part if the imaginary part of z is -0.0 (consistent with approaching the cut from below)². This applies to sqrt, asin, acos, atan, asinh, acosh and atanh.

2.10.6 Dictionary

Constant: ext:{short,single,double,long}-float-{positive,negative}-infinity ¶

Constant positive/negative infinity for the different floating point types.

Function: ext:nan ¶

Returns a double float NaN value. Coerce to other floating point types to get NaN values e.g. for single floats.

Function: ext:float-infinity-p x ¶

Function: ext:float-nan-p x ¶

Predicates to test if x is infinite or NaN.

2.10.7 C Reference

• Number C types
• Number constructors
• Number accessors
• Number coercion
• ANSI dictionary