C Math cos() Function

What You’ll Learn

The cos() function computes the cosine of an angle. In C, the angle must be in radians. The result is always between −1 and 1—perfect for waves, rotations, and graphics.

Definition and Usage

Cosine relates an angle to a ratio on a right triangle: adjacent ÷ hypotenuse. On the unit circle (radius 1), cos(θ) is simply the x-coordinate at angle θ.

In C, cos(x) expects x in radians. One full turn is 2π radians (360°). Half a turn is π radians (180°).

📝 Syntax

Standard C declaration:

double cos(double x);

Related variants

float cosf(float x);           /* <math.h> */
long double cosl(long double x); /* <math.h> */

Parameters

• x — angle in radians.

Return Value

• Cosine of x, in the range [−1, 1].
• cos(0) returns 1.0; cos(M_PI / 2) returns 0.0.
• cos(M_PI) returns -1.0.

Headers and linking

• #include <math.h>
• Compile: gcc cos.c -std=c11 -o cos -lm
• On MSVC, define _USE_MATH_DEFINES before <math.h> for M_PI.

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. All angles below are converted to radians before calling cos().

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

int main(void) {
    double degrees = 60.0;
    double radians = degrees * M_PI / 180.0;
    double result = cos(radians);

    printf("Angle:   %.1f degrees (%.4f radians)\n", degrees, radians);
    printf("cos() =  %.3f\n", result);

    return 0;
}

Angle:   60.0 degrees (1.0472 radians)
cos() =  0.500

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

int main(void) {
    printf("cos(0) = %.1f\n", cos(0.0));

    return 0;
}

cos(0) = 1.0

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

static double deg_to_rad(double degrees) {
    return degrees * M_PI / 180.0;
}

int main(void) {
    double angles[] = { 0.0, 30.0, 45.0, 60.0, 90.0 };
    size_t i;

    printf(" deg    cos()\n");
    for (i = 0; i < 5; i++) {
        double rad = deg_to_rad(angles[i]);
        printf("%4.0f  %6.3f\n", angles[i], cos(rad));
    }

    return 0;
}

 deg    cos()
   0   1.000
  30   0.866
  45   0.707
  60   0.500
  90   0.000

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

int main(void) {
    double radius = 100.0;
    double angle_deg = 45.0;
    double angle_rad = angle_deg * M_PI / 180.0;
    double x = radius * cos(angle_rad);
    double y = radius * sin(angle_rad);

    printf("Angle: %.0f degrees\n", angle_deg);
    printf("Point on circle (r=%.0f): (%.2f, %.2f)\n", radius, x, y);

    return 0;
}

Angle: 45 degrees
Point on circle (r=100): (70.71, 70.71)

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

int main(void) {
    double angles[] = { 0.0, M_PI / 2, M_PI };
    const char *labels[] = { "0", "pi/2", "pi" };
    size_t i;

    printf(" angle   cos()   sin()\n");
    for (i = 0; i < 3; i++) {
        printf(" %5s  %5.1f  %5.1f\n",
               labels[i], cos(angles[i]), sin(angles[i]));
    }

    return 0;
}

 angle   cos()   sin()
     0    1.0    0.0
  pi/2    0.0    1.0
    pi   -1.0    0.0

🚀 Common Use Cases

• Graphics and games — rotate sprites, orbit cameras, place objects on circles.
• Signal processing — model periodic waves (sound, AC voltage).
• Physics — resolve forces into horizontal components.
• Robotics — compute joint positions from angles.
• Pair with sin() — full 2D position from a single angle and radius.

📝 Notes

• Input is radians, not degrees—convert with degrees * M_PI / 180.0.
• Output is always in [−1, 1].
• cos() is an even function: cos(-x) == cos(x).
• Link with -lm when using GCC/Clang on Unix-like systems.
• Do not confuse cos() with cosh() (hyperbolic cosine).
• For very large angles, floating-point precision can affect results—consider reducing the angle modulo 2π if needed.

⚡ Optimization

cos() is implemented in the platform math library and is typically fast enough for most applications. If you call it thousands of times per frame in a game loop, profile first—often the bottleneck is elsewhere. For fixed small angle sets, a lookup table can help, but prefer the library function until profiling proves otherwise.

💡 Best Practices