DoubleFloats Benchmark Report

Generated by docs/reports/benchmarks.jl on Julia 1.13.0-DEV.1123.

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

Double64 carries ~32 significant decimal digits. Float64 is the native baseline; BigFloat timings use the default 256-bit precision.

Scalar Arithmetic

operation	Double64	Float64	D64/F64	BigFloat	Big/D64
`+`	2 ns	0 ns	6.8x	35 ns	14.3x
`*`	2 ns	0 ns	5.4x	50 ns	26.1x
`/`	2 ns	1 ns	3.4x	90 ns	39.4x
`sqrt`	1 ns	1 ns	1.0x	154 ns	131.4x
`abs`	0 ns	0 ns	1.0x	16 ns	44.6x
`fma`	4 ns	0 ns	11.3x	75 ns	18.3x

Elementary Functions

function	Double64	Float64	D64/F64	BigFloat	Big/D64
`exp`	58 ns	2 ns	33.0x	1.75 µs	29.9x
`log`	101 ns	2 ns	40.8x	3.27 µs	32.4x
`sin`	76 ns	2 ns	35.7x	2.00 µs	26.5x
`cos`	76 ns	2 ns	34.9x	1.67 µs	22.0x
`tan`	154 ns	4 ns	40.5x	2.44 µs	15.9x
`atan`	163 ns	3 ns	51.7x	9.99 µs	61.5x
`sinh`	90 ns	3 ns	33.6x	2.11 µs	23.3x
`tanh`	115 ns	3 ns	35.1x	2.30 µs	20.1x
`asinh`	148 ns	5 ns	27.8x	4.40 µs	29.7x
`x^y`	189 ns	19 ns	9.9x	6.46 µs	34.1x

Linear Algebra

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. Matrix multiplication is measured at several square sizes; the remaining operations use n = 32.

operation	Double64	Float64	D64/F64
`A * B (n=4)`	800 ns	67 ns	12.0x
`A * B (n=8)`	6.00 µs	200 ns	30.0x
`A * B (n=16)`	5.60 µs	467 ns	12.0x
`A * B (n=32)`	29.77 µs	3.13 µs	9.5x
`A * B (n=64)`	171.30 µs	21.63 µs	7.9x
`lu(A)`	134.33 µs	4.47 µs	30.1x
`qr(A)`	227.80 µs	36.00 µs	6.3x
`A \ b`	82.03 µs	4.73 µs	17.3x
`eigen(S) symmetric`	1.22 ms	48.73 µs	24.9x
`eigen(A) general`	5.36 ms	120.90 µs	44.3x
`svd(A)`	644.67 µs	39.60 µs	16.3x

Matrix Functions (n = 32 unless noted)

operation	Double64	Float64	D64/F64
`exp(A) (n=32)`	757.63 µs	32.77 µs	23.1x
`sqrt(P) spd`	1.40 ms	56.00 µs	24.9x
`log(P) spd`	1.52 ms	52.03 µs	29.3x
`sylvester(A, B, S)`	38.31 ms	262.70 µs	145.8x

Double32

Double32 carries ~14 significant decimal digits. Float32 is the native baseline; BigFloat timings use the default 256-bit precision.

Scalar Arithmetic

operation	Double32	Float32	D32/F32	BigFloat	Big/D32
`+`	2 ns	0 ns	6.5x	35 ns	14.1x
`*`	2 ns	0 ns	4.5x	50 ns	30.0x
`/`	2 ns	0 ns	4.6x	89 ns	44.4x
`sqrt`	1 ns	1 ns	1.0x	149 ns	213.0x
`abs`	0 ns	0 ns	1.2x	17 ns	41.1x
`fma`	3 ns	0 ns	9.0x	77 ns	22.7x

Elementary Functions

function	Double32	Float32	D32/F32	BigFloat	Big/D32
`exp`	59 ns	2 ns	28.7x	1.70 µs	28.7x
`log`	100 ns	3 ns	35.2x	3.31 µs	33.2x
`sin`	82 ns	2 ns	40.4x	1.85 µs	22.5x
`cos`	81 ns	2 ns	38.6x	1.37 µs	16.9x
`tan`	157 ns	3 ns	61.7x	2.12 µs	13.5x
`atan`	167 ns	2 ns	68.9x	8.10 µs	48.6x
`sinh`	87 ns	2 ns	52.2x	1.96 µs	22.5x
`tanh`	109 ns	2 ns	45.4x	2.07 µs	19.1x
`asinh`	155 ns	5 ns	29.6x	3.72 µs	23.9x
`x^y`	198 ns	9 ns	22.8x	5.40 µs	27.2x

Linear Algebra

Float32 timings use LAPACK/BLAS; Double32 uses pure-Julia generic algorithms (GenericLinearAlgebra / GenericSchur), so these ratios combine the precision cost with the loss of BLAS blocking and SIMD. Matrix multiplication is measured at several square sizes; the remaining operations use n = 32.

operation	Double32	Float32	D32/F32
`A * B (n=4)`	333 ns	67 ns	5.0x
`A * B (n=8)`	2.13 µs	133 ns	16.0x
`A * B (n=16)`	15.03 µs	300 ns	50.1x
`A * B (n=32)`	109.67 µs	1.10 µs	99.7x
`A * B (n=64)`	851.37 µs	6.83 µs	124.6x
`lu(A)`	47.10 µs	2.83 µs	16.6x
`qr(A)`	137.23 µs	15.57 µs	8.8x
`A \ b`	43.27 µs	3.20 µs	13.5x
`eigen(S) symmetric`	675.30 µs	129.73 µs	5.2x
`eigen(A) general`	3.03 ms	96.37 µs	31.4x
`svd(A)`	385.13 µs	20.40 µs	18.9x

Matrix Functions (n = 32 unless noted)

operation	Double32	Float32	D32/F32
`exp(A) (n=32)`	11.70 ms	25.40 µs	460.7x
`sqrt(P) spd`	728.77 µs	48.37 µs	15.1x
`log(P) spd`	747.97 µs	44.67 µs	16.7x
`sylvester(A, B, S)`	unavailable	unavailable	—

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.
Double64 and Double32 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).
The Double32 Sylvester row is unavailable: its generic Schur path currently fails for Complex{Double32}, so reporting a timing would be misleading.