الأعداد العشوائية في لغة C: rand وsrand وتوليد عدد ضمن مجال

تأتي الأعداد العشوائية في C من دالّتين في <stdlib.h>: rand() التي تُنتج القيمة التالية، وsrand() التي تضبط نقطة البداية. وهي ليست عشوائية حقًا - بل متتالية شبه عشوائية، تُحسَب حتميًا من بذرة - وهذا قيد للتعمية وميزة للاختبار.

rand() وRAND_MAX

تُرجِع rand() قيمة int في مكان ما بين 0 وRAND_MAX متضمّنَين. وRAND_MAX ماكرو مضمون أنه 32767 على الأقل؛ وعلى لينكس وmacOS يساوي 2147483647.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    printf("RAND_MAX = %d\n\n", RAND_MAX);

    for (int i = 0; i < 5; i++) {
        printf("rand() -> %d\n", rand());
    }
    return 0;
}

شغّل ذلك مرتين. الأعداد متطابقة في المرتين - وهذا ليس خطأً.

البذر بـ srand

بلا استدعاء لـ srand، تتصرّف المتتالية كما لو كنت استدعيت srand(1). البذرة نفسها، والمتتالية نفسها، في كل تشغيل. وللحصول على أعداد مختلفة لكل تشغيل، ابذر بشيء يتغيّر - وعرفًا هو الوقت الحالي:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void) {
    srand((unsigned int) time(NULL));

    for (int i = 0; i < 5; i++) {
        printf("%d\n", rand());
    }
    return 0;
}

تُرجِع time(NULL) من <time.h> الثواني منذ بداية 1970، فيحصل كل تشغيل على بذرة مختلفة. والتحويل إلى unsigned int يُسكِت تحذيرًا عن تضييق time_t.

وثلاث قواعد عن البذر، يخطئ الناس فيها كلها:

ابذر مرة واحدة بالضبط، في بداية main. فاستدعاء srand قبل كل rand() هو النمط المضادّ الكلاسيكي - إذ تُرجِع time(NULL) داخل حلقة تنتهي في أقلّ من ثانية القيمةَ نفسها في كل تكرار، فتعيد البذر بالرقم نفسه وتُرجِع rand() القيمة الأولى نفسها في كل مرة. فيكون الخرج عمودًا من أعداد "عشوائية" متطابقة.

لا تعد البذر لـ "تحسين" العشوائية. فجودة المولّد تأتي من تقدّم حالته الداخلية؛ وإعادة ضبط تلك الحالة ترمي المتتالية.

دقّة time(NULL) ثانية واحدة. فبرنامجان أُطلقا في الثانية نفسها يحصلان على المتتالية نفسها. وهذا مقبول للعبة وخاطئ لأي شيء يهمّ فيه الاستقلال.

عدد ضمن مجال

يستخدم الاصطلاح المعياري عامل باقي القسمة:

rand() % n            /* 0 to n-1 */
rand() % n + min      /* min to min+n-1 */

وللحصول على min حتى max متضمّنَين، يكون عدد القيم الممكنة max - min + 1:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int random_between(int min, int max) {
    return rand() % (max - min + 1) + min;
}

int main(void) {
    srand((unsigned int) time(NULL));

    printf("Dice roll (1-6):     %d\n", random_between(1, 6));
    printf("Percentage (0-100):  %d\n", random_between(0, 100));
    printf("Temperature (-10-40): %d\n", random_between(-10, 40));

    printf("\nTen coin flips: ");
    for (int i = 0; i < 10; i++) {
        printf("%s ", (rand() % 2) ? "H" : "T");
    }
    printf("\n");
    return 0;
}

و+ 1 هي حيث تسكن أخطاء الانزياح بمقدار واحد. فـ rand() % 6 تعطي 0 حتى 5، فرمية النرد هي rand() % 6 + 1. وكتابة rand() % 7 + 1 لـ "تضمين 6" تعطيك نردًا بسبعة أوجه.

الملاحظة الصريحة عن انحياز باقي القسمة

rand() % n ليست منتظمة تمامًا ما لم تقسم n القيمةَ RAND_MAX + 1 بالضبط.

تخيّلها بأرقام صغيرة. لو كانت RAND_MAX تساوي 9 - فتُرجِع rand() من 0 حتى 9، أي عشر قيم متساوية الاحتمال - فإن rand() % 3 تحوّل 0 و3 و6 و9 إلى 0؛ و1 و4 و7 إلى 1؛ و2 و5 و8 إلى 2. فتقع النتيجة 0 بأربع طرق من عشر، وتقع النتيجتان 1 و2 بثلاث طرق لكلٍّ منهما. فالصفر أرجح بنسبة 33%.

والميل نفسه موجود مع RAND_MAX الحقيقية، لكنه أصغر بكثير: فالقيم الفائضة هي النواتج الأولى (RAND_MAX + 1) % n، ويكسب كلٌّ منها فرصة إضافية واحدة من نحو 2.1 مليار. ولرمية نرد أو ورق مخلوط أو محاكاة، يكون ذلك غير قابل للقياس - استخدم % وامضِ.

