C Math hypot() Function

What You’ll Learn

The hypot() function computes √(x² + y²)—the hypotenuse of a right triangle with legs x and y. It is the standard way to measure 2D distance in graphics, games, and geometry, with built-in protection against overflow.

Definition and Usage

The Pythagorean theorem says that for a right triangle with legs x and y, the hypotenuse is √(x² + y²). In C, hypot(x, y) computes this directly.

Geometrically, hypot(x, y) is the straight-line distance from the origin (0, 0) to the point (x, y). For two points (x₁, y₁) and (x₂, y₂), use hypot(x2 - x1, y2 - y1).

📝 Syntax

Standard C declaration:

double hypot(double x, double y);

Related variants

float hypotf(float x, float y);           /* <math.h> */
long double hypotl(long double x, long double y); /* <math.h> */

Parameters

• x — first leg (horizontal offset or x-coordinate).
• y — second leg (vertical offset or y-coordinate).

Return Value

• √(x² + y²) as a non-negative double.
• hypot(3, 4) returns 5.0.
• hypot(0, y) returns |y|; hypot(x, 0) returns |x|.

Headers and linking

• #include <math.h>
• Compile: gcc hypot.c -std=c11 -o hypot -lm

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. Distance calculations appear constantly in graphics and collision detection.

#include <math.h>
#include <stdio.h>

int main(void) {
    double side1 = 3.0;
    double side2 = 4.0;
    double h = hypot(side1, side2);

    printf("Legs: %.1f and %.1f\n", side1, side2);
    printf("Hypotenuse: %.1f\n", h);

    return 0;
}

Legs: 3.0 and 4.0
Hypotenuse: 5.0

#include <math.h>
#include <stdio.h>

int main(void) {
    double x1 = 1.0, y1 = 2.0;
    double x2 = 4.0, y2 = 6.0;
    double dx = x2 - x1;
    double dy = y2 - y1;
    double dist = hypot(dx, dy);

    printf("Point A: (%.0f, %.0f)\n", x1, y1);
    printf("Point B: (%.0f, %.0f)\n", x2, y2);
    printf("Distance: %.1f\n", dist);

    return 0;
}

Point A: (1, 2)
Point B: (4, 6)
Distance: 5.0

#include <math.h>
#include <stdio.h>

int main(void) {
    printf("hypot( 3,  4) = %.1f\n", hypot( 3.0,  4.0));
    printf("hypot(-3,  4) = %.1f\n", hypot(-3.0,  4.0));
    printf("hypot( 3, -4) = %.1f\n", hypot( 3.0, -4.0));
    printf("hypot(-3, -4) = %.1f\n", hypot(-3.0, -4.0));

    return 0;
}

hypot( 3,  4) = 5.0
hypot(-3,  4) = 5.0
hypot( 3, -4) = 5.0
hypot(-3, -4) = 5.0

#include <math.h>
#include <stdio.h>

int main(void) {
    printf("hypot(0,  7) = %.1f\n", hypot(0.0,  7.0));
    printf("hypot(0, -7) = %.1f\n", hypot(0.0, -7.0));
    printf("hypot(5,  0) = %.1f\n", hypot(5.0,  0.0));

    return 0;
}

hypot(0,  7) = 7.0
hypot(0, -7) = 7.0
hypot(5,  0) = 5.0

#include <math.h>
#include <stdio.h>

int main(void) {
    double x = 3.0;
    double y = 4.0;
    double manual = sqrt(x * x + y * y);
    double library = hypot(x, y);

    printf("sqrt(x*x + y*y) = %.6f\n", manual);
    printf("hypot(x, y)     = %.6f\n", library);

    return 0;
}

sqrt(x*x + y*y) = 5.000000
hypot(x, y)     = 5.000000

🚀 Common Use Cases

• Graphics and games — distance between sprites, click points, or enemies.
• Collision detection — circular hit radius checks.
• GPS / mapping — approximate planar distance from coordinate deltas.
• Physics — vector magnitude in 2D simulations.
• Geometry homework — right-triangle side calculations.

📝 Notes

• Computes √(x² + y²), always non-negative.
• Sign of x and y does not affect the result.
• Designed to avoid overflow/underflow vs naive squaring.
• For 1D distance on a line, fabs(a - b) is enough.
• 3D distance: some platforms offer non-standard helpers; otherwise combine two hypot calls carefully.
• Link with -lm on GCC/Clang Unix-like builds.

⚡ Optimization

hypot() costs more than a few multiplications but buys numerical stability. In inner loops comparing squared distances, some games compare dx*dx + dy*dy < r*r to skip sqrt—but when you need the actual length, use hypot or sqrt of the summed squares only if values are known small.

💡 Best Practices