Funciones matemáticas en C: math.h, sqrt, pow y el enlace con -lm

El núcleo del lenguaje C te da + - * / y %, y nada más: sin operador de potencia, sin raíz cuadrada, sin redondeo. Todo lo que va más allá de la aritmética vive en la biblioteca matemática estándar, declarada en <math.h>.

Todas estas funciones trabajan con precisión double: toman argumentos double y devuelven double. Eso es lo primero que hay que interiorizar, porque pasar un int funciona en silencio (se convierte) mientras que asignar el resultado a un int descarta la fracción en silencio.

Para empezar, y la bandera -lm

#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;
}

En tu propia máquina, compilar eso puede fallar:

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

Este es con diferencia el tropiezo más común con math.h, y no es un error de tu código. La cabecera aportó las declaraciones, así que el compilador quedó satisfecho; las implementaciones viven en una biblioteca aparte (libm) que el enlazador no incluye por defecto en Linux. Agrega -lm:

gcc program.c -o program -lm

La bandera debe ir después de los archivos fuente: los enlazadores procesan sus entradas en orden, y una biblioteca listada antes que el código que la necesita no resuelve nada. En macOS y con MinGW en Windows, las rutinas matemáticas ya son parte de la biblioteca estándar de C, así que -lm es innecesaria (aunque inofensiva en macOS).

Potencias y raíces

#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));   /* una raiz cuadrada */
    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));      /* raiz cubica */
    printf("hypot(3, 4)    = %.4f\n", hypot(3.0, 4.0)); /* sqrt(3*3+4*4) */
    return 0;
}

sqrt(x) de un número negativo devuelve NaN en lugar de reventar; protege el argumento si puede ser negativo. hypot vale la pena conocerla porque calcula el mismo valor que sqrt(x*x + y*y) sin desbordarse cuando x o y son muy grandes.

Para potencias enteras pequeñas, la multiplicación simple es más rápida y exacta: x * x le gana a pow(x, 2.0), que pasa por logaritmos y puede devolver 8.999999999999998 donde esperabas 9.

Redondeo: floor, ceil, round, trunc

Cuatro funciones, cuatro respuestas distintas para los números negativos. Esa tabla es la parte que vale la pena memorizar:

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

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

    printf("valor   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): el mayor entero que no supera a x. Siempre se mueve hacia menos infinito: floor(-2.3) es -3.
• ceil(x): el menor entero que no es menor que x. Siempre se mueve hacia más infinito: ceil(-2.3) es -2.
• round(x): el entero más cercano, con los medios alejándose del cero: round(2.5) es 3, round(-2.5) es -3.
• trunc(x): corta la parte fraccionaria, moviéndose hacia cero: trunc(-2.7) es -2.

Las cuatro devuelven un double. Convertir a int cuando quieres un entero está bien, pero fíjate en que (int)x por sí solo trunca, así que (int)(x + 0.5) es el viejo modismo de "redondear" y está mal para los números negativos. Usa round().

fabs y fmod

fabs es el valor absoluto para punto flotante. Recurrir a abs en su lugar es un error clásico, porque abs toma un int y la conversión ocurre en silencio:

#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   <- la fraccion se tiro a la basura\n", abs((int)x));

    /* fmod: el resto de una division de punto flotante */
    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;
}

% no funciona con double en absoluto: es un operador entero y el compilador lo rechaza. fmod(a, b) es su contraparte en punto flotante, y conserva el signo de a.

fabs también es la forma correcta de comparar dos doubles, ya que == sobre punto flotante es una trampa:

#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) ? "si" : "no");
    printf("a es %.20f\n", a);
    printf("suficientemente cerca? %s\n", (fabs(a - b) < 1e-9) ? "si" : "no");
    return 0;
}

0.1 y 0.2 no se pueden representar exactamente en binario, así que su suma queda a un pelo de 0.3. Compara con una tolerancia, nunca con ==.

Trigonometría

Las funciones trigonométricas trabajan en radianes, no en grados: la otra fuente fiable de respuestas equivocadas.

