Fungsi matematika di C: math.h, sqrt, pow, dan linking dengan -lm

Bahasa inti C memberimu + - * / dan %, dan tidak lebih: tidak ada operator pangkat, tidak ada akar kuadrat, tidak ada pembulatan. Semua yang lebih dari aritmetika ada di library matematika standar, yang dideklarasikan di <math.h>.

Semua fungsi ini bekerja dengan presisi double: menerima argumen double dan mengembalikan double. Itu hal pertama yang perlu kamu pahami betul, karena memberikan int tetap bekerja tanpa suara (nilainya dikonversi), sementara menyimpan hasilnya ke int diam-diam membuang pecahannya.

Memulai, dan flag -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;
}

Di komputermu sendiri, mengompilasi kode itu bisa gagal:

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

Inilah sandungan paling umum saat memakai math.h, dan itu bukan kesalahan di kodemu. Header sudah menyediakan deklarasinya, jadi compiler puas; implementasinya ada di library terpisah (libm) yang secara bawaan tidak disertakan linker di Linux. Tambahkan -lm:

gcc program.c -o program -lm

Flag itu harus ditulis setelah file source: linker memproses input-nya secara berurutan, dan library yang ditulis sebelum kode yang membutuhkannya tidak menyelesaikan apa pun. Di macOS dan dengan MinGW di Windows, rutin matematika sudah menjadi bagian library C standar, jadi -lm tidak diperlukan (meski tidak berbahaya di macOS).

Pangkat dan akar

#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) untuk angka negatif mengembalikan NaN, bukan membuat program crash; jaga argumennya kalau nilainya bisa negatif. hypot layak diketahui karena menghitung nilai yang sama dengan sqrt(x*x + y*y) tanpa overflow saat x atau y sangat besar.

Untuk pangkat integer yang kecil, perkalian biasa lebih cepat sekaligus tepat: x * x lebih baik daripada pow(x, 2.0), yang lewat logaritma dan bisa mengembalikan 8.999999999999998 padahal kamu berharap 9.

Pembulatan: floor, ceil, round, trunc

Empat fungsi, empat jawaban berbeda untuk angka negatif. Tabel itulah bagian yang layak dihafal:

#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): integer terbesar yang tidak lebih besar dari x. Selalu bergerak ke arah minus tak hingga: floor(-2.3) hasilnya -3.
• ceil(x): integer terkecil yang tidak lebih kecil dari x. Selalu bergerak ke arah plus tak hingga: ceil(-2.3) hasilnya -2.
• round(x): integer terdekat, nilai setengah dibulatkan menjauhi nol: round(2.5) hasilnya 3, round(-2.5) hasilnya -3.
• trunc(x): memotong bagian pecahan, bergerak ke arah nol: trunc(-2.7) hasilnya -2.

Keempatnya mengembalikan double. Cast ke int saat kamu butuh integer memang tidak masalah, tapi perhatikan bahwa (int)x sendiri melakukan pemotongan. Jadi (int)(x + 0.5) adalah idiom "pembulatan" lama, dan idiom itu salah untuk angka negatif. Pakai round().

fabs dan fmod

fabs adalah nilai mutlak untuk floating point. Memakai abs sebagai gantinya adalah kesalahan klasik, karena abs menerima int dan konversinya terjadi diam-diam:

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

% sama sekali tidak bekerja untuk double: itu operator integer dan compiler menolaknya. fmod(a, b) adalah pasangannya untuk floating point, dan tanda hasilnya mengikuti a.

fabs juga cara yang benar untuk membandingkan dua double, karena == pada floating point adalah jebakan:

#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 dan 0.2 tidak bisa direpresentasikan secara tepat dalam biner, jadi jumlahnya sedikit meleset dari 0.3. Bandingkan dengan toleransi, jangan pernah dengan ==.

Trigonometri

Fungsi trigonometri bekerja dalam radian, bukan derajat. Ini sumber jawaban salah lain yang selalu bisa diandalkan.

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

Daftar lengkapnya: sin, cos, tan, inversnya asin, acos, atan, versi dua argumen atan2(y, x), dan keluarga hiperbolik sinh, cosh, tanh. Utamakan atan2(y, x) daripada atan(y / x) untuk sudut: fungsi itu menangani x == 0 dan menentukan kuadran dengan benar.

math.h mendefinisikan M_PI di kebanyakan sistem, tapi itu ekstensi POSIX, bukan C standar, jadi bisa saja tidak ada dengan -std=c17. Mendefinisikan konstantamu sendiri, seperti di atas, lebih portabel.

Logaritma dan eksponensial

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

Perhatikan jebakan penamaan yang terbawa dari matematika: log() adalah logaritma natural (basis e), bukan basis 10. Basis 10 adalah log10().

log(0.0) mengembalikan minus tak hingga dan log(-1.0) mengembalikan NaN. Keduanya tidak membuat program crash, artinya argumen yang salah bisa terbawa diam-diam di sepanjang perhitunganmu sampai ada yang mencetak nan.

INFINITY, NAN, dan cara mengeceknya

Floating point punya nilai yang bukan angka, dan math.h memberinya nama:

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

Baris terakhir itulah yang paling penting. Kamu tidak bisa menulis if (x == NAN): hasilnya selalu salah. Pakai isnan(x). (Identitas x != x hanya benar untuk NaN. Begitulah isnan sering diimplementasikan, dan itu cadangan yang praktis kalau suatu saat kamu bertemu toolchain yang tidak punya fungsi itu.)

Nilai tak hingga muncul dari overflow (exp(1000.0)) dan dari pembagian double bukan nol dengan nol, yang, berbeda dengan pembagian integer dengan nol, terdefinisi dan tidak membuat program crash.

Varian float dan long double

Setiap fungsi punya tiga bentuk: versi double, versi float berakhiran f, dan versi long double berakhiran l.

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

Pakai versi double biasa kecuali kamu punya alasan yang sudah diukur untuk tidak memakainya. double adalah tipe yang dipromosikan C secara bawaan, dan mencampur varian float biasanya lebih banyak memakan biaya konversi daripada yang dihemat. Satu-satunya tempat akhiran itu penting adalah saat perhitungan yang hanya memakai float sangat menentukan performa di hardware tanpa dukungan double.

Contoh praktis

Menggabungkan beberapa fungsi ini: jarak antara dua titik dan akar persamaan kuadrat:

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

Perhatikan fabs(disc) < 1e-12, bukan disc == 0.0. Ini aturan toleransi yang sama seperti tadi, diterapkan di tempat diskriminan yang dihitung dari nilai hasil pengukuran hampir tidak pernah tepat jatuh di nol.

<math.h> hanyalah satu header dalam perangkat yang lebih besar; halaman library standar memetakan sisanya, dan angka acak membahas rand, yang ada di <stdlib.h>, bukan di sini.