Hàm toán học trong C: math.h, sqrt, pow và liên kết với -lm

Ngôn ngữ lõi của C chỉ cho bạn + - * / và %, ngoài ra không có gì: không có toán tử lũy thừa, không có căn bậc hai, không có làm tròn. Mọi thứ vượt ra ngoài số học cơ bản đều nằm trong thư viện toán học chuẩn, được khai báo trong <math.h>.

Các hàm này đều làm việc với độ chính xác double: chúng nhận đối số double và trả về double. Đó là điều đầu tiên cần thấm, vì truyền vào một int vẫn chạy lặng lẽ (nó được chuyển kiểu), trong khi gán kết quả cho một int lại lặng lẽ bỏ mất phần thập phân.

Bắt đầu, và cờ -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;
}

Trên máy của bạn, biên dịch đoạn này có thể bị lỗi:

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

Đây là chỗ vấp phổ biến nhất với math.h, và nó không phải lỗi trong code của bạn. Header đã cung cấp các khai báo nên trình biên dịch hài lòng; còn phần cài đặt nằm trong một thư viện riêng (libm) mà trên Linux trình liên kết không đưa vào theo mặc định. Hãy thêm -lm:

gcc program.c -o program -lm

Cờ này phải đứng sau các tệp nguồn: trình liên kết xử lý đầu vào theo thứ tự, và một thư viện liệt kê trước phần code cần đến nó sẽ không giải quyết được gì. Trên macOS và với MinGW trên Windows, các hàm toán học đã nằm sẵn trong thư viện C chuẩn, nên không cần -lm (dù trên macOS thêm vào cũng không sao).

Lũy thừa và căn

#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) với số âm trả về NaN chứ không làm chương trình crash; hãy kiểm tra trước nếu đối số có thể âm. hypot đáng biết vì nó tính cùng giá trị với sqrt(x*x + y*y) mà không bị tràn số khi x hoặc y rất lớn.

Với lũy thừa nguyên nhỏ, phép nhân thường vừa nhanh hơn vừa chính xác: x * x tốt hơn pow(x, 2.0), vốn đi qua logarit và có thể trả về 8.999999999999998 khi bạn mong đợi 9.

Làm tròn: floor, ceil, round, trunc

Bốn hàm, bốn đáp án khác nhau với số âm. Bảng đó là phần đáng học thuộc:

#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): số nguyên lớn nhất không vượt quá x. Luôn đi về phía âm vô cực: floor(-2.3) là -3.
• ceil(x): số nguyên nhỏ nhất không nhỏ hơn x. Luôn đi về phía dương vô cực: ceil(-2.3) là -2.
• round(x): số nguyên gần nhất, giá trị nửa thì làm tròn ra xa số 0: round(2.5) là 3, round(-2.5) là -3.
• trunc(x): cắt bỏ phần thập phân, đi về phía số 0: trunc(-2.7) là -2.

Cả bốn hàm đều trả về double. Ép kiểu sang int khi bạn cần số nguyên là được, nhưng lưu ý bản thân (int)x đã là phép cắt bỏ phần thập phân, nên (int)(x + 0.5) là cách "làm tròn" kiểu cũ, và nó sai với số âm. Hãy dùng round().

fabs và fmod

fabs là giá trị tuyệt đối cho số thực. Dùng nhầm abs là lỗi kinh điển, vì abs nhận int và việc chuyển kiểu diễn ra lặng lẽ:

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

% hoàn toàn không dùng được với double: đó là toán tử số nguyên và trình biên dịch sẽ từ chối. fmod(a, b) là phiên bản cho số thực, và nó giữ dấu của a.

fabs cũng là cách đúng để so sánh hai số double, vì == trên số thực là một cái bẫy:

#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 và 0.2 không biểu diễn chính xác được ở hệ nhị phân, nên tổng của chúng lệch khỏi 0.3 một chút xíu. Hãy so sánh với một sai số cho phép, đừng bao giờ dùng ==.

Lượng giác

Các hàm lượng giác làm việc với radian, không phải độ: đây là một nguồn đáp án sai khác rất đáng tin cậy.

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

Bộ đầy đủ gồm: sin, cos, tan, các hàm ngược asin, acos, atan, hàm hai đối số atan2(y, x), và nhóm hàm hyperbolic sinh, cosh, tanh. Khi tính góc, hãy ưu tiên atan2(y, x) thay vì atan(y / x): nó xử lý được x == 0 và xác định đúng góc phần tư.

math.h định nghĩa M_PI trên phần lớn hệ thống, nhưng đó là phần mở rộng POSIX chứ không phải C chuẩn, nên có thể thiếu khi dùng -std=c17. Tự định nghĩa hằng số của bạn, như ở trên, là cách khả chuyển.

Logarit và hàm mũ

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

Để ý cái bẫy đặt tên kế thừa từ toán học: log() là logarit tự nhiên (cơ số e), không phải cơ số 10. Cơ số 10 là log10().

log(0.0) trả về âm vô cực và log(-1.0) trả về NaN: cả hai đều không làm crash, nghĩa là một đối số sai sẽ lặng lẽ đi xuyên qua phép tính của bạn cho tới khi có chỗ in ra nan.

INFINITY, NAN và cách kiểm tra chúng

Số thực có những giá trị không phải là số, và math.h đặt tên cho chúng:

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

Dòng cuối cùng là dòng quan trọng nhất. Bạn không thể viết if (x == NAN): điều kiện này luôn sai. Hãy dùng isnan(x). (Đẳng thức x != x chỉ đúng với NaN, đó cũng là cách isnan thường được cài đặt và là phương án dự phòng tiện lợi nếu bạn gặp một bộ công cụ không có nó.)

Giá trị vô cực xuất hiện do tràn số (exp(1000.0)) và khi chia một số double khác 0 cho 0, phép chia mà, khác với chia số nguyên cho 0, được định nghĩa rõ ràng và không làm crash.

Các biến thể float và long double

Mỗi hàm có ba dạng: phiên bản double, phiên bản float có hậu tố f, và phiên bản long double có hậu tố l.

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

Hãy dùng các phiên bản double thường trừ khi bạn có lý do đã đo đạc để không dùng: double là kiểu C mặc định nâng lên, và trộn các biến thể float vào thường tốn cho việc chuyển kiểu nhiều hơn phần tiết kiệm được. Chỗ duy nhất hậu tố này quan trọng là khi một phép tính chỉ dùng float cần hiệu năng cao trên phần cứng không hỗ trợ double.

Một ví dụ thực tế

Kết hợp vài hàm ở trên: khoảng cách giữa hai điểm và nghiệm của phương trình bậc hai:

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

Để ý fabs(disc) < 1e-12 thay vì disc == 0.0: vẫn là quy tắc sai số cho phép như trước, áp dụng ở chỗ một biệt thức tính từ giá trị đo đạc gần như không bao giờ rơi đúng vào 0.

<math.h> chỉ là một header trong bộ công cụ lớn hơn; trang thư viện chuẩn trình bày phần còn lại, và số ngẫu nhiên nói về rand, hàm nằm trong <stdlib.h> chứ không phải ở đây.