C Math asin() Function

What You’ll Learn

The asin() function computes the arc sine (inverse sine) of a number. Given a sine value between −1 and 1, it returns the angle in radians whose sine equals that value—the mirror image of acos() for opposite-over-hypotenuse ratios.

Definition and Usage

asin (arc sine) answers: “What angle has this sine?” If sin(θ) = x and x is between −1 and 1, then asin(x) = θ (in radians, principal value).

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

📝 Syntax

Standard C declaration:

double asin(double x);

Related variants

float asinf(float x);           /* <math.h> */
long double asinl(long double x); /* <math.h> */

Parameters

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

Return Value

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

Headers and linking

• #include <math.h>
• Compile: gcc asin.c -std=c11 -o asin -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 result = asin(x);

    printf("The arc sine of %.1f is: %.6f radians\n", x, result);

    return 0;
}

The arc sine of 0.5 is: 0.523599 radians

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

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

    return 0;
}

asin(-1) = -1.570796 radians
asin( 0) = 0.000000 radians
asin( 1) = 1.570796 radians

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

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

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

    return 0;
}

asin(0.5) = 0.5236 rad = 30.0 degrees

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

int main(void) {
    double opposite = 3.0;
    double hypotenuse = 5.0;
    double sine_ratio = opposite / hypotenuse;
    double angle_deg = asin(sine_ratio) * 180.0 / M_PI;

    printf("sin(theta) = %.0f / %.0f = %.2f\n",
           opposite, hypotenuse, sine_ratio);
    printf("theta = %.1f degrees\n", angle_deg);

    return 0;
}

sin(theta) = 3 / 5 = 0.60
theta = 36.9 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 = asin(x);
        double back = sin(angle);

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

    return 0;
}

x= -1.0  asin(x)=-1.5708  sin(asin(x))=-1.000000
x= -0.5  asin(x)=-0.5236  sin(asin(x))=-0.500000
x=  0.0  asin(x)=0.0000  sin(asin(x))=0.000000
x=  0.5  asin(x)=0.5236  sin(asin(x))=0.500000
x=  1.0  asin(x)=1.5708  sin(asin(x))=1.000000

🚀 Common Use Cases

• Geometry — find an angle from opposite and hypotenuse side lengths.
• 2D graphics — compute elevation or pitch angles from normalized vectors.
• Game development — aim angles and projectile trajectories from sine components.
• Signal processing — recover phase angles from sine values.
• Pair with sin() — use sin forward and asin to reverse it.

📝 Notes

• Input must be in [−1, 1]; values outside that range produce NaN.
• Output is in [−π/2, π/2] radians—can be negative unlike acos().
• Link with -lm when using GCC/Clang on Unix-like systems.
• Use asinf or asinl for float or long double data.
• For quadrant-aware angles from (x, y), prefer atan2(y, x) over asin.

⚡ Optimization

asin() is implemented in the platform math library and is already optimized. Cache results when the same ratio is computed repeatedly. For 2D direction vectors, atan2 often avoids separate quadrant logic that a naive asin(y/hyp) approach might need.

💡 Best Practices