Arithmetic from the Gates Up

const a = 0x7fffffff, b = 0x7fffffff;         // 2^31 - 1 squared is ~4.6e18, far above 2^53
console.log("exact product      :", BigInt(a) * BigInt(b));
console.log("a * b (double)     :", a * b, "-> already rounded");
console.log("(a * b) | 0        :", (a * b) | 0, "(low bits of the *rounded* product: wrong)");
console.log("Math.imul          :", Math.imul(a, b), "(low 32 bits of the exact product)");
console.log("BigInt.asIntN(32)  :", BigInt.asIntN(32, BigInt(a) * BigInt(b)), "(same value, from the exact product)");
// Small operands agree, because the exact product fits in a double.
console.log("small case agrees  :", ((1234 * 5678) | 0) === Math.imul(1234, 5678));

// Recode a 32-bit two's-complement multiplier into radix-4 Booth digits and
// multiply using only shifts and additions of the multiplicand, as a hardware
// multiplier does. The result is the low 32 bits, exactly like Math.imul.
function boothDigits(m) {
  const digits = [];
  let prev = 0;                                     // the implicit bit below bit 0
  for (let i = 0; i < 32; i += 2) {
    const b0 = (m >>> i) & 1, b1 = (m >>> (i + 1)) & 1;
    // digit = -2*b1 + b0 + prev, one of {-2,-1,0,1,2}
    digits.push(-2 * b1 + b0 + prev);
    prev = b1;
  }
  return digits;                                    // 16 digits for 32 bits
}
function boothMul(a, m) {
  let acc = 0;
  boothDigits(m).forEach((d, i) => { acc = (acc + d * (a << (2 * i))) | 0; });   // d*a is a shift and maybe a negate
  return acc | 0;
}
const digits = boothDigits(0b0111_1111_0000_0011 | 0);
console.log("multiplier 0111111100000011 recodes to", digits.slice(0, 8).join(","), "... (mostly zeros: runs collapse)");
console.log("nonzero partial products:", digits.filter(Boolean).length, "of 16, versus", (0b0111_1111_0000_0011).toString(2).split("1").length - 1, "set bits");

let ok = true;
for (let i = 0; i < 2000; i++) {
  const x = (Math.random() * 2 ** 32) | 0, y = (Math.random() * 2 ** 32) | 0;
  if (boothMul(x, y) !== Math.imul(x, y)) { ok = false; console.log("mismatch", x, y); break; }
}
console.log("all 2000 random products agree with Math.imul:", ok);

// Time n-bit × n-bit products for doubling n and estimate the exponent k in t ∝ n^k.
// Schoolbook gives k ≈ 2; Karatsuba k ≈ 1.58; Toom-3 k ≈ 1.46. Watch k fall as n grows.
function randomBig(bits) {
  let x = 0n;
  for (let i = 0; i < bits; i += 32) x = (x << 32n) | BigInt((Math.random() * 2 ** 32) >>> 0);
  return x | (1n << BigInt(bits - 1));            // force the full width
}
function time(bits, reps) {
  const a = randomBig(bits), b = randomBig(bits);
  let sink = 0n;
  const t0 = performance.now();
  for (let i = 0; i < reps; i++) sink ^= a * b;
  return (performance.now() - t0) / reps;
}
let prev = null;
for (const bits of [2048, 4096, 8192, 16384, 32768, 65536, 131072]) {
  const reps = Math.max(2, Math.floor(20000000 / bits ** 1.6));
  const t = time(bits, reps);
  const k = prev ? Math.log2(t / prev) : NaN;
  console.log(String(bits).padStart(7), "bits:", t.toFixed(4).padStart(9), "ms/mul", prev ? " k ≈ " + k.toFixed(2) : "");
  prev = t;
}
console.log("k near 2 is schoolbook; a drop toward ~1.6 marks the Karatsuba threshold.");

