quad-fp: quadruple-precision floating point🔗ℹ

1 Accuracy🔗ℹ

Every result comes straight from libquadmath, so the accuracy is libquadmath’s and varies slightly across GCC versions. The package’s property tests, which check each operation against math/bigfloat at 113-bit precision, characterize it as follows:

• qf+, qf-, qf*, and qf/ are correctly rounded on every libquadmath: each result is the exact value rounded to the nearest binary128, matching math/bigfloat bit for bit.

• qfsqrt and qffma are correctly rounded on recent libquadmath, but only faithfully rounded (within one unit in the last place) on older builds. There sqrtq refines a double seed by Newton’s method with no final correcting step, and fmaq may double-round by up to one ulp — while still computing a true, cancellation-safe fused multiply-add.

• The transcendental and special functions are not guaranteed correctly rounded; in practice they are within a few ulps. The gamma functions qftgamma and qflgamma are the least accurate and vary the most from one libquadmath to the next.

A quad result may therefore differ in its last bit or two from one produced by another correctly-rounded library.

2 Performance🔗ℹ

Every operation crosses the Racket/C boundary and allocates its result — a fixed overhead of roughly 40–70 nanoseconds per call on x86-64, independent of the operation. The relative cost therefore depends on how much work the operation itself does. Arithmetic and qfabs are cheap in libquadmath (around 10 ns), so the boundary dominates: expect about 4–6× the cost of the same operation in C. qfsqrt and every transcendental or special function take hundreds to thousands of nanoseconds, leaving the boundary in the noise — within roughly 15%, and under 5% for the dearest ones such as qferf, qfpow, and qftgamma.

The pattern, measured on one x86-64 machine (gcc -O3, approximate ns per call):

Absolute numbers are machine-dependent; the ratios are the portable part.

Those figures are for the untyped layer, quad-fp/quadf. The default quad-fp additionally wraps each export in the Typed Racket require/typed contract — another flat ~45 ns per call, a Quad? check on every argument and result. That roughly doubles the cheap arithmetic operations but is negligible for the expensive ones, and it applies to typed and untyped callers alike. Code that is bottlenecked on quad arithmetic and does not need the static types can (require quad-fp/quadf) to bypass it.

3 Datatype🔗ℹ

4 Conversion🔗ℹ

5 Arithmetic🔗ℹ

6 Elementary functions🔗ℹ

7 Rounding🔗ℹ

8 Special functions🔗ℹ

9 Other binary functions🔗ℹ

10 Comparison🔗ℹ

11 Classification🔗ℹ

12 Constants🔗ℹ