1. Module (chicken flonum)
    1. Arithmetic floating-point operations
  2. Flonum limits

Module (chicken flonum)

Because CHICKEN supports a full numeric tower, operations can sometimes incur a subtantial overhead to simply detect the type of numbers you're passing in. When you know you're definitely dealing only with flonums, you can choose to use flonum-specific operations to avoid this overhead.

This is purely a performance hack. You might want to consider adding type annotations instead, this often gives the same performance boost without having to rewrite all numeric operators in your code.

Arithmetic floating-point operations

[procedure] (fp+ X Y)
[procedure] (fp- X Y)
[procedure] (fp* X Y)
[procedure] (fp/ X Y)
[procedure] (fpgcd X Y)
[procedure] (fpneg X)
[procedure] (fpmin X Y)
[procedure] (fpmax X Y)
[procedure] (fp= X Y)
[procedure] (fp> X Y)
[procedure] (fp< X Y)
[procedure] (fp>= X Y)
[procedure] (fp<= X Y)
[procedure] (fpfloor X)
[procedure] (fpceiling X)
[procedure] (fptruncate X)
[procedure] (fpround X)
[procedure] (fpsin X)
[procedure] (fpcos X)
[procedure] (fptan X)
[procedure] (fpasin X)
[procedure] (fpacos X)
[procedure] (fpatan X)
[procedure] (fpatan2 X Y)
[procedure] (fplog X)
[procedure] (fpexp X)
[procedure] (fpexpt X Y)
[procedure] (fpsqrt X)
[procedure] (fpabs X)
[procedure] (fpinteger? X)

Arithmetic floating-point operations.

In safe mode, these procedures throw a type error when given non-float arguments. In unsafe mode, these procedures do not check their arguments. A non-flonum argument in unsafe mode can crash the application.

Note: fpround uses the rounding mode that your C library implements, which is usually different from R5RS.

Flonum limits

[constant] maximum-flonum
[constant] minimum-flonum
[constant] flonum-radix
[constant] flonum-epsilon
[constant] flonum-precision
[constant] flonum-decimal-precision
[constant] flonum-maximum-exponent
[constant] flonum-minimum-exponent
[constant] flonum-maximum-decimal-exponent
[constant] flonum-minimum-decimal-exponent

Platform-specific flonum limits.

[procedure] (flonum-print-precision [PRECISION])

Gets and sets the number of significant digits printed for a floating-point number. PRECISION must be a positive fixnum. Returns the setting that was previously in effect.

The default print precision is 15 on nearly all systems, and 7 on the rare system on which the double type is only single-precision.

Note: To ensure read/write invariance for all floating-point numbers, you must increase print precision from 15 to 17 (or from 7 to 9). For example:

> (define a (expt 2 -53))
> (define b (+ a (* 2 (expt 10 -32))))
> (eqv? a b)
> (flonum-print-precision 15)
> (cons a b)
(1.11022302462516e-16 .
 1.11022302462516e-16)            ;; same printed representation
> (flonum-print-precision 17)
> (cons a b)
(1.1102230246251565e-16 .
 1.1102230246251568e-16)          ;; differs in last place

On the downside, this will result in unnecessarily precise representations of many numbers:

> (flonum-print-precision 17)
> 0.1

The maximum number of decimal digits required to uniquely represent all floating-point numbers of a certain precision is given by the formula ceil(1+N*log10(2)), where N is the number of bits of precision; for double-precision, N=53.

Previous: Module (chicken fixnum)

Next: Module (chicken foreign)