The following rules apply to floating point computations.
When rationals and floats are combined by a numerical function,
the rational is first converted to a float of the same format.
For functions such as
+ that take more than two arguments,
it is permitted that part of the operation be carried out exactly using
rationals and the rest be done using floating-point arithmetic.
When rationals and floats are compared by a numerical function,
rational is effectively called to convert the float
to a rational and then an exact
comparison is performed. In the case of complex numbers,
the real and imaginary parts are effectively handled individually.
;;;; Combining rationals with floats. ;;; This example assumes an implementation in which ;;; (float-radix 0.5) is 2 (as in IEEE) or 16 (as in IBM/360), ;;; or else some other implementation in which 1/2 has an exact ;;; representation in floating point. (+ 1/2 0.5) → 1.0 (- 1/2 0.5d0) → 0.0d0 (+ 0.5 -0.5 1/2) → 0.5 ;;;; Comparing rationals with floats. ;;; This example assumes an implementation in which the default float ;;; format is IEEE single-float, IEEE double-float, or some other format ;;; in which 5/7 is rounded upwards by FLOAT. (< 5/7 (float 5/7)) → true (< 5/7 (rational (float 5/7))) → true (< (float 5/7) (float 5/7)) → false
Computations with floats are only approximate, although they are described as if the results were mathematically accurate. Two mathematically identical expressions may be computationally different because of errors inherent in the floating-point approximation process. The precision of a float is not necessarily correlated with the accuracy of that number. For instance, 3.142857142857142857 is a more precise approximation to π than 3.14159, but the latter is more accurate. The precision refers to the number of bits retained in the representation. When an operation combines a short float with a long float, the result will be a long float. Common Lisp functions assume that the accuracy of arguments to them does not exceed their precision. Therefore when two small floats are combined, the result is a small float. Common Lisp functions never convert automatically from a larger size to a smaller one.
An error of type
floating-point-underflow should be signaled if a
floating-point computation causes exponent overflow or underflow, respectively.
The result of a numerical function is a float of the largest format among all the floating-point arguments to the function.