Ausführbare C-Docs: Mathematikfunktionen

Q: Wie benutze ich Mathematikfunktionen in C?

Setze #include an den Anfang der Datei und rufe sie auf: sqrt(16.0), pow(2.0, 10.0), fabs(-3.5). Sie nehmen double entgegen und liefern double. Unter Linux musst du zusätzlich die Mathematikbibliothek mit -lm linken: gcc program.c -o program -lm.

Q: Was ist der Unterschied zwischen abs und fabs in C?

abs() aus nimmt ein int und liefert ein int. fabs() aus nimmt ein double und liefert ein double. abs(-3.7) aufzurufen wandelt das Argument zuerst in int um und ergibt 3, wobei der Bruchteil still verworfen wird - nimm für Gleitkommawerte fabs.

Q: Wie prüfe ich in C auf NaN?

Benutze isnan(x) aus . Mit x == NAN kannst du nicht prüfen, denn NaN vergleicht sich mit allem als ungleich, auch mit sich selbst - diese Eigenheit ist tatsächlich der Ersatztest: x != x ist nur für NaN wahr. Nimm isinf(x) für Unendlichkeiten und isfinite(x), um auf eine gewöhnliche Zahl zu prüfen.

Cs Kernsprache gibt dir + - * / und %, sonst nichts - keinen Potenzoperator, keine Quadratwurzel, kein Runden. Alles jenseits der Arithmetik lebt in der Standard-Mathematikbibliothek, deklariert in <math.h>.

Diese Funktionen arbeiten alle mit double-Genauigkeit: Sie nehmen double-Argumente entgegen und liefern double. Das ist das Erste, was man verinnerlichen sollte, denn ein int zu übergeben funktioniert stillschweigend (es wird umgewandelt), während das Ergebnis einem int zuzuweisen still den Bruchteil verwirft.

Der Einstieg und das -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;
}

Auf deiner eigenen Maschine kann das Kompilieren fehlschlagen:

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

Das ist der mit Abstand häufigste Stolperstein bei math.h, und es ist kein Fehler in deinem Code. Der Header lieferte die Deklarationen, der Compiler war also zufrieden; die Implementierungen liegen in einer eigenen Bibliothek (libm), die der Linker unter Linux standardmäßig nicht einbezieht. Füge -lm hinzu:

gcc program.c -o program -lm

Das Flag muss nach den Quelldateien kommen - Linker verarbeiten ihre Eingaben der Reihe nach, und eine Bibliothek, die vor dem Code steht, der sie braucht, löst nichts auf. Unter macOS und mit MinGW unter Windows gehören die Mathematikroutinen bereits zur Standard-C-Bibliothek, -lm ist dort also unnötig (unter macOS aber harmlos).

Potenzen und Wurzeln

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

sqrt(x) einer negativen Zahl liefert NaN, statt abzustürzen; sichere das Argument ab, wenn es negativ sein kann. hypot ist wissenswert, weil es denselben Wert wie sqrt(x*x + y*y) berechnet, ohne überzulaufen, wenn x oder y sehr groß ist.

Für kleine ganzzahlige Potenzen ist schlichte Multiplikation sowohl schneller als auch exakt - x * x schlägt pow(x, 2.0), das über Logarithmen geht und 8.999999999999998 liefern kann, wo du 9 erwartet hast.

Runden: floor, ceil, round, trunc

Vier Funktionen, vier verschiedene Antworten bei negativen Zahlen. Diese Tabelle ist der merkenswerte Teil:

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

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

    printf("Wert    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) - größte ganze Zahl, die nicht größer als x ist. Bewegt sich immer Richtung negativ unendlich: floor(-2.3) ist -3.
ceil(x) - kleinste ganze Zahl, die nicht kleiner als x ist. Bewegt sich immer Richtung positiv unendlich: ceil(-2.3) ist -2.
round(x) - nächste ganze Zahl, Hälften von null weg: round(2.5) ist 3, round(-2.5) ist -3.
trunc(x) - schneidet den Bruchteil ab, Richtung null: trunc(-2.7) ist -2.

Alle vier liefern ein double. Nach int zu casten, wenn du eine Ganzzahl willst, ist in Ordnung, aber beachte, dass (int)x für sich abschneidet - (int)(x + 0.5) ist also das alte „Rundungs"-Idiom, und es ist für negative Zahlen falsch. Nimm round().

fabs und fmod

fabs ist der Absolutbetrag für Gleitkommazahlen. Stattdessen zu abs zu greifen ist ein klassischer Fehler, denn abs nimmt ein int und die Umwandlung passiert stillschweigend:

#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   <- der Bruchteil wurde weggeworfen\n", abs((int)x));

    /* fmod: der Rest einer Gleitkommadivision */
    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;
}

% funktioniert bei double überhaupt nicht - es ist ein Ganzzahloperator, und der Compiler weist es zurück. fmod(a, b) ist sein Gleitkomma-Gegenstück, und es behält das Vorzeichen von a.

fabs ist auch der richtige Weg, zwei doubles zu vergleichen, denn == ist bei Gleitkommazahlen eine Falle:

#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) ? "ja" : "nein");
    printf("a ist %.20f\n", a);
    printf("nah genug?       %s\n", (fabs(a - b) < 1e-9) ? "ja" : "nein");
    return 0;
}

0.1 und 0.2 lassen sich binär nicht exakt darstellen, ihre Summe liegt also haarscharf neben 0.3. Vergleiche mit einer Toleranz, nie mit ==.

Trigonometrie

