C Math acos() Function

What You’ll Learn

The acos() function computes the arc cosine (inverse cosine) of a number. Given a cosine value between −1 and 1, it returns the angle in radians whose cosine equals that value—essential for geometry, graphics, and robotics.

Definition and Usage

acos (arc cosine) answers the question: “What angle has this cosine?” If cos(θ) = x and x is between −1 and 1, then acos(x) = θ (in radians).

On a right triangle, cosine is adjacent ÷ hypotenuse. If you know those side lengths, their ratio is a valid input to acos(), and the result is the angle at the vertex between those sides.

📝 Syntax

Standard C declaration:

double acos(double x);

Related variants

float acosf(float x);           /* <math.h> */
long double acosl(long double x); /* <math.h> */

Parameters

• x — cosine value; must be in the range [−1, 1].

Return Value

• Angle in radians in the range [0, π].
• acos(1) returns 0; acos(-1) returns π.
• If |x| > 1, returns NaN and may set errno to EDOM.

Headers and linking

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

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. The -lm flag links the math library on Linux and macOS.

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

int main(void) {
    double x = 0.5;
    double angle_rad = acos(x);

    printf("The arccosine of %.1f is: %.6f radians\n", x, angle_rad);

    return 0;
}

The arccosine of 0.5 is: 1.047198 radians

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

int main(void) {
    printf("acos( 1) = %.6f radians\n", acos(1.0));
    printf("acos( 0) = %.6f radians\n", acos(0.0));
    printf("acos(-1) = %.6f radians\n", acos(-1.0));

    return 0;
}

acos( 1) = 0.000000 radians
acos( 0) = 1.570796 radians
acos(-1) = 3.141593 radians

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

int main(void) {
    double x = 0.5;
    double rad = acos(x);
    double deg = rad * 180.0 / M_PI;

    printf("acos(%.1f) = %.4f rad = %.1f degrees\n", x, rad, deg);

    return 0;
}

acos(0.5) = 1.0472 rad = 60.0 degrees

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

int main(void) {
    double adjacent = 3.0;
    double hypotenuse = 5.0;
    double cosine_ratio = adjacent / hypotenuse;
    double angle_deg = acos(cosine_ratio) * 180.0 / M_PI;

    printf("cos(theta) = %.2f / %.0f = %.2f\n",
           adjacent, hypotenuse, cosine_ratio);
    printf("theta = %.1f degrees\n", angle_deg);

    return 0;
}

cos(theta) = 3.00 / 5 = 0.60
theta = 53.1 degrees

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

int main(void) {
    double values[] = { -1.0, -0.5, 0.0, 0.5, 1.0 };
    size_t i;

    for (i = 0; i < sizeof values / sizeof values[0]; i++) {
        double x = values[i];
        double angle = acos(x);
        double back = cos(angle);

        printf("x=%5.1f  acos(x)=%.4f  cos(acos(x))=%.6f\n",
               x, angle, back);
    }

    return 0;
}

x= -1.0  acos(x)=3.1416  cos(acos(x))=-1.000000
x= -0.5  acos(x)=2.0944  cos(acos(x))=-0.500000
x=  0.0  acos(x)=1.5708  cos(acos(x))=0.000000
x=  0.5  acos(x)=1.0472  cos(acos(x))=0.500000
x=  1.0  acos(x)=0.0000  cos(acos(x))=1.000000

🚀 Common Use Cases

• Geometry — find an angle when you know two side lengths on a right triangle.
• 2D graphics — compute rotation angles from direction vectors (after normalizing).
• Robotics and physics — recover joint angles from cosine relationships in kinematics.
• Signal processing — phase calculations involving cosine components.
• Pair with cos() — use cos for forward trig and acos to reverse it.

📝 Notes

• Input must be in [−1, 1]; values outside that range produce NaN.
• Output is always in [0, π] radians—never negative, never above π.
• Link with -lm when using GCC/Clang on Unix-like systems.
• Use acosf or acosl when working with float or long double.
• Check isnan(result) after acos if input might be out of range.

⚡ Optimization

acos() is implemented in the platform math library and is already highly optimized. Avoid calling it inside tight inner loops when you can cache angles. For many graphics tasks, atan2(y, x) is more convenient than combining acos with manual quadrant fixes—but when you already have a cosine ratio, acos is the direct tool.

💡 Best Practices