// Two-Sum (Knuth / Møller): the error of a + b is itself representable and computable.
function twoSum(a, b) { const s = a + b; const bb = s - a; const err = (a - (s - bb)) + (b - bb); return [s, err]; }
const [s, err] = twoSum(0.1, 0.2);
console.log("0.1 + 0.2 =", s, " exact error of that addition:", err, "(as a multiple of 2^-54:", err / 2 ** -54, ")");

// Naive summation accumulates the rounding of every step.
const xs = Array(10).fill(0.1);
console.log("naive sum of 0.1 x 10  :", xs.reduce((a, b) => a + b, 0));
// Neumaier's compensated sum tracks the lost low bits.
function compensated(list) { let sum = 0, c = 0; for (const x of list) { const t = sum + x; c += Math.abs(sum) >= Math.abs(x) ? (sum - t) + x : (x - t) + sum; sum = t; } return sum + c; }
console.log("compensated            :", compensated(xs));
console.log("Math.sumPrecise        :", typeof Math.sumPrecise === "function" ? Math.sumPrecise(xs) : "not in this engine yet (ES2025)");
// Catastrophic case: the naive order loses a small term entirely.
const hard = [1e100, 1, -1e100];
console.log("naive [1e100, 1, -1e100]:", hard.reduce((a, b) => a + b, 0), "| compensated:", compensated(hard), "| sumPrecise:", typeof Math.sumPrecise === "function" ? Math.sumPrecise(hard) : "n/a");

// The exact decimal expansion of a double, via BigInt: value = mantissa × 2^exp exactly.
function exactDecimal(x) {
  const f64 = new Float64Array([x]), u = new BigUint64Array(f64.buffer)[0];
  const exp = Number((u >> 52n) & 0x7ffn) - 1075, frac = (u & ((1n << 52n) - 1n)) | (1n << 52n);
  if (exp >= 0) return (frac << BigInt(exp)).toString();
  // value = frac / 2^-exp = frac * 5^-exp / 10^-exp: multiply by 5^-exp, then place the point.
  const digits = (frac * 5n ** BigInt(-exp)).toString().padStart(-exp + 1, "0");
  return digits.slice(0, digits.length + exp) + "." + digits.slice(digits.length + exp);
}
console.log("exact decimal of 0.1  :", exactDecimal(0.1));
console.log("shortest (toString)   :", String(0.1), "<- what the spec requires");
console.log("exact decimal of 1.005:", exactDecimal(1.005));
console.log("(1.005).toFixed(2) =", (1.005).toFixed(2), " (rounds the exact value, which is below 1.005)");

// Shortest means: no shorter string parses to the same double, and this one does.
const samples = [0.1, 1 / 3, 5e-324, 1.7976931348623157e308, 123456789.123456789, 2 ** 53 + 2];
console.log("round-trips:", samples.every((x) => Number(String(x)) === x));
console.log("digit counts:", samples.map((x) => String(x).replace(/[-.e+]/g, "").length).join(", "), "(never more than 17 significant digits)");

console.log("9007199254740993 parses to", Number("9007199254740993"), "(exact halfway -> ties to even)");
console.log("9007199254740995 parses to", Number("9007199254740995"), "(halfway the other way -> even neighbour is ...996)");
const boundary = Number("2.2250738585072011e-308");
console.log("subnormal boundary parses without hanging:", boundary > 0 && boundary < Number.MIN_VALUE * 2 ** 52 * 1.0000001);
console.log("MIN_VALUE (smallest subnormal):", Number.MIN_VALUE, "| its exact decimal has 1074 fractional digits");
console.log("parseFloat stops at the first bad char:", parseFloat("3.14abc"), "| Number() rejects it:", Number("3.14abc"));
console.log("Number('') and Number(' ') are 0 (StringToNumber of whitespace-only is 0):", Number(""), Number("  "));
console.log("hex, octal, binary literals in strings:", Number("0x1f"), Number("0o17"), Number("0b101"), "| but no sign with a radix prefix:", Number("-0x1f"));