C Standard Library math.h

What You’ll Learn

The <math.h> header is the standard math library for C: trigonometry, powers, roots, logarithms, rounding, and more. Most functions take and return double. You include the header and link with -lm on GCC—a step the old reference omitted from its compile instructions.

Definition and Usage

<math.h> declares functions declared in the C standard for real floating-point math. They operate on double by default; float variants end in f (sinf, sqrtf) and long double variants end in l (sinl, sqrtl).

Trigonometric functions expect radians, not degrees. Invalid inputs (like sqrt(-1)) can return NaN and set errno to EDOM. Huge results may set ERANGE.

📝 Syntax

Include the header:

#include <math.h>

Common functions by category

• Trigonometry — sin, cos, tan, asin, acos, atan, atan2 (radians).
• Hyperbolic — sinh, cosh, tanh.
• Power / root — pow, sqrt, cbrt (C99).
• Exponential / log — exp, log, log10, log2 (C99).
• Rounding — floor, ceil, round, trunc (C99).
• Utility — fabs, fmod, hypot, fmax, fmin (C99).

Common macros (C99)

• HUGE_VAL, INFINITY, NAN — special values.
• FP_NAN, FP_INFINITE, isnan, isfinite — classification.
• M_PI — often available as an extension (not strict ISO C); use acos(-1.0) if missing.

Typical declarations

double sin(double x);
double cos(double x);
double sqrt(double x);
double pow(double base, double exp);
double fabs(double x);
double log(double x);
double exp(double x);

Headers and linking

• #include <math.h>
• GCC/Clang: gcc program.c -std=c11 -lm -o program
• Errors: #include <errno.h> for EDOM / ERANGE
• Limits: #include <float.h> for DBL_MAX, etc.

Examples Gallery

Compile every example with gcc file.c -std=c11 -lm -o out. See also the C Math Functions index for deep dives on each function.

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

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

int main(void) {
    double x = 2.0;
    double y = 8.0;
    double angle = M_PI / 4.0;  /* 45 degrees in radians */

    printf("pow(%.1f, %.1f) = %.2f\n", x, y, pow(x, y));
    printf("sqrt(%.1f) = %.2f\n", y, sqrt(y));
    printf("sin(pi/4) = %.2f\n", sin(angle));
    printf("cos(pi/4) = %.2f\n", cos(angle));
    printf("tan(pi/4) = %.2f\n", tan(angle));
    printf("log(%.1f) = %.2f\n", x, log(x));
    printf("log10(%.1f) = %.2f\n", y, log10(y));
    printf("exp(%.1f) = %.2f\n", x, exp(x));
    printf("fabs(-%.1f) = %.2f\n", x, fabs(-x));

    return 0;
}

pow(2.0, 8.0) = 256.00
sqrt(8.0) = 2.83
sin(pi/4) = 0.71
cos(pi/4) = 0.71
tan(pi/4) = 1.00
log(2.0) = 0.69
log10(8.0) = 0.90
exp(2.0) = 7.39
fabs(-2.0) = 2.00

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

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

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

int main(void) {
    double deg = 30.0;
    double rad = deg_to_rad(deg);

    printf("%.0f degrees = %.4f radians\n", deg, rad);
    printf("sin(30 deg) = %.4f\n", sin(rad));
    printf("cos(30 deg) = %.4f\n", cos(rad));

    return 0;
}

30 degrees = 0.5236 radians
sin(30 deg) = 0.5000
cos(30 deg) = 0.8660

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

int main(void) {
    double dx = 3.0;
    double dy = 4.0;

    printf("Distance from (0,0) to (%.0f,%.0f) = %.1f\n",
           dx, dy, hypot(dx, dy));

    return 0;
}

Distance from (0,0) to (3,4) = 5.0

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

int main(void) {
    double value = 7.5;
    double step = 2.0;
    double rem = fmod(value, step);

    printf("fmod(%.1f, %.1f) = %.1f\n", value, step, rem);
    printf("%.1f = %.0f * %.1f + %.1f\n",
           value, step, floor(value / step), rem);

    return 0;
}

fmod(7.5, 2.0) = 1.5
7.5 = 2 * 3.0 + 1.5

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

int main(void) {
    double values[] = { 3.2, 3.7, -2.3 };
    size_t i;

    for (i = 0; i < 3; i++) {
        double v = values[i];
        printf("x=%5.1f  floor=%.0f  ceil=%.0f  round=%.0f\n",
               v, floor(v), ceil(v), round(v));
    }

    return 0;
}

x=  3.2  floor=3  ceil=4  round=3
x=  3.7  floor=3  ceil=4  round=4
x= -2.3  floor=-3  ceil=-2  round=-2

🚀 Common Use Cases

• Graphics & games — sin/cos for rotation, hypot for distance.
• Science & engineering — pow, log, exp for formulas and decay models.
• Finance — compound interest with pow, rounding with floor/ceil.
• Signal processing — trigonometry and fmod for phase wrapping.
• Statistics — logarithms, square roots, error functions.
• Embedded sensors — sqrtf/sinf float variants for speed.

📝 Notes

• Trig functions use radians; convert from degrees with * M_PI / 180.0.
• Link with -lm on GCC/Clang (not always needed on MSVC).
• Most functions are defined for double; use sinf for float.
• Domain errors set errno to EDOM; range errors may set ERANGE.
• M_PI is not in strict ISO C—provide a fallback #define if needed.
• For integer absolute value, use abs from <stdlib.h>, not fabs.

⚡ Optimization

libm functions are highly optimized on modern CPUs. Use float variants (sqrtf, sinf) in hot loops with large arrays when precision allows. Avoid calling heavy functions inside tight inner loops when a lookup table or approximation suffices—but for most apps, math.h is plenty fast.

💡 Best Practices