FP64 (Double Precision) | Floating Point Format Guide

Bit Layout

An FP64 number uses 64 bits divided into three fields:

The sign bit determines positive (0) or negative (1). The exponent is stored with a bias of 1023. The mantissa stores 52 bits of fractional precision, with an implicit leading 1 for normal numbers.

Overview

FP64, also known as double precision or simply double, is the highest-precision standard IEEE 754 format in common use. It is the default numeric type in many languages including Python, JavaScript, R, and MATLAB.

With 11 exponent bits, FP64 spans an enormous range, roughly 600 orders of magnitude (from about 10^-308 to 10³⁰⁸). The 52 mantissa bits provide approximately 15.9 decimal digits of precision, making it suitable for scientific computing, financial calculations, and any application requiring high accuracy.

In JavaScript, all numbers are FP64 by default (the Number type). In C/C++, it's the double type. In Python, float is actually FP64 (double precision), and numpy.float64 explicitly represents it.

Why "double"? The name "double precision" comes from the fact that FP64 uses twice as many bits as FP32 (single precision). This naming convention dates back to the early days of computing when single precision was the default.

Encoding Rules

Normal Numbers

value = (-1)^sign × 2^{(exponent - 1023)} × (1 + mantissa / 2⁵²)

The implicit leading 1 gives an effective 53-bit mantissa. The exponent bias of 1023 means a stored value of 1023 represents an actual exponent of 0. The bias is calculated as 2^(e-1) - 1, where e is the number of exponent bits (11).

Subnormal Numbers

value = (-1)^sign × 2^-1022 × (0 + mantissa / 2⁵²)

When the stored exponent is 0, the number is subnormal. The implicit leading bit becomes 0 instead of 1, and the exponent is fixed at -1022.

Special Values

Zero: Exponent = 0, Mantissa = 0. Both +0 and -0 exist.
Infinity: Exponent = 2047 (all ones), Mantissa = 0.
NaN: Exponent = 2047, Mantissa ≠ 0.

Interactive Value Visualizer

Click any bit to flip it, drag the slider, or enter a decimal or hex value. The graphs show how values are distributed across the encoding space.

Decimal:

Hex:

Note: Due to browser limitations with 64-bit integers, some extreme FP64 values may show slight rounding in the visualizer. The encoding logic is mathematically correct.

Dynamic Range & Precision

Special Values & Bit Patterns

Key values and their exact binary representations:

Format Comparison

See how FP64 compares to other floating-point formats:

Where FP64 Is Used

NVIDIA FP64 Tensor Cores: The Ampere architecture introduced FP64 Tensor Cores via DMMA instructions, delivering 2.5× FP64 throughput over V100. Hopper H100 provides 60 TFLOPS of FP64 Tensor Core performance.
Scientific computing: FP64 is required for numerical methods where error accumulation across many operations would corrupt FP32 results - climate models, orbital mechanics, finite-element analysis, and computational fluid dynamics.
Language defaults: Python float, JavaScript Number, R, and MATLAB all use FP64 as their default numeric type. The ONNX specification defines it as DOUBLE = 11.
Compiler infrastructure: MLIR defaults float attributes to f64 unless explicitly annotated. The NVVM dialect maps f64 to m8n8k4 Tensor Core MMA shapes on Ampere+.
High-precision accumulation: cuBLAS supports FP64-accuracy GEMM via fixed-point emulation (Ozaki scheme) using BF16 mantissa encoding, enabling FP64-quality results on hardware optimized for lower precisions.