C Math atan2() Function

What You’ll Learn

The atan2() function computes the angle from (0, 0) to a point (x, y) in the plane. It is the go-to C function for graphics, robotics, and game development when you need a direction angle that respects all four quadrants and handles x = 0 safely.

Definition and Usage

atan2(y, x) returns the counterclockwise angle θ (in radians) from the positive x-axis to the ray through (x, y). Equivalently, it is the arc tangent of y/x with the signs of both arguments used to select the correct quadrant.

If you only know the slope y/x, atan(y/x) loses quadrant information. atan2 keeps y and x separate so (-1, -1) and (1, 1) produce different angles even though their ratios are equal.

📝 Syntax

Standard C declaration:

double atan2(double y, double x);

Related variants

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

Parameters

• y — y-coordinate (vertical component, “rise”).
• x — x-coordinate (horizontal component, “run”).

Return Value

• Angle in radians in the range (−π, π].
• atan2(0, 1) returns 0 (point on positive x-axis).
• atan2(1, 0) returns π/2 (point straight up).
• atan2(0, 0) is implementation-defined—avoid in production.

Headers and linking

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

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. atan2 is one of the most practical functions in <math.h>.

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

int main(void) {
    double y = 1.0;
    double x = 1.0;
    double rad = atan2(y, x);
    double deg = rad * 180.0 / M_PI;

    printf("atan2(%.1f, %.1f) = %.6f radians\n", y, x, rad);
    printf("atan2(%.1f, %.1f) = %.1f degrees\n", y, x, deg);

    return 0;
}

atan2(1.0, 1.0) = 0.785398 radians
atan2(1.0, 1.0) = 45.0 degrees

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

int main(void) {
    struct { double x, y; const char *name; } pts[] = {
        { 1,  1, "Q1 (+,+)" },
        { -1,  1, "Q2 (-,+)" },
        { -1, -1, "Q3 (-,-)" },
        {  1, -1, "Q4 (+,-)" }
    };
    size_t i;

    for (i = 0; i < 4; i++) {
        double deg = atan2(pts[i].y, pts[i].x) * 180.0 / M_PI;
        printf("%s  atan2(%.0f,%.0f) = %.1f deg\n",
               pts[i].name, pts[i].y, pts[i].x, deg);
    }

    return 0;
}

Q1 (+,+)  atan2(1,1) = 45.0 deg
Q2 (-,+)  atan2(1,-1) = 135.0 deg
Q3 (-,-)  atan2(-1,-1) = -135.0 deg
Q4 (+,-)  atan2(-1,1) = -45.0 deg

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

int main(void) {
    double x = -4.0, y = -3.0;

    printf("Point (%.0f, %.0f), slope y/x = %.2f\n", x, y, y / x);
    printf("atan(y/x)  = %.2f rad (%.1f deg)\n",
           atan(y / x), atan(y / x) * 180.0 / M_PI);
    printf("atan2(y,x) = %.2f rad (%.1f deg)\n",
           atan2(y, x), atan2(y, x) * 180.0 / M_PI);

    return 0;
}

Point (-4, -3), slope y/x = 0.75
atan(y/x)  = 0.64 rad (36.9 deg)
atan2(y,x) = -2.50 rad (-143.1 deg)

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

int main(void) {
    double px = 10.0, py = 20.0;
    double tx = 50.0, ty = 35.0;
    double dx = tx - px;
    double dy = ty - py;
    double aim_deg = atan2(dy, dx) * 180.0 / M_PI;

    printf("Player (%.0f, %.0f) -> Target (%.0f, %.0f)\n", px, py, tx, ty);
    printf("Aim angle = %.1f degrees\n", aim_deg);

    return 0;
}

Player (10, 20) -> Target (50, 35)
Aim angle = 20.6 degrees

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

int main(void) {
    printf("atan2( 5, 0) = %.4f rad (%.1f deg)\n",
           atan2(5.0, 0.0), atan2(5.0, 0.0) * 180.0 / M_PI);
    printf("atan2(-5, 0) = %.4f rad (%.1f deg)\n",
           atan2(-5.0, 0.0), atan2(-5.0, 0.0) * 180.0 / M_PI);

    return 0;
}

atan2( 5, 0) = 1.5708 rad (90.0 deg)
atan2(-5, 0) = -1.5708 rad (-90.0 deg)

🚀 Common Use Cases

• 2D game graphics — rotate a sprite to face a target.
• Robotics — heading angle from wheel odometry deltas.
• Touch and mouse input — angle from center of joystick to touch point.
• Navigation — bearing between two GPS-style coordinates.
• Vector math — convert (x, y) components to polar angle.

📝 Notes

• Argument order is atan2(y, x)—y first, not x first.
• Prefer atan2 over atan(y/x) for coordinates.
• Output range is (−π, π], not limited to [−π/2, π/2] like atan.
• atan2(0, 0) is implementation-defined—guard against zero length.
• Link with -lm when using GCC/Clang on Unix-like systems.

⚡ Optimization

atan2() is highly optimized in standard math libraries. It avoids the extra division and branch logic you would write by hand with atan(y/x). For hot loops with float data, use atan2f() to match your precision.

💡 Best Practices