פונקציות מתמטיות ב-C: math.h, sqrt, pow וקישור עם -lm

השפה הבסיסית של C נותנת לכם את + - * / ואת %, ותו לא: אין אופרטור חזקה, אין שורש ריבועי, אין עיגול. כל מה שמעבר לאריתמטיקה נמצא בספרייה המתמטית הסטנדרטית, שמוצהרת ב-<math.h>.

כל הפונקציות האלה עובדות בדיוק של double: הן מקבלות ארגומנטים מסוג double ומחזירות double. זה הדבר הראשון שצריך להפנים, כי העברה של int עובדת בשקט (הוא מומר), בעוד שהשמת התוצאה ל-int משליכה בשקט את השבר.

צעדים ראשונים, והדגל -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;
}

על המחשב שלכם, קומפילציה של זה עלולה להיכשל:

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

זו המעידה הנפוצה ביותר עם math.h, והיא לא טעות בקוד שלכם. ה-header סיפק את ההצהרות, אז הקומפיילר היה מרוצה; המימושים נמצאים בספרייה נפרדת (libm) שה-linker לא כולל כברירת מחדל ב-Linux. הוסיפו -lm:

gcc program.c -o program -lm

הדגל חייב לבוא אחרי קובצי המקור: linkers מעבדים את הקלטים שלהם לפי הסדר, וספרייה שמופיעה לפני הקוד שצריך אותה לא פותרת כלום. ב-macOS וב-MinGW ב-Windows, השגרות המתמטיות כבר חלק מספריית C הסטנדרטית, כך ש--lm מיותר (אם כי לא מזיק ב-macOS).

חזקות ושורשים

#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));   /* שורש ריבועי */
    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));      /* שורש שלישי */
    printf("hypot(3, 4)    = %.4f\n", hypot(3.0, 4.0)); /* sqrt(3*3+4*4) */
    return 0;
}

sqrt(x) של מספר שלילי מחזיר NaN במקום לקרוס; הגנו על הארגומנט אם הוא יכול להיות שלילי. כדאי להכיר את hypot, כי הוא מחשב את אותו ערך כמו sqrt(x*x + y*y) בלי לגלוש כש-x או y גדולים מאוד.

עבור חזקות שלמות קטנות, כפל רגיל גם מהיר יותר וגם מדויק: x * x עדיף על pow(x, 2.0), שעובר דרך לוגריתמים ועלול להחזיר 8.999999999999998 כשציפיתם ל-9.

עיגול: floor, ceil, round, trunc

ארבע פונקציות, ארבע תשובות שונות עבור מספרים שליליים. הטבלה הזו היא החלק ששווה לזכור:

#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): המספר השלם הגדול ביותר שאינו גדול מ-x. תמיד זז לכיוון מינוס אינסוף: floor(-2.3) הוא -3.
• ceil(x): המספר השלם הקטן ביותר שאינו קטן מ-x. תמיד זז לכיוון פלוס אינסוף: ceil(-2.3) הוא -2.
• round(x): המספר השלם הקרוב ביותר, חצאים מתעגלים הרחק מאפס: round(2.5) הוא 3, round(-2.5) הוא -3.
• trunc(x): חותך את החלק השברי, זז לכיוון אפס: trunc(-2.7) הוא -2.

כל הארבע מחזירות double. המרה ל-int כשרוצים מספר שלם היא בסדר, אבל שימו לב ש-(int)x לבדו מבצע חיתוך, כך ש-(int)(x + 0.5) הוא ביטוי ה"עיגול" הישן, והוא שגוי עבור מספרים שליליים. השתמשו ב-round().

fabs ו-fmod

fabs הוא ערך מוחלט עבור נקודה צפה. שימוש ב-abs במקומו הוא טעות קלאסית, כי abs מקבלת int וההמרה קורית בשקט:

#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: השארית של חילוק בנקודה צפה */
    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;
}

% לא עובד בכלל על double: הוא אופרטור של מספרים שלמים והקומפיילר דוחה אותו. fmod(a, b) הוא המקביל שלו לנקודה צפה, והוא שומר על הסימן של a.

fabs הוא גם הדרך הנכונה להשוות שני double, כי == על נקודה צפה הוא מלכודת:

#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 ואת 0.2 בדיוק בבינארי, ולכן הסכום שלהם רחוק כחוט השערה מ-0.3. השוו עם סבולת, אף פעם לא עם ==.

טריגונומטריה

הפונקציות הטריגונומטריות עובדות ברדיאנים, לא במעלות, וזה המקור האמין השני לתשובות שגויות.

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

    /* הפונקציות ההופכיות מחזירות רדיאנים */
    printf("asin(0.5)   = %.4f rad = %.1f deg\n",
           asin(0.5), asin(0.5) * 180.0 / PI);

    /* atan2 יודעת את הרביע; atan לבדה לא */
    printf("atan2(1, 1) = %.4f rad = %.1f deg\n",
           atan2(1.0, 1.0), atan2(1.0, 1.0) * 180.0 / PI);
    return 0;
}

הסט המלא: sin, cos, tan, ההופכיות שלהן asin, acos, atan, הגרסה עם שני ארגומנטים atan2(y, x), והמשפחה ההיפרבולית sinh, cosh, tanh. העדיפו את atan2(y, x) על פני atan(y / x) עבור זוויות: היא מטפלת ב-x == 0 ומזהה נכון את הרביע.

math.h מגדיר את M_PI ברוב המערכות, אבל זו הרחבה של POSIX ולא C תקני, כך שהוא עלול להיות חסר תחת -std=c17. הגדרת קבוע משלכם, כמו למעלה, היא ניידת.

לוגריתמים ואקספוננטים

#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 בכל בסיס b: log(x) / log(b) */
    printf("log base 3 of 81 = %.4f\n", log(81.0) / log(3.0));
    return 0;
}

שימו לב למלכודת השמות שעברה מהמתמטיקה: log() הוא הלוגריתם הטבעי (בסיס e), לא בסיס 10. בסיס 10 הוא log10().

log(0.0) מחזיר מינוס אינסוף ו-log(-1.0) מחזיר NaN: אף אחד מהם לא קורס, מה שאומר שארגומנט גרוע עובר בשקט דרך כל החישוב עד שמשהו מדפיס nan.

INFINITY, NAN ואיך בודקים אותם

לנקודה צפה יש ערכים שאינם מספרים, ו-math.h נותן להם שמות:

#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 לא שווה לשום דבר, כולל לעצמו */
    printf("nan_val == nan_val ? %s\n", (nan_val == nan_val) ? "yes" : "no");
    return 0;
}

השורה האחרונה היא הקריטית. אי אפשר לכתוב if (x == NAN): זה תמיד שקר. השתמשו ב-isnan(x). (הזהות x != x היא אמת רק עבור NaN, וכך isnan ממומש לעתים קרובות, וזה גיבוי שימושי אם תיתקלו פעם בכלי פיתוח בלעדיו.)

אינסופים מגיעים מגלישה (exp(1000.0)) ומחילוק של double שאינו אפס באפס, שבניגוד לחילוק שלמים באפס מוגדר ולא קורס.

גרסאות float ו-long double

לכל פונקציה יש שלוש צורות: גרסת ה-double, גרסת float עם הסיומת f, וגרסת long double עם הסיומת l.

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

השתמשו בגרסאות ה-double הרגילות אלא אם יש לכם סיבה מדודה שלא: double הוא מה ש-C מקדמת אליו כברירת מחדל, וערבוב של גרסאות float בדרך כלל עולה בהמרות יותר ממה שהוא חוסך. המקום היחיד שבו הסיומת חשובה הוא כשחישוב שכולו float קריטי לביצועים על חומרה בלי תמיכה ב-double.

דוגמה מעשית

שילוב של כמה מהן יחד: המרחק בין שתי נקודות והשורשים של משוואה ריבועית:

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

    /* פתרון של 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;
}

שימו לב ל-fabs(disc) < 1e-12 במקום disc == 0.0: אותו כלל סבולת כמו קודם, מיושם במקום שבו דיסקרימיננטה שחושבה מערכים מדודים כמעט אף פעם לא תנחת בדיוק על אפס.

<math.h> הוא header אחד בארגז כלים גדול יותר; העמוד על הספרייה הסטנדרטית ממפה את השאר, ומספרים אקראיים מכסה את rand, שנמצא ב-<stdlib.h> ולא כאן.