quad-fp: quadruple-precision floating point🔗ℹ

1 Accuracy🔗ℹ

The arithmetic operators are compiled as GCC __float128 operations; the elementary and special functions delegate to libquadmath. The exception is qfexp2, which uses powq(2,x) for compatibility with libquadmath versions that do not export exp2q. Accuracy therefore varies across GCC versions. The package’s property tests compare the core operations and functions for which there is a corresponding math/bigfloat operation at 113-bit precision. Their regression bounds are:

• qf+, qf-, qf*, qf/, and qfabs must match math/bigfloat bit for bit for the generated finite inputs.

• qfsqrt and qffma use the relative-error bound 2^{-110} (roughly 4–8 ulps, depending on the significand). They are bit-exact on recent libquadmath builds, while older implementations may be only faithfully rounded or may double-round.

• The tested transcendental functions, including qflgamma, are held to relative error 2^{-106} (roughly 64–128 ulps). qftgamma varies much more across libquadmath versions and uses 2^{-90} (roughly 4–8 million ulps), which still requires about 27 correct decimal digits.

These are conservative regression-test bounds, not universal accuracy guarantees from libquadmath. Functions without a math/bigfloat counterpart, including the Bessel functions, are not covered by those property comparisons. When a reference result is zero, the suite treats the same numeric bound as an absolute rather than relative error limit. Do not rely on bit-for-bit reproducibility of transcendental results across libquadmath versions, especially for qftgamma.

2 Performance🔗ℹ

Every operation crosses the Racket/C boundary and allocates a result. That fixed cost is most visible for arithmetic and much less important for expensive transcendental functions. Exact timings depend on the Racket implementation, compiler, CPU, and libquadmath version, so measure on the deployment system:

The benchmark reports nanoseconds per call, the Racket version, machine type, and iteration count. It measures the untyped quad-fp/quadf layer. The default quad-fp adds Typed Racket contracts at the boundary.

The untyped module uses ffi/unsafe, bypasses the public typed contracts, and exposes low-level representation accessors. Treat it as an optimization interface: use it only after profiling, pass values produced by this package, and do not depend on its extra exports remaining stable.

3 Datatype🔗ℹ

The public entry point preserves its type information when used from Typed Racket:

#lang typed/racket/base

(require quad-fp)

(: square (Quad-Flonum -> Quad-Flonum))

(define (square x) (qf* x x))

(quad-flonum->string (square (string->quad-flonum "1.25")))

This usage is compiled and exercised by the package’s typed-client test.

4 Conversion🔗ℹ

Apart from surrounding C-locale whitespace, string->quad-flonum requires the entire input to be consumed as a valid number; malformed strings and strings with trailing nonnumeric text raise exn:fail:contract instead of silently producing the value of a numeric prefix. A syntactically valid value outside binary128’s range is not a parse error: overflow produces signed infinity and underflow produces signed zero.

quad-flonum->string accepts precisions from 1 through 12000 and sizes its output dynamically, so it returns the complete representation even when it is longer than a small fixed buffer. The maximum exceeds the roughly 11,600 significant digits needed by the longest exact finite binary128 expansion. The default of 36 is quad-decimal-dig, the number of digits sufficient to round-trip any finite binary128 value exactly. Textual NaN formatting does not preserve payload or signalling state.

5 IEEE 754 behavior and errors🔗ℹ

Arithmetic and mathematical domain errors follow GCC/libquadmath floating-point semantics instead of raising Racket exceptions. For example, division by zero produces signed infinity, invalid operations produce NaN, and overflow or underflow produces infinity, subnormal values, or signed zero as appropriate. The binding does not expose C errno or floating-point exception flags.

NaN is unordered: every comparison involving NaN, including qf=, returns #f. Positive and negative zero compare equal, while qfsignbit? distinguishes them. qfmin and qfmax follow fminq/fmaxq: if exactly one operand is NaN they return the numeric operand. When both operands are zeros with different signs, the returned zero’s sign follows the libquadmath implementation; use qfcopysign when the sign is semantically important.

6 Arithmetic🔗ℹ

7 Elementary functions🔗ℹ

8 Rounding🔗ℹ

9 Special functions🔗ℹ

Concurrency note: libquadmath’s lgammaq, which implements qflgamma, writes the process-global C variable signgam. That makes qflgamma unsafe to run concurrently with another qflgamma call or with native code outside the package that calls lgammaq or accesses signgam. Serialize all such access at the application level.

10 Other binary functions🔗ℹ

11 Comparison🔗ℹ

12 Classification🔗ℹ

13 Constants🔗ℹ