Math Functions in C: math.h, sqrt, pow, and Linking with -lm

C's core language gives you + - * / and %, and nothing else - no power operator, no square root, no rounding. Everything beyond arithmetic lives in the standard math library, declared in <math.h>.

These functions all work in double precision: they take double arguments and return double. That is the first thing to internalize, because passing an int works silently (it is converted) while assigning the result to an int silently discards the fraction.

Getting Started, and the -lm Flag

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

int main(void) {
    printf("sqrt(144)   = %.2f\n", sqrt(144.0));
    printf("pow(2, 10)  = %.2f\n", pow(2.0, 10.0));
    printf("fabs(-7.25) = %.2f\n", fabs(-7.25));
    return 0;
}

On your own machine, compiling that may fail:

/usr/bin/ld: /tmp/ccXYZ.o: in function `main':
program.c:(.text+0x1a): undefined reference to `sqrt'
collect2: error: ld returned 1 exit status

This is the single most common stumble with math.h, and it is not a mistake in your code. The header supplied the declarations, so the compiler was satisfied; the implementations live in a separate library (libm) that the linker does not include by default on Linux. Add -lm:

gcc program.c -o program -lm

The flag must come after the source files - linkers process their inputs in order, and a library listed before the code that needs it resolves nothing. On macOS and with MinGW on Windows, the math routines are part of the standard C library already, so -lm is unnecessary (though harmless on macOS).

Powers and Roots

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

int main(void) {
    printf("pow(2, 8)      = %.0f\n", pow(2.0, 8.0));
    printf("pow(9, 0.5)    = %.4f\n", pow(9.0, 0.5));   /* a square root */
    printf("pow(2, -3)     = %.4f\n", pow(2.0, -3.0));

    printf("sqrt(2)        = %.6f\n", sqrt(2.0));
    printf("cbrt(27)       = %.4f\n", cbrt(27.0));      /* cube root */
    printf("hypot(3, 4)    = %.4f\n", hypot(3.0, 4.0)); /* sqrt(3*3+4*4) */
    return 0;
}

sqrt(x) of a negative number returns NaN rather than crashing; guard the argument if it can be negative. hypot is worth knowing because it computes the same value as sqrt(x*x + y*y) without overflowing when x or y is very large.

For small integer powers, plain multiplication is both faster and exact - x * x beats pow(x, 2.0), which goes through logarithms and can return 8.999999999999998 where you expected 9.

Rounding: floor, ceil, round, trunc

Four functions, four different answers for negative numbers. That table is the part worth memorizing:

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

int main(void) {
    double values[] = {2.3, 2.7, -2.3, -2.7};

    printf("value   floor   ceil   round   trunc\n");
    for (int i = 0; i < 4; i++) {
        double v = values[i];
        printf("%5.1f  %6.0f %6.0f  %6.0f  %6.0f\n",
               v, floor(v), ceil(v), round(v), trunc(v));
    }
    return 0;
}

• floor(x) - largest integer not greater than x. Always moves toward negative infinity: floor(-2.3) is -3.
• ceil(x) - smallest integer not less than x. Always moves toward positive infinity: ceil(-2.3) is -2.
• round(x) - nearest integer, halves away from zero: round(2.5) is 3, round(-2.5) is -3.
• trunc(x) - chop the fractional part, moving toward zero: trunc(-2.7) is -2.

All four return a double. Casting to int when you want an integer is fine, but note that (int)x on its own performs truncation - so (int)(x + 0.5) is the old "round" idiom, and it is wrong for negative numbers. Use round().

fabs and fmod

fabs is absolute value for floating point. Reaching for abs instead is a classic mistake, because abs takes an int and the conversion happens silently:

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

int main(void) {
    double x = -3.7;

    printf("fabs(-3.7) = %.2f\n", fabs(x));
    printf("abs(-3.7)  = %d   <- the fraction was thrown away\n", abs((int)x));

    /* fmod: the remainder of a floating-point division */
    printf("fmod(10.5, 3.0)  = %.2f\n", fmod(10.5, 3.0));
    printf("fmod(-10.5, 3.0) = %.2f\n", fmod(-10.5, 3.0));
    return 0;
}

% does not work on double at all - it is an integer operator and the compiler rejects it. fmod(a, b) is its floating-point counterpart, and it keeps the sign of a.

fabs is also the correct way to compare two doubles, since == on floating point is a trap:

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

int main(void) {
    double a = 0.1 + 0.2;
    double b = 0.3;

    printf("a == b ?         %s\n", (a == b) ? "yes" : "no");
    printf("a is %.20f\n", a);
    printf("close enough?    %s\n", (fabs(a - b) < 1e-9) ? "yes" : "no");
    return 0;
}

0.1 and 0.2 cannot be represented exactly in binary, so their sum is a hair away from 0.3. Compare with a tolerance, never with ==.

Trigonometry

