الدوال الرياضية في لغة 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، وهي ليست خطأً في شيفرتك. فقد وفّرت الترويسة التصريحات، فاقتنع المترجم؛ أما التنفيذات فتعيش في مكتبة منفصلة (libm) لا يضمّنها الرابط افتراضيًا على لينكس. أضف -lm:

gcc program.c -o program -lm

ويجب أن تأتي الراية بعد ملفات المصدر - فالروابط تعالج مدخلاتها بالترتيب، والمكتبة المُدرَجة قبل الشيفرة التي تحتاجها لا تحلّ شيئًا. وعلى macOS ومع MinGW على ويندوز، تكون الإجراءات الرياضية جزءًا من مكتبة 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));

    /* لوغاريتم لأي أساس 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> ترويسة واحدة في صندوق أدوات أكبر؛ وتخطّط صفحة المكتبة القياسية الباقي، وتغطّي الأعداد العشوائية الدالةَ rand التي تعيش في <stdlib.h> لا هنا.