Why does Math.hypot() prevent overflow in JavaScript?

Mar 12, 2026

I got Infinity from a distance calculation. My inputs weren’t even that large.

const a = 1e200;
const b = 1e200;

const distance = Math.sqrt(a * a + b * b);
// Result: Infinity
// Expected: 1.4142135623730951e+200

The values 1e200 seemed reasonable. JavaScript’s Number.MAX_VALUE is 1.7976931348623157e+308, so both inputs are well within range. Why did I get Infinity?

The Problem: Intermediate Overflow

I traced through my calculation step by step:

const a = 1e200;
const b = 1e200;

console.log(a);              // 1e+200 (fine)
console.log(a * a);          // Infinity (OVERFLOW!)
console.log(a * a + b * b);  // Infinity + Infinity = Infinity
console.log(Math.sqrt(Infinity)); // Infinity

// The problem: a*a = 1e400, which exceeds Number.MAX_VALUE (1.8e308)

The overflow happens at the multiplication step, before Math.sqrt() is even called. The intermediate value 1e400 exceeds JavaScript’s maximum floating-point value.

The Underflow Problem

I also discovered the opposite problem with very small numbers:

const a = 1e-200;
const b = 1e-200;

console.log(a);              // 1e-200 (fine)
console.log(a * a);         // 0 (UNDERFLOW!)
console.log(a * a + b * b);  // 0 + 0 = 0
console.log(Math.sqrt(0));   // 0

// Expected: 1.4142135623730951e-200
// Got: 0

When I square 1e-200, I get 1e-400, which underflows to 0 because it’s smaller than Number.MIN_VALUE (5e-324).

The Solution: Math.hypot()

JavaScript has a built-in solution:

// Overflow case - manual sqrt fails
Math.sqrt(1e200 * 1e200 + 1e200 * 1e200);  // Infinity (WRONG)
Math.hypot(1e200, 1e200);                     // 1.4142135623730951e+200 (CORRECT)

// Underflow case - manual sqrt fails
Math.sqrt(1e-200 * 1e-200 + 1e-200 * 1e-200);  // 0 (WRONG)
Math.hypot(1e-200, 1e-200);                     // 1.4142135623730951e-200 (CORRECT)

Math.hypot() handles both overflow and underflow automatically. How?

How Math.hypot() Works: The Scaling Algorithm

The key insight is that Math.hypot() never lets intermediate values get too large or too small. Here’s the algorithm:

Step 1: Find the maximum absolute value M
  M = max(|a|, |b|, ...)

Step 2: Handle edge cases
  If M = 0, return 0
  If M = Infinity, return Infinity

Step 3: Scale all values by 1/M
  a_scaled = a / M
  b_scaled = b / M

Step 4: Compute in scaled space
  sum = a_scaled^2 + b_scaled^2

Step 5: Scale back
  result = M * sqrt(sum)

Why this prevents overflow:
  - After scaling, all values are <= 1
  - Squaring values <= 1 gives values <= 1
  - No overflow possible!

A Simplified Implementation

Here’s a simplified version of what Math.hypot() does internally:

function stableHypot(a, b) {
  const absA = Math.abs(a);
  const absB = Math.abs(b);
  const max = Math.max(absA, absB);

  // Edge cases
  if (max === 0) return 0;
  if (max === Infinity) return Infinity;

  // Scale down, compute, scale back up
  const ratioA = absA / max;
  const ratioB = absB / max;

  return max * Math.sqrt(ratioA * ratioA + ratioB * ratioB);
}

// Test with overflow case
stableHypot(1e200, 1e200);
// Step 1: max = 1e200
// Step 2: ratioA = 1, ratioB = 1
// Step 3: sqrt(1*1 + 1*1) = sqrt(2) = 1.414...
// Step 4: 1e200 * 1.414... = 1.414e200 (CORRECT!)

// Test with underflow case
stableHypot(1e-200, 1e-200);
// Step 1: max = 1e-200
// Step 2: ratioA = 1, ratioB = 1
// Step 3: sqrt(1*1 + 1*1) = sqrt(2) = 1.414...
// Step 4: 1e-200 * 1.414... = 1.414e-200 (CORRECT!)

The scaled values are always <= 1, so squaring them can never overflow. The final multiplication by max scales the result back to the correct magnitude.

Floating-Point Limits in JavaScript

Understanding why this matters requires knowing JavaScript’s floating-point limits:

// JavaScript uses IEEE 754 double-precision
Number.MAX_VALUE;        // 1.7976931348623157e+308
Number.MIN_VALUE;        // 5e-324
Number.MAX_SAFE_INTEGER; // 9007199254740991 (2^53 - 1)

