Dokumentacja C z przykładami: Funkcje matematyczne

Q: Jak używać funkcji matematycznych w C?

Dodaj #include na początku pliku i wywołuj je: sqrt(16.0), pow(2.0, 10.0), fabs(-3.5). Przyjmują i zwracają double. Na Linuksie trzeba też dolinkować bibliotekę matematyczną przez -lm: gcc program.c -o program -lm.

Q: Czym różni się abs od fabs w C?

abs() z przyjmuje int i zwraca int. fabs() z przyjmuje double i zwraca double. Wywołanie abs(-3.7) najpierw zamienia argument na int i daje 3, po cichu odrzucając część ułamkową. Dla wartości zmiennoprzecinkowych używaj fabs.

Q: Jak sprawdzić NaN w C?

Użyj isnan(x) z . Nie da się tego sprawdzić przez x == NAN, bo NaN jest różne od wszystkiego, łącznie z samym sobą. Ta osobliwość to zresztą test zapasowy: x != x jest prawdą tylko dla NaN. Do nieskończoności używaj isinf(x), a isfinite(x) sprawdza, czy to zwykła liczba.

Sam język C daje ci + - * / i %, i nic więcej: nie ma operatora potęgowania, pierwiastka ani zaokrąglania. Wszystko poza arytmetyką leży w standardowej bibliotece matematycznej, zadeklarowanej w <math.h>.

Wszystkie te funkcje działają z precyzją double: przyjmują argumenty double i zwracają double. To pierwsza rzecz do zapamiętania, bo przekazanie int działa po cichu (następuje konwersja), a przypisanie wyniku do int po cichu odrzuca część ułamkową.

Pierwsze kroki i flaga -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;
}

Na twoim komputerze kompilacja tego kodu może się nie udać:

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

To najczęstsze potknięcie z math.h i nie jest to błąd w twoim kodzie. Nagłówek dostarczył deklaracje, więc kompilator był zadowolony; implementacje leżą w osobnej bibliotece (libm), której linker na Linuksie domyślnie nie dołącza. Dodaj -lm:

gcc program.c -o program -lm

Flaga musi stać po plikach źródłowych: linkery przetwarzają wejścia po kolei, a biblioteka podana przed kodem, który jej potrzebuje, niczego nie rozwiąże. Na macOS i z MinGW na Windows funkcje matematyczne są już częścią standardowej biblioteki C, więc -lm jest zbędne (choć na macOS nieszkodliwe).

Potęgi i pierwiastki

#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));   /* pierwiastek kwadratowy */
    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));      /* pierwiastek sześcienny */
    printf("hypot(3, 4)    = %.4f\n", hypot(3.0, 4.0)); /* sqrt(3*3+4*4) */
    return 0;
}

sqrt(x) z liczby ujemnej zwraca NaN, zamiast się wysypać; zabezpiecz argument, jeśli może być ujemny. hypot warto znać, bo oblicza tę samą wartość co sqrt(x*x + y*y) bez przepełnienia, gdy x albo y jest bardzo duże.

Dla małych potęg całkowitych zwykłe mnożenie jest i szybsze, i dokładne: x * x wygrywa z pow(x, 2.0), które przechodzi przez logarytmy i może zwrócić 8.999999999999998 tam, gdzie spodziewasz się 9.

Zaokrąglanie: floor, ceil, round, trunc

Cztery funkcje, cztery różne odpowiedzi dla liczb ujemnych. Tę tabelę warto zapamiętać:

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

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

    printf("liczba  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): największa liczba całkowita nie większa niż x. Zawsze przesuwa w stronę minus nieskończoności: floor(-2.3) to -3.
ceil(x): najmniejsza liczba całkowita nie mniejsza niż x. Zawsze przesuwa w stronę plus nieskończoności: ceil(-2.3) to -2.
round(x): najbliższa liczba całkowita, połówki od zera: round(2.5) to 3, round(-2.5) to -3.
trunc(x): obcina część ułamkową, przesuwając w stronę zera: trunc(-2.7) to -2.

Wszystkie cztery zwracają double. Rzutowanie na int, gdy potrzebujesz liczby całkowitej, jest w porządku, ale pamiętaj, że samo (int)x obcina, więc (int)(x + 0.5) to stary idiom "zaokrąglania", który jest błędny dla liczb ujemnych. Używaj round().

fabs i fmod

fabs to wartość bezwzględna dla liczb zmiennoprzecinkowych. Sięgnięcie zamiast niej po abs to klasyczny błąd, bo abs przyjmuje int, a konwersja dzieje się po cichu:

#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   <- czesc ulamkowa przepadla\n", abs((int)x));

    /* fmod: reszta z dzielenia zmiennoprzecinkowego */
    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;
}

% w ogóle nie działa na double: to operator całkowity i kompilator go odrzuci. fmod(a, b) to jego odpowiednik zmiennoprzecinkowy i zachowuje znak a.

fabs to też właściwy sposób porównywania dwóch liczb double, bo == na liczbach zmiennoprzecinkowych to pułapka:

#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) ? "tak" : "nie");
    printf("a to %.20f\n", a);
    printf("wystarczy blisko? %s\n", (fabs(a - b) < 1e-9) ? "tak" : "nie");
    return 0;
}

0.1 i 0.2 nie dają się dokładnie zapisać binarnie, więc ich suma różni się od 0.3 o włos. Porównuj z tolerancją, nigdy przez ==.

Trygonometria

