Floating Point: IEEE 754

in reviewThis lesson is complete and being validated before release - details may still change.

IEEE 754 floating point

Loading interactive demo…

The row at the top is the bit pattern: the sign, the exponent field, and the fraction, each cell filled as it is decided and faint until then. The strip beneath reads the fields back as a number. The two lines below are number lines: the whole range the slider covers, banded by how far apart the format's numbers are, and a zoom on the value's own power-of-two band with every number the format can hold there as a tick. Drag either line to move the value.Take the tour, or press and explore. Legend:

The panel beside the stage is the real FloatingPoint class from the published library executing in your browser, with the current line highlighted.

The field or bit being decided, and the value asked for.
The sign bit.
The exponent field.
The fraction bits.
The value stored, and bits settled by rounding.
A rounding error, infinity, or a subnormal.

value is the number asked for, stored what the bits decode to, error their difference, spacing the distance between neighbours at that size, and kind whether the result is normal, subnormal, zero, or infinity.

The code panel shows bare executable code by default. The bar above it names the file (hover the name for the full published path); options holds the toggles: comments, the tracer instrumentation that produces this visualization, and verbose names for the terse identifiers (display only: the default is the byte-exact published file). The view switch adds plain-English narration: both interleaves it with the code, pseudo shows only the pseudocode. hide code collapses the panel; the rail it leaves behind brings it back.

Keys: Space play/pause · ←/→ step · Home/End jump · R reset · F fullscreen · G guided tour

Scientific notation in base 2. Every nonzero number can be written as $\pm 1.f \times 2^e$ with $1 \le 1.f < 2$ : the leading digit of a binary number in that range is always $1$ . A float stores the sign, the exponent $e$ , and the fraction $f$ ; the leading $1$ is implied and costs no bit. With $8$ bits split $1 + 4 + 3$ :

6.3 = 1.575 \times 2^2, \qquad 1.575 = 1.101_2 + 0.075 \;\;\Rightarrow\;\; 1.101_2 \times 2^2 = 6.5 .

The bias. The exponent field holds $e + \text{bias}$ with $\text{bias} = 2^{k-1} - 1$ for $k$ exponent bits ( $7$ here, $15$ for half precision, $127$ for single, $1023$ for double). The field needs no sign bit, and two patterns of equal sign compare as integers in the same order as the numbers they encode, so sorting the bits sorts the values.

Finding the bits. Halving a number is exact in binary, so the exponent is found by halving or doubling until the mantissa lies in $[1, 2)$ and counting. The fraction is then found one bit at a time: double the part after the point, and the whole part of the result is the next bit. After $p$ fraction bits, whatever remains is less than one unit in the last place, $\text{ulp} = 2^{e - p}$ .

Rounding. The remainder decides: more than half an ulp rounds up, less rounds down, and exactly half rounds to whichever neighbour has an even last bit, so that a long run of ties does not drift. A round up can carry all the way through the fraction and into the exponent: $1.9375$ in this format becomes $2$ . The error after rounding is at most half an ulp, so the relative error is at most $2^{-p-1}$ whatever the size of the number: $1/16$ here, about $5 \times 10^{-4}$ in half precision, $6 \times 10^{-8}$ in single, $10^{-16}$ in double. Absolute error, by contrast, doubles with every power of two, which is what the banded number line shows.

The edges. The exponent field of all zeros means the leading $1$ is gone: the number is $0.f \times 2^{e_{\min}}$ , a subnormal, and these fill the gap between zero and the smallest normal number at a fixed spacing instead of leaving a hole. Zero is the subnormal with $f = 0$ , and comes in two signs. The field of all ones is infinity when $f = 0$ and not a number otherwise, the result of $0/0$ or $\sqrt{-1}$ . A format with $k$ exponent and $p$ fraction bits therefore holds $2^k - 2$ binades of $2^p$ numbers each, plus the subnormal band.

Adding floats. Two floats with different exponents cannot go straight into the adder from the previous lesson: the smaller must first be shifted right until the exponents agree, losing bits off its end, then the mantissas are added, then the result is normalised and rounded again. That is why $(a + b) + c$ and $a + (b + c)$ can differ, and why summing a million small numbers into a large one loses them. A floating-point unit is the integer adder plus shifters and a rounder wrapped around it.