The trig functions work in radians, not degrees - the other reliable source of wrong answers.

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

#define PI 3.14159265358979323846
#define DEG_TO_RAD(d) ((d) * PI / 180.0)

int main(void) {
    printf("sin(30 deg) = %.4f\n", sin(DEG_TO_RAD(30.0)));
    printf("cos(60 deg) = %.4f\n", cos(DEG_TO_RAD(60.0)));
    printf("tan(45 deg) = %.4f\n", tan(DEG_TO_RAD(45.0)));

    /* inverse functions return radians */
    printf("asin(0.5)   = %.4f rad = %.1f deg\n",
           asin(0.5), asin(0.5) * 180.0 / PI);

    /* atan2 knows the quadrant; atan alone does not */
    printf("atan2(1, 1) = %.4f rad = %.1f deg\n",
           atan2(1.0, 1.0), atan2(1.0, 1.0) * 180.0 / PI);
    return 0;
}

The full set: sin, cos, tan, their inverses asin, acos, atan, the two-argument atan2(y, x), and the hyperbolic family sinh, cosh, tanh. Prefer atan2(y, x) over atan(y / x) for angles - it handles x == 0 and gets the quadrant right.

math.h defines M_PI on most systems, but it is a POSIX extension rather than standard C, so it may be missing under -std=c17. Defining your own constant, as above, is portable.

Logarithms and Exponentials

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

int main(void) {
    printf("exp(1)      = %.6f   (that is e)\n", exp(1.0));
    printf("log(e)      = %.4f   (natural log)\n", log(exp(1.0)));
    printf("log10(1000) = %.4f\n", log10(1000.0));
    printf("log2(1024)  = %.4f\n", log2(1024.0));

    /* log in any base b: log(x) / log(b) */
    printf("log base 3 of 81 = %.4f\n", log(81.0) / log(3.0));
    return 0;
}

Note the naming trap carried over from mathematics: log() is the natural logarithm (base e), not base 10. Base 10 is log10().

log(0.0) returns negative infinity and log(-1.0) returns NaN - neither one crashes, which means a bad argument travels silently through your calculation until something prints nan.

INFINITY, NAN, and Checking for Them

Floating point has values that are not numbers, and math.h names them:

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

int main(void) {
    double inf = INFINITY;
    double nan_val = NAN;
    double from_bad_math = sqrt(-1.0);

    printf("inf          = %f\n", inf);
    printf("sqrt(-1)     = %f\n", from_bad_math);

    printf("isinf(inf)       = %d\n", isinf(inf));
    printf("isnan(sqrt(-1))  = %d\n", isnan(from_bad_math));
    printf("isfinite(3.14)   = %d\n", isfinite(3.14));

    /* NaN compares unequal to everything, including itself */
    printf("nan_val == nan_val ? %s\n", (nan_val == nan_val) ? "yes" : "no");
    return 0;
}

That last line is the crucial one. You cannot write if (x == NAN) - it is always false. Use isnan(x). (The identity x != x is true only for NaN, which is how isnan is often implemented and a handy fallback if you ever meet a toolchain without it.)

Infinities arrive from overflow (exp(1000.0)) and from division of a nonzero double by zero, which - unlike integer division by zero - is defined and does not crash.

float and long double Variants

Every function has three forms: the double version, an f-suffixed float version, and an l-suffixed long double version.

float       sqrtf(float x);
double      sqrt(double x);
long double sqrtl(long double x);

Use the plain double versions unless you have a measured reason not to - double is what C promotes to by default, and mixing float variants in usually costs more in conversions than it saves. The one place the suffix matters is when a float-only calculation is performance-critical on hardware without double support.

A Practical Example

Putting several of these together - the distance between two points and the roots of a quadratic:

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

int main(void) {
    double x1 = 1.0, y1 = 2.0;
    double x2 = 4.0, y2 = 6.0;

    double dist = hypot(x2 - x1, y2 - y1);
    printf("Distance: %.4f\n", dist);

    /* Solve 2x^2 - 7x + 3 = 0 */
    double a = 2.0, b = -7.0, c = 3.0;
    double disc = b * b - 4 * a * c;

    if (disc > 0) {
        double root = sqrt(disc);
        printf("Two roots: %.4f and %.4f\n",
               (-b + root) / (2 * a), (-b - root) / (2 * a));
    } else if (fabs(disc) < 1e-12) {
        printf("One repeated root: %.4f\n", -b / (2 * a));
    } else {
        printf("No real roots (discriminant %.4f)\n", disc);
    }
    return 0;
}

Notice fabs(disc) < 1e-12 rather than disc == 0.0 - the same tolerance rule as before, applied where a discriminant computed from measured values will almost never land exactly on zero.

<math.h> is one header in a larger toolkit; the standard library page maps the rest, and random numbers covers rand, which lives in <stdlib.h> rather than here.