Funkcje trygonometryczne działają w radianach, a nie stopniach, i to drugie niezawodne źródło złych odpowiedzi.

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

    /* funkcje odwrotne zwracają radiany */
    printf("asin(0.5)   = %.4f rad = %.1f st.\n",
           asin(0.5), asin(0.5) * 180.0 / PI);

    /* atan2 zna ćwiartkę, samo atan nie */
    printf("atan2(1, 1) = %.4f rad = %.1f st.\n",
           atan2(1.0, 1.0), atan2(1.0, 1.0) * 180.0 / PI);
    return 0;
}

Pełny zestaw: sin, cos, tan, ich odwrotności asin, acos, atan, dwuargumentowe atan2(y, x) i rodzina hiperboliczna sinh, cosh, tanh. Do kątów wybieraj atan2(y, x) zamiast atan(y / x): obsługuje x == 0 i poprawnie ustala ćwiartkę.

math.h w większości systemów definiuje M_PI, ale to rozszerzenie POSIX, a nie standardowe C, więc przy -std=c17 może go brakować. Zdefiniowanie własnej stałej, jak powyżej, jest przenośne.

Logarytmy i funkcje wykładnicze

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

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

    /* logarytm o dowolnej podstawie b: log(x) / log(b) */
    printf("log o podstawie 3 z 81 = %.4f\n", log(81.0) / log(3.0));
    return 0;
}

Zwróć uwagę na pułapkę w nazewnictwie: log() to logarytm naturalny (podstawa e), a nie dziesiętny. Podstawa 10 to log10().

log(0.0) zwraca minus nieskończoność, a log(-1.0) zwraca NaN. Żadne z nich nie powoduje awarii, więc zły argument po cichu wędruje przez obliczenia, aż coś wypisze nan.

INFINITY, NAN i ich sprawdzanie

Liczby zmiennoprzecinkowe mają wartości, które nie są liczbami, a math.h nadaje im nazwy:

#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 jest różne od wszystkiego, łącznie z samym sobą */
    printf("nan_val == nan_val ? %s\n", (nan_val == nan_val) ? "tak" : "nie");
    return 0;
}

Kluczowa jest ostatnia linia. Nie możesz napisać if (x == NAN), bo to zawsze fałsz. Użyj isnan(x). (Tożsamość x != x jest prawdziwa tylko dla NaN; często tak właśnie implementuje się isnan i to przydatne wyjście awaryjne, gdyby kiedyś trafił się zestaw narzędzi bez tej funkcji.)

Nieskończoności biorą się z przepełnienia (exp(1000.0)) i z dzielenia niezerowej liczby double przez zero, które w odróżnieniu od całkowitego dzielenia przez zero jest zdefiniowane i nie powoduje awarii.

Warianty float i long double

Każda funkcja ma trzy formy: wersję double, wersję float z przyrostkiem f i wersję long double z przyrostkiem l.

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

Używaj zwykłych wersji double, chyba że masz zmierzony powód, żeby tego nie robić: C domyślnie promuje do double, a wplatanie wariantów float zwykle kosztuje więcej na konwersjach, niż oszczędza. Przyrostek ma znaczenie w jednym miejscu: gdy obliczenia wyłącznie na float są krytyczne dla wydajności na sprzęcie bez obsługi double.

Praktyczny przykład

Kilka z tych funkcji razem: odległość między dwoma punktami i pierwiastki równania kwadratowego:

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

    /* Rozwiąż 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("Dwa pierwiastki: %.4f i %.4f\n",
               (-b + root) / (2 * a), (-b - root) / (2 * a));
    } else if (fabs(disc) < 1e-12) {
        printf("Jeden podwojny pierwiastek: %.4f\n", -b / (2 * a));
    } else {
        printf("Brak pierwiastkow rzeczywistych (wyroznik %.4f)\n", disc);
    }
    return 0;
}

Zauważ fabs(disc) < 1e-12 zamiast disc == 0.0: ta sama zasada tolerancji co wcześniej, zastosowana tam, gdzie wyróżnik obliczony z mierzonych wartości prawie nigdy nie wypadnie dokładnie na zerze.

<math.h> to jeden nagłówek z większego zestawu narzędzi; resztę opisuje strona o bibliotece standardowej, a strona o liczbach losowych omawia rand, które leży w <stdlib.h>, a nie tutaj.

Najczęściej zadawane pytania

Jak używać funkcji matematycznych w C?

Dodaj #include <math.h> na początku pliku i wywołuj je: sqrt(16.0), pow(2.0, 10.0), fabs(-3.5). Przyjmują i zwracają double. Na Linuksie trzeba też dolinkować bibliotekę matematyczną przez -lm: gcc program.c -o program -lm.

Skąd błąd 'undefined reference to sqrt' przy kompilacji?

Nagłówek dał kompilatorowi deklarację, ale implementacja leży w osobnej bibliotece, której linker na Linuksie nie dołącza automatycznie. Dodaj -lm na końcu polecenia: gcc program.c -o program -lm. Na macOS i z MinGW na Windows kod matematyczny jest częścią standardowej biblioteki C, więc flaga nie jest potrzebna.

Czym różni się abs od fabs w C?

abs() z <stdlib.h> przyjmuje int i zwraca int. fabs() z <math.h> przyjmuje double i zwraca double. Wywołanie abs(-3.7) najpierw zamienia argument na int i daje 3, po cichu odrzucając część ułamkową. Dla wartości zmiennoprzecinkowych używaj fabs.

Jak sprawdzić NaN w C?

Użyj isnan(x) z <math.h>. Nie da się tego sprawdzić przez x == NAN, bo NaN jest różne od wszystkiego, łącznie z samym sobą. Ta osobliwość to zresztą test zapasowy: x != x jest prawdą tylko dla NaN. Do nieskończoności używaj isinf(x), a isfinite(x) sprawdza, czy to zwykła liczba.

Powiązane zagadnienia