The Pythagorean Theorem in Programming and Games

In programming, the Pythagorean theorem is how code measures the straight-line distance between two points: subtract the coordinates to get the legs dx and dy, then compute √dx² + dy². Games use it for range checks and collisions, graphics code for circles and lighting, and data science for Euclidean distance between records with many features.

Distance between two points on screen

Every point on a screen has an x coordinate and a y coordinate. The horizontal and vertical differences between two points are perpendicular, so they are the legs of a right triangle and the distance is the hypotenuse. This is the distance formula in code:

// JavaScript
const dx = enemy.x - player.x;
const dy = enemy.y - player.y;
const distance = Math.hypot(dx, dy);   // same value as Math.sqrt(dx * dx + dy * dy)

# Python 3.8+
import math
distance = math.hypot(ex - px, ey - py)
distance = math.dist((px, py), (ex, ey))   # same thing, from two points

For a player at (120, 340) and an enemy at (300, 100), dx = 180 and dy = −240, so the distance is √180² + (−240)² = √90,000 = 300 pixels. The minus sign does not matter, because squaring makes every difference positive. That is also why it does not matter that screen y coordinates usually grow downward, or which point you subtract from which. To check a pair of points by hand, use the distance formula calculator.

Range checks without the square root

Games run distance checks thousands of times per frame: is the enemy close enough to attack, is the coin close enough to collect, which tower should fire? Since both sides of d ≤ r are positive, you can square them without changing the answer:

function inRange(a, b, r) {
  const dx = b.x - a.x, dy = b.y - a.y;
  return dx * dx + dy * dy <= r * r;   // no square root needed
}

Square roots are fast on modern hardware, but in a loop over thousands of objects every saved operation adds up, and the squared version is simpler. Game engines expose it directly; Unity, for example, offers sqrMagnitude next to magnitude. The same idea works for sorting: ordering objects by d² gives exactly the same order as ordering by d, because squaring never changes the order of non-negative numbers.

Circle collisions

Two circles overlap when the distance between their centers is no more than the sum of their radii. Collision code for balls, bullets, characters and planets usually starts with exactly this test, again in squared form.

function circlesOverlap(a, b) {
  const dx = b.x - a.x, dy = b.y - a.y;
  const rSum = a.r + b.r;
  return dx * dx + dy * dy <= rSum * rSum;
}

circlesOverlap({ x: 50, y: 80, r: 20 }, { x: 85, y: 100, r: 25 });   // true

To respond to the collision you do need the real distance, because you push the circles apart along the line between their centers. Dividing dx and dy by d gives a unit vector, a direction of length 1:

const d = Math.hypot(dx, dy);          // 40.31 in the example (check d > 0 first)
const overlap = rSum - d;              // 4.69 px
const nx = dx / d, ny = dy / d;        // unit vector from a toward b
b.x += nx * overlap;                   // move b out until the circles just touch
b.y += ny * overlap;

Collision tests in 3D add a dz² term, the 3D version of the theorem. Many collision systems also wrap complicated shapes in invisible "bounding spheres" so that this cheap test can rule out most pairs before any expensive check runs.

Diagonal movement: the √2 bug

A classic beginner bug: the player moves 1 unit per frame right and 1 unit per frame up, so holding both keys moves the player along the diagonal of a unit square. That diagonal has length √1² + 1² = √2 ≈ 1.414, the 45-45-90 triangle again, so diagonal movement is about 41% faster than straight movement.

The fix is to normalize the input: divide it by its own length so that every direction has length 1.

let mx = (keys.right ? 1 : 0) - (keys.left ? 1 : 0);
let my = (keys.down ? 1 : 0) - (keys.up ? 1 : 0);
const len = Math.hypot(mx, my);
if (len > 0) { mx /= len; my /= len; }    // (1, -1) becomes (0.707, -0.707)
player.x += mx * speed * dt;
player.y += my * speed * dt;

Math.hypot versus the naive formula

Computers store most decimals as 64-bit floating-point numbers, which can hold values up to about 1.8 × 10³⁰⁸ and down to about 5 × 10⁻³²⁴. Squaring a large number can overflow to infinity, and squaring a tiny one can underflow to zero, even when the final distance is perfectly ordinary. Math.hypot in JavaScript and math.hypot in Python rescale internally to avoid this.

// JavaScript
const x = 1e200;
Math.sqrt(x * x + x * x);   // Infinity   (x * x overflows)
Math.hypot(x, x);           // 1.414213562373095e+200

const s = 1e-200;
Math.sqrt(s * s + s * s);   // 0          (s * s underflows)
Math.hypot(s, s);           // 1.414213562373095e-200

# Python
import math
x = 1e200
math.sqrt(x * x + x * x)    # inf
x ** 2                      # raises OverflowError
math.hypot(x, x)            # 1.414213562373095e+200

