🔰floating-point

🚧 under construction

JS ⟩ value ⟩ primitive ⟩ number ⟩ floating-point

the implementation of JavaScript’s Number：

based on the “IEEE 754” standard.
uses the “double precision” format (aka “64-bit binary”).

📗 You Don't Know JS: Types & Grammar

all numbers are floating-point.
all division have floating-point results.

The exponent is an 11-bit from 0 to 2047, in biased form: an exponent value of 1023 represents the actual zero. Exponents range from −1022 to +1023 because exponents of −1023 (all 0s) and +1024 (all 1s) are reserved for special numbers.

📗 Wikipedia

// 單精度浮點數
sign
↓╭─exp──╮╭────── fraction ──────╮
001111100010000000000000000000000 = n
↑╰─8-bit╯╰─────── 23-bit ───────╯

   ⭐️ sign ↴        ↱ exp ⭐️                    ↱ fraction ⭐️
n = (-1)^sign * 2^[exp - (01111111)₂] * [1 + (.01)₂]
  =    1   *   2^(-3)   *   (1 + 1/4)
  =    1   *   0.125    *    1.25
  =    0.15625
  
// 雙精度浮點數 (double precision)(64-bit)

sign: 0 -> +, 1 -> -
exp : -1022 ~ 1023   (2^1024 ≈ 1.8 * 10^308)
frac: a₁(2)¯¹ + a₂(2)¯² + ... + a₅₂(2)¯⁵²

// ┌───────────────────────────────────────────────────────────┐
// │ n = (-1)^sign * 2^[exp - (01111111111)₂] * (1 + fraction) │
// └───────────────────────────────────────────────────────────┘

sign
↓ ╭── exp ──╮ ╭───────────────────── fraction ───────────────────╮
0 10000000000 0100000000000000000000000000000000000000000000000000
  ╰──11-bit─╯ ╰────────────────────── 52-bit ────────────────────╯
  
= (-1)⁰ * 2^[(10000000000)₂ - (01111111111)₂] * (1.01)₂
= 1 * 2 * (1.25)
= 2.5

Floating-Point

Number.MAX_VALUE

    ┌──────────────────┐
    │ Number.MAX_VALUE │
    └──────────────────┘

      2¹⁰²³                                               2⁹⁷¹
        ↓                                                  ↓
    = 1.1111111111111111111111111111111111111111111111111111 * 2¹⁰²³
        ╰──────────────────── 52-bit ──────────────────────╯
    = 1.7976931348623157e+308
    ≈ 2¹⁰²⁴

NaN

// ⭐️ `NaN` is the ONLY ONE that doesn't equal to itself.
NaN === NaN,            // false❗️
NaN !== NaN,            // true❗️

isNaN('foo'),           // true❗️ (⭐️ DON'T use isNaN())

Number.isNaN('foo'),    // false (⭐️ use Number.isNaN() instead)
Number.isNaN(NaN),      // true

2 / 'foo',              // NaN

±Infinity & ±0

const {log} = console;

/*
    ┌──────────────────┐
    │ Number.MAX_VALUE │
    └──────────────────┘

      2¹⁰²³                                               2⁹⁷¹
        ↓                                                  ↓
    = 1.1111111111111111111111111111111111111111111111111111 * 2¹⁰²³
        ╰──────────────────── 52-bit ──────────────────────╯
    = 1.7976931348623157e+308
    ≈ 2¹⁰²⁴
*/

// ---------- log ----------

const M = Number.MAX_VALUE;
const D = Math.pow(2, 970);     // 2⁹⁷⁰
const d = Math.pow(2, 969);     // 2⁹⁶⁹

[
    // -------- Infinity --------

     1 / 0,     //  Infinity
    -1 / 0,     // -Infinity

     Infinity === Number.POSITIVE_INFINITY, // true
    -Infinity === Number.NEGATIVE_INFINITY, // true

    3 + Infinity,           // Infinity
    3 / Infinity,           //  0
    -3 / Infinity,          // -0
    Infinity / Infinity,    // NaN

    // -------- Number.MAX_VALUE --------

    M,                      // 1.7976931348623157e+308

    // ⭐️ 只要 M 的最後一位 (2⁹⁷¹) 的一半 = 2⁹⁷⁰ 就足以讓 M 「進位」變成 Infinity
    M + D,                  // Infinity

    // ⭐️ 再小的話，則會被直接「捨棄」。
    M + d,                  // M

    // -------- Number.MAX_SAFE_INTEGER --------

    Number.MAX_SAFE_INTEGER,    // 9007199254740991 = 2⁵³ - 1
    Math.pow(2, 53) - 1,        // 9007199254740991

].forEach(x => log(x));

PreviousNumber Nextintegers

Last updated 2 years ago

Was this helpful?