DoubleFloats Benchmark Report

Generated by docs/reports/benchmarks.jl on Julia 1.12.6.

This report covers a representative sample of operations; it does not cover all available functions. Timings are best-of-trials amortized averages on the machine that ran the script — treat them as indicative magnitudes, not precise measurements.

Double64 carries ~32 significant decimal digits (106-bit significand); BigFloat timings use the default 256-bit precision. The D64/F64 column shows the cost of the extra precision relative to Float64; Big/D64 shows the advantage of Double64 over BigFloat.

Scalar Arithmetic

operation	Double64	Float64	D64/F64	BigFloat	Big/D64
`+`	2 ns	0 ns	6.6x	35 ns	14.3x
`*`	2 ns	0 ns	5.1x	52 ns	27.6x
`/`	2 ns	1 ns	3.5x	88 ns	37.4x
`sqrt`	1 ns	1 ns	1.0x	149 ns	128.1x
`abs`	0 ns	0 ns	1.2x	18 ns	43.1x
`fma`	5 ns	0 ns	11.9x	76 ns	16.7x

Elementary Functions

function	Double64	Float64	D64/F64	BigFloat	Big/D64
`exp`	181 ns	2 ns	106.0x	1.71 µs	9.5x
`log`	236 ns	3 ns	71.7x	3.34 µs	14.2x
`sin`	160 ns	2 ns	71.2x	1.85 µs	11.5x
`cos`	147 ns	2 ns	60.7x	1.42 µs	9.6x
`tan`	614 ns	4 ns	157.8x	2.34 µs	3.8x
`atan`	511 ns	3 ns	161.3x	8.64 µs	16.9x
`sinh`	384 ns	2 ns	156.3x	2.11 µs	5.5x
`tanh`	763 ns	3 ns	231.1x	2.17 µs	2.8x
`asinh`	260 ns	5 ns	48.0x	3.96 µs	15.2x
`x^y`	456 ns	16 ns	28.4x	5.63 µs	12.3x

Linear Algebra (n = 32)

Float64 timings use LAPACK/BLAS; Double64 uses pure-Julia generic algorithms (GenericLinearAlgebra / GenericSchur), so these ratios combine the precision cost with the loss of BLAS blocking and SIMD.

operation	Double64	Float64	D64/F64
`A * B (n=32)`	167.87 µs	1.60 µs	104.9x
`lu(A)`	58.63 µs	4.23 µs	13.9x
`qr(A)`	168.20 µs	23.30 µs	7.2x
`A \ b`	69.13 µs	4.90 µs	14.1x
`eigen(S) symmetric`	913.13 µs	49.20 µs	18.6x
`eigen(A) general`	5.01 ms	118.70 µs	42.2x
`svd(A)`	511.50 µs	24.50 µs	20.9x

Matrix Functions (n = 32 unless noted)

operation	Double64	Float64	D64/F64
`exp(A) (n=32)`	2.79 ms	34.97 µs	79.8x
`sqrt(P) spd`	1.05 ms	52.17 µs	20.2x
`log(P) spd`	990.33 µs	52.27 µs	18.9x
`sylvester(A, B, S)`	38.26 ms	245.10 µs	156.1x

Notes

Entries below ~10 ns are at the resolution of the timing loop; treat them (and their ratios) as "too fast to matter" rather than exact.
Scalar Double64 arithmetic is typically 3–20x Float64 and several times faster than BigFloat, with no heap allocation per operation.
Double64 values are immutable bitstypes; vectors of them are stored inline, which is where much of the advantage over BigFloat comes from.
Matrix-function timings include the full dense algorithm (scaling-and-squaring for exp, Schur-based methods for sqrt/log).