وحين يهمّ فعلًا - العمل الإحصائي، وأي شيء متعلّق بالأمن - ارفض القيم الفائضة بدل طيّها:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* قيمة غير منحازة في 0..n-1 بإهمال الذيل غير المتساوي */
int unbiased(int n) {
    int limit = RAND_MAX - (RAND_MAX % n);
    int r;
    do {
        r = rand();
    } while (r >= limit);
    return r % n;
}

int main(void) {
    srand((unsigned int) time(NULL));

    int counts[6] = {0};
    for (int i = 0; i < 60000; i++) {
        counts[unbiased(6)]++;
    }

    for (int face = 0; face < 6; face++) {
        printf("%d appeared %d times\n", face + 1, counts[face]);
    }
    return 0;
}

ترمي الحلقة المجال الصغير من القيم الذي يسبّب الميل وتسحب مجددًا. وهي تنتهي بسرعة - فالشريحة المرفوضة كسر متلاشٍ من الكل.

وللعشوائية الحسّاسة أمنيًا فعلًا، rand() هي الأداة الخاطئة مهما بلغ الحذر: استخدم arc4random_buf على macOS وBSD، وgetrandom() على لينكس، وBCryptGenRandom على ويندوز.

الأعداد العشرية العشوائية

اقسم على RAND_MAX لتقع في [0.0, 1.0]، ثم قِس:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

double random_unit(void) {
    return (double) rand() / RAND_MAX;      /* من 0.0 إلى 1.0 */
}

double random_range(double min, double max) {
    return min + random_unit() * (max - min);
}

int main(void) {
    srand((unsigned int) time(NULL));

    for (int i = 0; i < 5; i++) {
        printf("unit: %.6f   range(-1, 1): %+.6f   price: %.2f\n",
               random_unit(),
               random_range(-1.0, 1.0),
               random_range(9.99, 99.99));
    }
    return 0;
}

والتحويل في (double) rand() جوهري. فبدونه تكون rand() / RAND_MAX قسمةً صحيحة وتساوي 0 في كل الأحوال تقريبًا، و1 في فرصة واحدة من مليارين عند بلوغ القيمة العظمى - وهو خطأ يبدو كـ "أعدادي العشرية العشوائية كلها أصفار". انظر تحويل الأنواع للسبب.

المتتاليات القابلة للتكرار

البذرة الثابتة تعطي المتتالية نفسها في كل تشغيل، وهذا بالضبط ما تريده لاختبار أو جلسة تنقيح أو لعبة برموز مراحل قابلة للمشاركة:

#include <stdio.h>
#include <stdlib.h>

void print_five(unsigned int seed) {
    srand(seed);
    printf("seed %-6u:", seed);
    for (int i = 0; i < 5; i++) {
        printf(" %4d", rand() % 100);
    }
    printf("\n");
}

int main(void) {
    print_five(42);
    print_five(42);      /* مطابق للسطر أعلاه */
    print_five(2026);
    print_five(42);      /* مطابق مجددًا */
    return 0;
}

تُنتج البذرة 42 الأعدادَ الخمسة نفسها في كل مرة تُستخدم فيها، في هذا التشغيل وفي أي تشغيل آخر على المكتبة نفسها. وتلك القابلية للتكرار هي سبب وجوب السماح باختيار البذرة في محاكاة: شغّل بالساعة عادةً، ومرّر بذرة ثابتة عند إعادة إنتاج خطأ.

وتحفّظ واحد: المتتالية لبذرة معيّنة ليست قابلة للنقل. فمكتبات C المختلفة تستخدم مولّدات مختلفة، فالبذرة 42 على glibc والبذرة 42 على ويندوز تعطيان أعدادًا مختلفة. قابلة للتكرار على جهاز واحد، لا عبر الأجهزة.

لعبة نرد

كل شيء معًا - البذر مرة واحدة، ودالة مساعِدة للمجال، ومصفوفة تحصي النتائج:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define ROLLS 1000

int roll_die(void) {
    return rand() % 6 + 1;
}

int main(void) {
    srand((unsigned int) time(NULL));

    printf("Five rolls of two dice:\n");
    for (int i = 0; i < 5; i++) {
        int a = roll_die(), b = roll_die();
        printf("  %d + %d = %d%s\n", a, b, a + b,
               (a + b == 7) ? "  <- seven!" : "");
    }

    /* توزيع مجموع نردين على رميات كثيرة */
    int totals[13] = {0};
    for (int i = 0; i < ROLLS; i++) {
        totals[roll_die() + roll_die()]++;
    }

    printf("\nSum distribution over %d rolls:\n", ROLLS);
    for (int sum = 2; sum <= 12; sum++) {
        printf("%3d: ", sum);
        for (int bar = 0; bar < totals[sum] / 4; bar++) {
            printf("#");
        }
        printf(" (%d)\n", totals[sum]);
    }
    return 0;
}

ينبغي أن يبلغ المدرّج ذروته عند 7 ويتناقص نحو 2 و12 - فهناك ست طرق لصنع 7 وطريقة واحدة لكلٍّ من 2 و12. والمولّد الذي ينتج توزيعًا مسطّحًا هنا يكون معطوبًا.

وصفحتان مرتبطتان: تخطّط المكتبة القياسية بقيةَ <stdlib.h>، وتغطّي الدوال الرياضية الترويسةَ <math.h>، التي ستريدها بمجرّد أن تغذّي القيم العشوائية حسابات حقيقية.