// When you square a large number
1e154 * 1e154;   // 1e308 (within range)
1e155 * 1e155;   // Infinity (overflow!)

// When you square a tiny number
1e-162 * 1e-162; // 1e-324 (within range)
1e-163 * 1e-163; // 0 (underflow!)

The overflow threshold is around 1e154 for squaring operations. Any value larger than that will overflow when squared.

Real-World Scenarios

I thought this was an edge case until I encountered these situations:

Scientific Computing

// Processing astronomical distances (in meters)
const distanceToStar = 9.461e15;  // 1 light-year in meters
const distanceToGalaxy = 2.5e22;  // Distance to Andromeda

// Naive calculation overflows
Math.sqrt(distanceToStar * distanceToStar + distanceToGalaxy * distanceToGalaxy);
// Result: Infinity (WRONG)

// Correct approach
Math.hypot(distanceToStar, distanceToGalaxy);
// Result: 2.5e22 (CORRECT)

Game Development with Large Worlds

// Open-world game with large coordinate values
const playerX = 1e10;  // Player at edge of map
const playerY = 1e10;
const enemyX = 1.5e10;
const enemyY = 1.5e10;

// Distance calculation in game loop
function distance(x1, y1, x2, y2) {
  const dx = x2 - x1;
  const dy = y2 - y1;

  // This can overflow for large coordinates
  // return Math.sqrt(dx * dx + dy * dy);

  // Use hypot for safety
  return Math.hypot(dx, dy);
}

Data Normalization

// Normalizing feature vectors in ML
const features = [1e150, 1e150, 1e150];

// Naive magnitude calculation overflows
const magnitude = Math.sqrt(
  features.reduce((sum, f) => sum + f * f, 0)
);
// Result: Infinity (WRONG)

// Correct approach
const magnitudeCorrect = Math.hypot(...features);
// Result: 1.732e150 (CORRECT)

Historical Context: This Problem Is Decades Old

I was surprised to learn that this isn’t a new JavaScript problem:

1970s: Fortran introduces HYPOT intrinsic function
  - Scientific computing required numerical stability
  - Engineers recognized overflow/underflow risks

1990s: C/C++ add hypot() to math.h
  - POSIX standard includes hypot()
  - Same algorithm: scale before squaring

2015: JavaScript ES6 adds Math.hypot()
  - Same battle-tested algorithm
  - Extended to support n dimensions

From the Reddit discussion, user tokagemushi noted: “It’s the same reason Fortran has had HYPOT since the 70s.” This is a solved problem in numerical computing.

When Should You Use Math.hypot()?

Always Use Math.hypot() When:

// Scientific calculations with unknown input ranges
const distance = Math.hypot(dx, dy);

// Multi-dimensional vectors
const magnitude3D = Math.hypot(x, y, z);
const magnitudeND = Math.hypot(...vector);

// Code that processes external data
function calculateDistance(p1, p2) {
  return Math.hypot(p2.x - p1.x, p2.y - p1.y);
}

// Any situation where input magnitude is uncertain

Manual sqrt() Is Acceptable When:

// You control the input range
const dx = Math.cos(angle) * radius;  // radius is small
const dy = Math.sin(angle) * radius;
const dist = Math.sqrt(dx * dx + dy * dy);  // Safe

// Performance-critical code with known bounds
// (if inputs are guaranteed < 1e154)

Comparison Summary

Input Size    | Known Range    | Unknown Range
--------------|----------------|---------------
Small (<1e100)| sqrt OK        | hypot preferred
Medium        | sqrt OK        | hypot required
Large (>1e154)| hypot required| hypot required
Tiny (<1e-162)| hypot required| hypot required

Summary

I learned that Math.sqrt(a*a + b*b) is a landmine. The intermediate multiplication can overflow or underflow before the square root is even applied.

// DON'T do this:
const dist = Math.sqrt(a * a + b * b);

// DO this instead:
const dist = Math.hypot(a, b);

Key points:

JavaScript uses IEEE 754 double-precision with limits around 1.8e308 (max) and 5e-324 (min)
Squaring 1e155 overflows to Infinity, squaring 1e-163 underflows to 0
Math.hypot() scales inputs to prevent intermediate overflow/underflow
This algorithm has been used since the 1970s in Fortran
Use Math.hypot() for any distance calculation where input magnitude is uncertain

The next time you calculate distance, magnitude, or vector length, remember: Math.hypot() isn’t just syntactic sugar. It’s the numerically correct way to compute hypotenuses.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 Reddit r/javascript - TIL about Math.hypot()
👨‍💻 MDN Web Docs: Math.hypot()
👨‍💻 IEEE 754 - Wikipedia

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!