Choices worth reading closely in the implementation (the code panel's comments and tracer checkboxes reveal the full published file):

Normalisation is halving and doubling, never Math.log2, because each step is exact and the trace should show the count being made. Math.log2 appears only in spacing, a helper for the readouts.
The fraction loop is binary long division of the remainder: double, take the whole part, keep the rest. After the loop the rest is already in units of the last place, so round compares it with 0.5 directly.
Ties to even is one test: remainder === 0.5 && fractionField % 2 === 1. The equality is exact because every value handled is a dyadic rational of the input, which doubles represent without error.
A carry out of the fraction bumps the exponent field in encode, and the kind is decided afterwards from the field, so a round up to infinity is reported as infinity.
decode is the whole meaning of the bits in four lines, and finish runs it on the result, so the reported error is the decoded value minus the input, never a second computation.
magnitudes lists what a format can hold between two bounds and refuses past 512 values, which is why the full-range line draws ticks only for the two small formats.

Scientific notation for machines is older than electronics: Leonardo Torres Quevedo proposed it in 1914, and Konrad Zuse built it into the Z1 and Z3 in the late 1930s, infinity included. For forty years after that every manufacturer chose its own exponent width, rounding rule, and treatment of overflow, so the same program gave different answers on different machines. In 1977 Intel hired William Kahan to design the arithmetic of the 8087 coprocessor, and the IEEE committee that formed around that design published standard 754 in 1985. Almost every processor since implements it.

1914Leonardo Torres Quevedo - Essays on Automatics describes a machine holding numbers as a mantissa and an exponent, the first proposal of floating point.source
1941Konrad Zuse - The Z3 computes in 22-bit binary floating point with special values for infinity and undefined results.source
1980Intel, with William Kahan - The 8087 coprocessor ships with the arithmetic that becomes the standard, including round to nearest even and subnormals.source
1985IEEE - IEEE 754 fixes the single and double formats, the rounding modes, and the exceptions.source
1989William Kahan - Receives the Turing Award for his work on floating-point arithmetic and the standard.source
2008IEEE - The revised standard adds the 16-bit half precision format on this stage, and decimal formats.source

Used today

Every numeric program - A JavaScript number is an IEEE 754 double; C's float and double, and the GPU's half and single, are the same scheme at other widths.
Graphics and machine learning - GPUs and accelerators run in half precision and bfloat16, trading the fraction bits this stage shows for throughput.
Scientific computing - Numerical analysis is largely the study of how the relative error shown here accumulates through an algorithm.

Did you know

In 1994 Thomas Nicely, a mathematics professor, found that Pentium processors divided some numbers wrongly from the fourth significant digit; Intel replaced the chips at a cost it put at 475 million dollars.source
The first Ariane 5 broke up forty seconds after launch in 1996 because a 64-bit floating-point value of the rocket's sideways velocity was converted to a 16-bit integer and did not fit; the code came from Ariane 4, which never flew that fast.source
In 1991 a Patriot battery in Dhahran missed a Scud missile because its clock counted tenths of a second in binary, where 0.1 has no exact representation; after 100 hours running, the accumulated error was a third of a second.source
In every IEEE double computation, 0.1 + 0.2 is 0.30000000000000004, because neither 0.1 nor 0.2 is representable and the two roundings do not cancel. A website with that number as its name lists the result in dozens of languages.source

value6.30

format

value: 6.3
stored: 6.5
error: +0.2
spacing: 0.5
kind: normal

floating-point.ts

import type { Tracer } from "../trace";/** A binary floating-point format: one sign bit, then the exponent field, then the fraction. */export interface FloatFormat {  exponentBits: number;  fractionBits: number;}/** The 8-bit format the stage starts on: 1 sign, 4 exponent, 3 fraction bits. */export const MINIFLOAT: FloatFormat = { exponentBits: 4, fractionBits: 3 };/** IEEE 754 binary16. */export const HALF_PRECISION: FloatFormat = { exponentBits: 5, fractionBits: 10 };export const MAX_EXPONENT_BITS = 8;export const MAX_FRACTION_BITS = 16;/** Values a number line can list between two magnitudes. */export const MAX_LISTED = 512;export type FloatKind = "zero" | "subnormal" | "normal" | "infinity";export interface Encoded {  sign: 0 | 1;  /** The stored exponent: the true exponent plus the bias; 0 for zero and subnormals, all ones for infinity. */  exponentField: number;  fractionField: number;  /** Sign, exponent, fraction, as written. */  bits: string;  kind: FloatKind;  /** What the bits decode to. */  value: number;  /** The value stored minus the value asked for. */  error: number;}/** * Encodes a number the way IEEE 754 does, one decision at a time: * the sign, then the exponent by halving or doubling until the * magnitude lies in [1, 2), then the fraction bit by bit, then the * rounding of what is left over, to the nearest representable value and * to an even last bit on a tie. The exponent is stored with a bias so * that the field never needs a sign of its own. The field of all zeros * is for zero and the subnormals, which fill the gap below the smallest * normal number at a fixed spacing; the field of all ones is for * infinity. The spacing between neighbours doubles with every power of * two, so the error of a stored number is relative, not absolute. * * Time: O(exponent range + fraction bits). Space: O(1). */export class FloatingPoint {  readonly bias: number;  /** The largest exponent of a finite number; the field above it is infinity. */  readonly maxExponent: number;  /** The exponent of the smallest normal number, and of every subnormal. */  readonly minExponent: number;  constructor(    private readonly format: FloatFormat,    private readonly tracer?: Tracer,  ) {    const { exponentBits, fractionBits } = format;    if (!Number.isInteger(exponentBits) || exponentBits < 2 || exponentBits > MAX_EXPONENT_BITS) throw new RangeError(`exponent bits must be in [2, ${MAX_EXPONENT_BITS}]`);    if (!Number.isInteger(fractionBits) || fractionBits < 1 || fractionBits > MAX_FRACTION_BITS) throw new RangeError(`fraction bits must be in [1, ${MAX_FRACTION_BITS}]`);    this.bias = 2 ** (exponentBits - 1) - 1;    this.maxExponent = this.bias;    this.minExponent = 1 - this.bias;  }  get width(): number {    return 1 + this.format.exponentBits + this.format.fractionBits;  }  /** The largest finite value. */  get largest(): number {    return (2 - 2 ** -this.format.fractionBits) * 2 ** this.maxExponent;  }  /** The distance between neighbours at a magnitude: one unit in the last place. */  spacing(magnitude: number): number {    const exponent = Math.max(this.minExponent, Math.floor(Math.log2(Math.max(Math.abs(magnitude), Number.MIN_VALUE))));    return 2 ** (Math.min(exponent, this.maxExponent) - this.format.fractionBits);  }  encode(value: number): Encoded {    const { fractionBits, exponentBits } = this.format;    const infinityField = 2 ** exponentBits - 1;    const sign: 0 | 1 = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;    const magnitude = Math.abs(value);    // ▸ the sign bit: 1 for a negative number, then work on the magnitude    this.tracer?.emit("sign", { value, sign, magnitude });    if (magnitude === 0 || !Number.isFinite(magnitude)) {      const kind: FloatKind = magnitude === 0 ? "zero" : "infinity";      const exponentField = this.chooseExponent(kind === "zero" ? this.minExponent : this.maxExponent + 1, kind === "zero" ? 0 : infinityField, kind, 0);      return this.finish(value, sign, exponentField, 0, kind);    }    // Normalize: halve or double, exactly, until the mantissa lies in [1, 2) or the exponent range runs out.    let scaled = { exponent: 0, mantissa: magnitude };    while (scaled.mantissa >= 2 && scaled.exponent < this.maxExponent) scaled = this.scale("halve", scaled);    while (scaled.mantissa < 1 && scaled.exponent > this.minExponent) scaled = this.scale("double", scaled);    const { exponent, mantissa } = scaled;    if (mantissa >= 2) {      const exponentField = this.chooseExponent(exponent + 1, infinityField, "infinity", mantissa);      return this.finish(value, sign, exponentField, 0, "infinity");    }    const subnormal = mantissa < 1;    let exponentField = this.chooseExponent(exponent, subnormal ? 0 : exponent + this.bias, subnormal ? "subnormal" : "normal", mantissa);    // The fraction: the part after the leading 1 (the whole mantissa for a subnormal), one bit per doubling.    let remainder = subnormal ? mantissa : mantissa - 1;    let fractionField = 0;    for (let index = 1; index <= fractionBits; index++) {      remainder *= 2;      const bit = remainder >= 1 ? 1 : 0;      remainder -= bit;      fractionField = fractionField * 2 + bit;      // ▸ one fraction bit: double what is left after the leading 1, and take the whole part      this.tracer?.emit("fraction", { index, bit, remainder, field: fractionField });    }    // Round to nearest, ties to even: the remainder is in units of the last place.    const up = remainder > 0.5 || (remainder === 0.5 && fractionField % 2 === 1);    const roundsUp = remainder > 0.5 || (remainder === 0.5 && fractionField % 2 === 1);    let carried = false;    let carriedIntoExponent = false;    if (up) {    if (roundsUp) {      fractionField++;      if (fractionField === 2 ** fractionBits) {        fractionField = 0;        exponentField++;        carried = true;        carriedIntoExponent = true;      }    }    // ▸ what is left is less than one unit in the last place: round to the nearest, and to even on a tie    this.tracer?.emit("round", { remainder, up, carried, field: fractionField, exponentField });    this.tracer?.emit("round", { remainder, roundsUp, carriedIntoExponent, field: fractionField, exponentField });    const kind: FloatKind = exponentField === infinityField ? "infinity" : exponentField === 0 ? "subnormal" : "normal";    return this.finish(value, sign, exponentField, fractionField, kind);  }  /** What a bit pattern means: the sign, the biased exponent, and the fraction below an implied leading 1 (0 for subnormals). */  decode(sign: 0 | 1, exponentField: number, fractionField: number): number {    const { fractionBits, exponentBits } = this.format;    const negative = sign === 1 ? -1 : 1;    if (exponentField === 2 ** exponentBits - 1) return negative * Infinity;    const fraction = fractionField / 2 ** fractionBits;    if (exponentField === 0) return negative * fraction * 2 ** this.minExponent;    return negative * (1 + fraction) * 2 ** (exponentField - this.bias);  }  /** Every non-negative value the format can hold in [from, to], smallest first; a number line's ticks. */  magnitudes(from: number, to: number): number[] {    const { fractionBits, exponentBits } = this.format;    const out: number[] = [];    const count = 2 ** fractionBits;    for (let field = 0; field < 2 ** exponentBits - 1; field++) {      for (let fraction = 0; fraction < count; fraction++) {        const value = this.decode(0, field, fraction);        if (value > to) return out;        if (value >= from) {          out.push(value);          if (out.length > MAX_LISTED) throw new RangeError(`more than ${MAX_LISTED} values in [${from}, ${to}]; narrow the window`);        }      }    }    return out;  }  /** One halving or doubling of the mantissa, exact in binary, with the exponent keeping count. */  private scale(direction: "halve" | "double", from: { exponent: number; mantissa: number }): { exponent: number; mantissa: number } {    const mantissa = direction === "halve" ? from.mantissa / 2 : from.mantissa * 2;    const exponent = direction === "halve" ? from.exponent + 1 : from.exponent - 1;    // ▸ halve or double the magnitude, exactly, and count the exponent, until it lies in [1, 2)    this.tracer?.emit("scale", { direction, exponent, mantissa });    return { exponent, mantissa };  }  /** The exponent field settled: biased for a normal number, all zeros for zero and the subnormals, all ones for infinity. */  private chooseExponent(exponent: number, field: number, kind: FloatKind, mantissa: number): number {    // ▸ store the exponent plus the bias; all zeros is zero or a subnormal, all ones is infinity    this.tracer?.emit("exponent", { exponent, field, bits: this.fieldBits(field, this.format.exponentBits), kind, mantissa });    return field;  }  private fieldBits(field: number, bits: number): string {    return field.toString(2).padStart(bits, "0");  }  private finish(value: number, sign: 0 | 1, exponentField: number, fractionField: number, kind: FloatKind): Encoded {    const stored = this.decode(sign, exponentField, fractionField);    const bits = `${sign}${this.fieldBits(exponentField, this.format.exponentBits)}${this.fieldBits(fractionField, this.format.fractionBits)}`;    const error = kind === "infinity" ? Infinity : stored - value;    // ▸ sign, exponent, fraction, as written, and what they decode to    this.tracer?.emit("encode", { bits, sign, exponentField, fractionField, kind, value: stored, error });    return { sign, exponentField, fractionField, bits, kind, value: stored, error };  }}

bits =: 01001101
stored =: 6.5
error =: +0.2

6.3 is stored in 8 bits as 01001101, which reads back as 6.5: normal, error +0.2.

import type { Tracer } from "../trace";/** A binary floating-point format: one sign bit, then the exponent field, then the fraction. */export interface FloatFormat { exponentBits: number; fractionBits: number;}/** The 8-bit format the stage starts on: 1 sign, 4 exponent, 3 fraction bits. */export const MINIFLOAT: FloatFormat = { exponentBits: 4, fractionBits: 3 };/** IEEE 754 binary16. */export const HALF_PRECISION: FloatFormat = { exponentBits: 5, fractionBits: 10 };export const MAX_EXPONENT_BITS = 8;export const MAX_FRACTION_BITS = 16;/** Values a number line can list between two magnitudes. */export const MAX_LISTED = 512;export type FloatKind = "zero" | "subnormal" | "normal" | "infinity";export interface Encoded { sign: 0 | 1; /** The stored exponent: the true exponent plus the bias; 0 for zero and subnormals, all ones for infinity. */ exponentField: number; fractionField: number; /** Sign, exponent, fraction, as written. */ bits: string; kind: FloatKind; /** What the bits decode to. */ value: number; /** The value stored minus the value asked for. */ error: number;}/** * Encodes a number the way IEEE 754 does, one decision at a time: * the sign, then the exponent by halving or doubling until the * magnitude lies in [1, 2), then the fraction bit by bit, then the * rounding of what is left over, to the nearest representable value and * to an even last bit on a tie. The exponent is stored with a bias so * that the field never needs a sign of its own. The field of all zeros * is for zero and the subnormals, which fill the gap below the smallest * normal number at a fixed spacing; the field of all ones is for * infinity. The spacing between neighbours doubles with every power of * two, so the error of a stored number is relative, not absolute. * * Time: O(exponent range + fraction bits). Space: O(1). */export class FloatingPoint { readonly bias: number; /** The largest exponent of a finite number; the field above it is infinity. */ readonly maxExponent: number; /** The exponent of the smallest normal number, and of every subnormal. */ readonly minExponent: number; constructor( private readonly format: FloatFormat, private readonly tracer?: Tracer, ) { const { exponentBits, fractionBits } = format; if (!Number.isInteger(exponentBits) || exponentBits < 2 || exponentBits > MAX_EXPONENT_BITS) throw new RangeError(`exponent bits must be in [2, ${MAX_EXPONENT_BITS}]`); if (!Number.isInteger(fractionBits) || fractionBits < 1 || fractionBits > MAX_FRACTION_BITS) throw new RangeError(`fraction bits must be in [1, ${MAX_FRACTION_BITS}]`); this.bias = 2 ** (exponentBits - 1) - 1; this.maxExponent = this.bias; this.minExponent = 1 - this.bias; } get width(): number { return 1 + this.format.exponentBits + this.format.fractionBits; } /** The largest finite value. */ get largest(): number { return (2 - 2 ** -this.format.fractionBits) * 2 ** this.maxExponent; } /** The distance between neighbours at a magnitude: one unit in the last place. */ spacing(magnitude: number): number { const exponent = Math.max(this.minExponent, Math.floor(Math.log2(Math.max(Math.abs(magnitude), Number.MIN_VALUE)))); return 2 ** (Math.min(exponent, this.maxExponent) - this.format.fractionBits); } encode(value: number): Encoded { const { fractionBits, exponentBits } = this.format; const infinityField = 2 ** exponentBits - 1; const sign: 0 | 1 = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; const magnitude = Math.abs(value); // ▸ the sign bit: 1 for a negative number, then work on the magnitude this.tracer?.emit("sign", { value, sign, magnitude }); if (magnitude === 0 || !Number.isFinite(magnitude)) { const kind: FloatKind = magnitude === 0 ? "zero" : "infinity"; const exponentField = this.chooseExponent(kind === "zero" ? this.minExponent : this.maxExponent + 1, kind === "zero" ? 0 : infinityField, kind, 0); return this.finish(value, sign, exponentField, 0, kind); } // Normalize: halve or double, exactly, until the mantissa lies in [1, 2) or the exponent range runs out. let scaled = { exponent: 0, mantissa: magnitude }; while (scaled.mantissa >= 2 && scaled.exponent < this.maxExponent) scaled = this.scale("halve", scaled); while (scaled.mantissa < 1 && scaled.exponent > this.minExponent) scaled = this.scale("double", scaled); const { exponent, mantissa } = scaled; if (mantissa >= 2) { const exponentField = this.chooseExponent(exponent + 1, infinityField, "infinity", mantissa); return this.finish(value, sign, exponentField, 0, "infinity"); } const subnormal = mantissa < 1; let exponentField = this.chooseExponent(exponent, subnormal ? 0 : exponent + this.bias, subnormal ? "subnormal" : "normal", mantissa); // The fraction: the part after the leading 1 (the whole mantissa for a subnormal), one bit per doubling. let remainder = subnormal ? mantissa : mantissa - 1; let fractionField = 0; for (let index = 1; index <= fractionBits; index++) { remainder *= 2; const bit = remainder >= 1 ? 1 : 0; remainder -= bit; fractionField = fractionField * 2 + bit; // ▸ one fraction bit: double what is left after the leading 1, and take the whole part this.tracer?.emit("fraction", { index, bit, remainder, field: fractionField }); } // Round to nearest, ties to even: the remainder is in units of the last place. const up = remainder > 0.5 || (remainder === 0.5 && fractionField % 2 === 1); const roundsUp = remainder > 0.5 || (remainder === 0.5 && fractionField % 2 === 1); let carried = false; let carriedIntoExponent = false; if (up) { if (roundsUp) { fractionField++; if (fractionField === 2 ** fractionBits) { fractionField = 0; exponentField++; carried = true; carriedIntoExponent = true; } } // ▸ what is left is less than one unit in the last place: round to the nearest, and to even on a tie this.tracer?.emit("round", { remainder, up, carried, field: fractionField, exponentField }); this.tracer?.emit("round", { remainder, roundsUp, carriedIntoExponent, field: fractionField, exponentField }); const kind: FloatKind = exponentField === infinityField ? "infinity" : exponentField === 0 ? "subnormal" : "normal"; return this.finish(value, sign, exponentField, fractionField, kind); } /** What a bit pattern means: the sign, the biased exponent, and the fraction below an implied leading 1 (0 for subnormals). */ decode(sign: 0 | 1, exponentField: number, fractionField: number): number { const { fractionBits, exponentBits } = this.format; const negative = sign === 1 ? -1 : 1; if (exponentField === 2 ** exponentBits - 1) return negative * Infinity; const fraction = fractionField / 2 ** fractionBits; if (exponentField === 0) return negative * fraction * 2 ** this.minExponent; return negative * (1 + fraction) * 2 ** (exponentField - this.bias); } /** Every non-negative value the format can hold in [from, to], smallest first; a number line's ticks. */ magnitudes(from: number, to: number): number[] { const { fractionBits, exponentBits } = this.format; const out: number[] = []; const count = 2 ** fractionBits; for (let field = 0; field < 2 ** exponentBits - 1; field++) { for (let fraction = 0; fraction < count; fraction++) { const value = this.decode(0, field, fraction); if (value > to) return out; if (value >= from) { out.push(value); if (out.length > MAX_LISTED) throw new RangeError(`more than ${MAX_LISTED} values in [${from}, ${to}]; narrow the window`); } } } return out; } /** One halving or doubling of the mantissa, exact in binary, with the exponent keeping count. */ private scale(direction: "halve" | "double", from: { exponent: number; mantissa: number }): { exponent: number; mantissa: number } { const mantissa = direction === "halve" ? from.mantissa / 2 : from.mantissa * 2; const exponent = direction === "halve" ? from.exponent + 1 : from.exponent - 1; // ▸ halve or double the magnitude, exactly, and count the exponent, until it lies in [1, 2) this.tracer?.emit("scale", { direction, exponent, mantissa }); return { exponent, mantissa }; } /** The exponent field settled: biased for a normal number, all zeros for zero and the subnormals, all ones for infinity. */ private chooseExponent(exponent: number, field: number, kind: FloatKind, mantissa: number): number { // ▸ store the exponent plus the bias; all zeros is zero or a subnormal, all ones is infinity this.tracer?.emit("exponent", { exponent, field, bits: this.fieldBits(field, this.format.exponentBits), kind, mantissa }); return field; } private fieldBits(field: number, bits: number): string { return field.toString(2).padStart(bits, "0"); } private finish(value: number, sign: 0 | 1, exponentField: number, fractionField: number, kind: FloatKind): Encoded { const stored = this.decode(sign, exponentField, fractionField); const bits = `${sign}${this.fieldBits(exponentField, this.format.exponentBits)}${this.fieldBits(fractionField, this.format.fractionBits)}`; const error = kind === "infinity" ? Infinity : stored - value; // ▸ sign, exponent, fraction, as written, and what they decode to this.tracer?.emit("encode", { bits, sign, exponentField, fractionField, kind, value: stored, error }); return { sign, exponentField, fractionField, bits, kind, value: stored, error }; }}