Die trigonometrischen Funktionen arbeiten im Bogenmaß, nicht in Grad - die andere verlässliche Quelle falscher Antworten.

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

    /* Umkehrfunktionen liefern Bogenmass */
    printf("asin(0.5)    = %.4f rad = %.1f Grad\n",
           asin(0.5), asin(0.5) * 180.0 / PI);

    /* atan2 kennt den Quadranten; atan allein nicht */
    printf("atan2(1, 1)  = %.4f rad = %.1f Grad\n",
           atan2(1.0, 1.0), atan2(1.0, 1.0) * 180.0 / PI);
    return 0;
}

Der vollständige Satz: sin, cos, tan, ihre Umkehrungen asin, acos, atan, das zweiargumentige atan2(y, x) und die hyperbolische Familie sinh, cosh, tanh. Bevorzuge für Winkel atan2(y, x) gegenüber atan(y / x) - es behandelt x == 0 und trifft den Quadranten richtig.

math.h definiert auf den meisten Systemen M_PI, aber das ist eine POSIX-Erweiterung statt Standard-C, unter -std=c17 kann es also fehlen. Eine eigene Konstante zu definieren, wie oben, ist portabel.

Logarithmen und Exponentialfunktionen

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

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

    /* Logarithmus zu beliebiger Basis b: log(x) / log(b) */
    printf("log zur Basis 3 von 81 = %.4f\n", log(81.0) / log(3.0));
    return 0;
}

Beachte die aus der Mathematik übernommene Namensfalle: log() ist der natürliche Logarithmus (Basis e), nicht Basis 10. Basis 10 ist log10().

log(0.0) liefert negativ unendlich und log(-1.0) liefert NaN - keines von beidem stürzt ab, was bedeutet, dass ein schlechtes Argument still durch deine Rechnung reist, bis irgendetwas nan ausgibt.

INFINITY, NAN und die Prüfung darauf

Gleitkommazahlen kennen Werte, die keine Zahlen sind, und math.h benennt sie:

#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 vergleicht sich mit allem als ungleich, auch mit sich selbst */
    printf("nan_val == nan_val ? %s\n", (nan_val == nan_val) ? "ja" : "nein");
    return 0;
}

Die letzte Zeile ist die entscheidende. Du kannst nicht if (x == NAN) schreiben - es ist immer falsch. Nimm isnan(x). (Die Identität x != x ist nur für NaN wahr, so wird isnan oft implementiert, und es ist ein praktischer Ersatz, falls dir je eine Werkzeugkette ohne begegnet.)

Unendlichkeiten entstehen durch Überlauf (exp(1000.0)) und durch die Division eines double ungleich null durch null, die - anders als die Ganzzahldivision durch null - definiert ist und nicht abstürzt.

Die float- und long-double-Varianten

Jede Funktion hat drei Formen: die double-Fassung, eine mit f-Suffix für float und eine mit l-Suffix für long double.

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

Nimm die schlichten double-Fassungen, sofern du keinen gemessenen Grund dagegen hast - double ist das, wozu C standardmäßig befördert, und float-Varianten hineinzumischen kostet meist mehr an Umwandlungen, als es spart. Die eine Stelle, an der das Suffix zählt, ist eine reine float-Rechnung, die auf Hardware ohne Double-Unterstützung leistungskritisch ist.

Ein praktisches Beispiel

Mehrere davon zusammen - der Abstand zweier Punkte und die Lösungen einer quadratischen Gleichung:

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

    /* Loese 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("Zwei Loesungen: %.4f und %.4f\n",
               (-b + root) / (2 * a), (-b - root) / (2 * a));
    } else if (fabs(disc) < 1e-12) {
        printf("Eine doppelte Loesung: %.4f\n", -b / (2 * a));
    } else {
        printf("Keine reellen Loesungen (Diskriminante %.4f)\n", disc);
    }
    return 0;
}

Beachte fabs(disc) < 1e-12 statt disc == 0.0 - dieselbe Toleranzregel wie zuvor, angewandt dort, wo eine aus Messwerten berechnete Diskriminante fast nie exakt auf null landet.

<math.h> ist ein Header in einem größeren Werkzeugkasten; die Seite Standardbibliothek kartiert den Rest, und Zufallszahlen behandelt rand, das in <stdlib.h> lebt statt hier.

Häufig gestellte Fragen

Wie benutze ich Mathematikfunktionen in C?

Setze #include <math.h> an den Anfang der Datei und rufe sie auf: sqrt(16.0), pow(2.0, 10.0), fabs(-3.5). Sie nehmen double entgegen und liefern double. Unter Linux musst du zusätzlich die Mathematikbibliothek mit -lm linken: gcc program.c -o program -lm.

Warum bekomme ich beim Kompilieren „undefined reference to sqrt"?

Der Header hat dem Compiler die Deklaration gegeben, aber die Implementierung liegt in einer eigenen Bibliothek, die der Linker unter Linux nicht automatisch hinzunimmt. Füge -lm am Ende des Befehls hinzu: gcc program.c -o program -lm. Unter macOS und mit MinGW unter Windows gehört der Mathematikcode zur Standard-C-Bibliothek, dort braucht es kein Flag.

Was ist der Unterschied zwischen abs und fabs in C?

abs() aus <stdlib.h> nimmt ein int und liefert ein int. fabs() aus <math.h> nimmt ein double und liefert ein double. abs(-3.7) aufzurufen wandelt das Argument zuerst in int um und ergibt 3, wobei der Bruchteil still verworfen wird - nimm für Gleitkommawerte fabs.

Wie prüfe ich in C auf NaN?

Benutze isnan(x) aus <math.h>. Mit x == NAN kannst du nicht prüfen, denn NaN vergleicht sich mit allem als ungleich, auch mit sich selbst - diese Eigenheit ist tatsächlich der Ersatztest: x != x ist nur für NaN wahr. Nimm isinf(x) für Unendlichkeiten und isfinite(x), um auf eine gewöhnliche Zahl zu prüfen.

Verwandte Konzepte