#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 grados) = %.4f\n", sin(DEG_TO_RAD(30.0)));
    printf("cos(60 grados) = %.4f\n", cos(DEG_TO_RAD(60.0)));
    printf("tan(45 grados) = %.4f\n", tan(DEG_TO_RAD(45.0)));

    /* las funciones inversas devuelven radianes */
    printf("asin(0.5)   = %.4f rad = %.1f grados\n",
           asin(0.5), asin(0.5) * 180.0 / PI);

    /* atan2 conoce el cuadrante; atan por si solo no */
    printf("atan2(1, 1) = %.4f rad = %.1f grados\n",
           atan2(1.0, 1.0), atan2(1.0, 1.0) * 180.0 / PI);
    return 0;
}

El conjunto completo: sin, cos, tan, sus inversas asin, acos, atan, la atan2(y, x) de dos argumentos y la familia hiperbólica sinh, cosh, tanh. Prefiere atan2(y, x) sobre atan(y / x) para los ángulos: maneja x == 0 y acierta el cuadrante.

math.h define M_PI en la mayoría de los sistemas, pero es una extensión POSIX y no C estándar, así que puede faltar bajo -std=c17. Definir tu propia constante, como arriba, es portable.

Logaritmos y exponenciales

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

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

    /* logaritmo en cualquier base b: log(x) / log(b) */
    printf("log base 3 de 81 = %.4f\n", log(81.0) / log(3.0));
    return 0;
}

Fíjate en la trampa de nomenclatura heredada de las matemáticas: log() es el logaritmo natural (base e), no el de base 10. La base 10 es log10().

log(0.0) devuelve menos infinito y log(-1.0) devuelve NaN; ninguno de los dos revienta, lo que significa que un argumento malo viaja en silencio por todo tu cálculo hasta que algo imprime nan.

INFINITY, NAN y cómo comprobarlos

El punto flotante tiene valores que no son números, y math.h les pone nombre:

#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 resulta distinto de todo, incluido el mismo */
    printf("nan_val == nan_val ? %s\n", (nan_val == nan_val) ? "si" : "no");
    return 0;
}

Esa última línea es la crucial. No puedes escribir if (x == NAN): siempre es falso. Usa isnan(x). (La identidad x != x solo es verdadera para NaN, que es como suele implementarse isnan y un recurso útil si alguna vez te topas con una cadena de herramientas que no la tenga.)

Los infinitos llegan por desbordamiento (exp(1000.0)) y por la división de un double distinto de cero entre cero, que —a diferencia de la división entera entre cero— está definida y no revienta.

Variantes float y long double

Cada función tiene tres formas: la versión double, una versión float con sufijo f y una versión long double con sufijo l.

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

Usa las versiones double a secas salvo que tengas una razón medida para no hacerlo: double es a lo que C promociona por defecto, y mezclar variantes float suele costar más en conversiones de lo que ahorra. El único lugar donde el sufijo importa es cuando un cálculo exclusivamente en float es crítico para el rendimiento en hardware sin soporte de doble precisión.

Un ejemplo práctico

Juntando varias de estas: la distancia entre dos puntos y las raíces de una ecuación cuadrática.

#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("Distancia: %.4f\n", dist);

    /* Resolver 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("Dos raices: %.4f y %.4f\n",
               (-b + root) / (2 * a), (-b - root) / (2 * a));
    } else if (fabs(disc) < 1e-12) {
        printf("Una raiz repetida: %.4f\n", -b / (2 * a));
    } else {
        printf("Sin raices reales (discriminante %.4f)\n", disc);
    }
    return 0;
}

Fíjate en fabs(disc) < 1e-12 en lugar de disc == 0.0: la misma regla de la tolerancia de antes, aplicada donde un discriminante calculado a partir de valores medidos casi nunca caerá exactamente en cero.

<math.h> es una cabecera dentro de un conjunto mayor; la página de la biblioteca estándar mapea el resto, y números aleatorios cubre rand, que vive en <stdlib.h> y no aquí.