For game coordinates measured in pixels or meters, overflow never happens and either form is fine; the plain formula can even be faster in some engines, because Math.hypot does extra work to stay safe. Use hypot for scientific data, values from users or files, or any time the magnitudes could be extreme. Both functions accept more than two arguments for 3D and higher.

Floating-point pitfalls

Floating-point numbers store most decimals only approximately, because they are written in binary. Small rounding errors are usually harmless, but they break exact comparisons.

Checking for a right triangle with decimals

The sides 0.5, 1.2 and 1.3 form a right triangle (the 5-12-13 triangle scaled by 0.1), yet the obvious test fails:

0.5 * 0.5 + 1.2 * 1.2 === 1.3 * 1.3;   // false: 1.69 versus 1.6900000000000002

const close = (p, q, tol = 1e-9) =>
  Math.abs(p - q) <= tol * Math.max(1, Math.abs(p), Math.abs(q));
close(0.5 ** 2 + 1.2 ** 2, 1.3 ** 2);   // true

Python has this built in as math.isclose. Compare with a tolerance whenever the inputs are decimals or measurements. To test a set of side lengths without writing any code, use the right triangle checker.

Whole numbers: exact, up to a limit

JavaScript numbers represent every integer exactly only up to 2⁵³ − 1 = 9,007,199,254,740,991. The test a * a + b * b === c * c is reliable while every side is below about 94 million, so that c² stays under that limit. Beyond it, use BigInt:

const a = 2000001, b = 2000002000000, c = 2000002000001;   // a genuine triple
a * a + b * b === c * c;                                // false: squares too big
BigInt(a) ** 2n + BigInt(b) ** 2n === BigInt(c) ** 2n;  // true

Python integers never overflow, and math.isqrt gives an exact integer square root, which makes it the easy choice for searching for Pythagorean triples (or let the triples generator do it for you):

import math

def is_right_triangle(a, b, c):       # whole-number sides, c the longest
    return a * a + b * b == c * c       # exact for any size of integer

def is_perfect_square(n):
    r = math.isqrt(n)                   # exact, no floating point involved
    return r * r == n

Square roots of tiny negative numbers

Finding a leg means computing √c² − b². If b and c are equal in theory but rounded differently, the difference can come out as a tiny negative number, and the square root of a negative number is NaN ("not a number"):

const c = 0.3, b = 0.1 * 3;             // b is actually 0.30000000000000004
Math.sqrt(c * c - b * b);               // NaN, because c*c - b*b is about -2.8e-17
Math.sqrt(Math.max(0, c * c - b * b));  // 0

Euclidean distance in data science

A row of data with n numeric features is a point in n-dimensional space, and the theorem extends to any number of dimensions. The Euclidean distance between points p and q is

The k-nearest neighbors method (k-NN) classifies or recommends by finding the k stored points closest to a new one. Here three friends and you have rated the same three films from 1 to 5:

import math

friends = {"Ana": (4, 2, 4), "Ben": (1, 5, 2), "Cy": (3, 3, 5)}
you = (5, 1, 4)

ranked = sorted(friends, key=lambda name: math.dist(you, friends[name]))
print(ranked)   # ['Ana', 'Cy', 'Ben']

The distances are √1 + 1 + 0 ≈ 1.41 to Ana, √4 + 4 + 1 = 3 to Cy and √16 + 16 + 4 = 6 to Ben, so Ana is your nearest neighbor and her other favorites are the best guesses for you.

The mathematics behind this, including why "perpendicular" still makes sense in 100 dimensions, is on the page about the theorem in n dimensions.

Color distance

An RGB color is three numbers from 0 to 255, so it is a point in a 3D cube, and the distance between two colors is a 3D Pythagorean distance:

function rgbDistance([r1, g1, b1], [r2, g2, b2]) {
  return Math.hypot(r1 - r2, g1 - g2, b1 - b2);
}
rgbDistance([255, 0, 0], [200, 30, 30]);    // about 69.46
rgbDistance([0, 0, 0], [255, 255, 255]);    // about 441.67, the maximum (255√3)

This is good enough for simple jobs like reducing an image to a palette, but equal RGB distances do not look equally different to human eyes. For perceptual work, colors are first converted to the CIELAB color space, where the original color-difference formula, CIE76 ΔE, is again a plain Euclidean distance; later formulas such as CIEDE2000 add corrections.

More places it hides in code

• Drawing circles. A pixel (x, y) is inside a circle when (x − c_x)² + (y − c_y)² ≤ r², the equation of a circle used as a test.
• Pathfinding. The A* algorithm needs an estimate of the remaining distance to the goal. When units can move in any direction, the straight-line distance is a common choice, because no path can be shorter than it; on grids with only four directions, programmers usually switch to the "Manhattan" distance |dx| + |dy|.
• Maps and GPS. Map software often approximates short distances with a flat-map version of the theorem and uses spherical formulas over long ones, and GPS receivers model every satellite range as a 3D distance; see the navigation page.
• Lighting and physics. Normalizing surface directions, measuring light falloff and computing gravity between bodies all start with a vector length, as on the physics page.