Utiliser la Simulation de Monte Carlo pour l'Estimation de Probabilités en C

Introduction

Dans ce laboratoire, nous explorerons comment utiliser la simulation de Monte Carlo pour estimer les probabilités en programmation C. Nous commencerons par définir une expérience aléatoire simple, telle qu'un lancer de pièce, puis nous exécuterons plusieurs essais pour compter le nombre de résultats favorables. Enfin, nous calculerons la probabilité estimée en divisant le nombre de succès par le nombre total d'essais. Ce laboratoire fournit une introduction pratique aux concepts fondamentaux de la probabilité et de la combinatoire en utilisant le langage C, compétences essentielles pour l'analyse de données et la prise de décision.

Définition d'une expérience aléatoire

Dans cette étape, nous explorerons comment définir une expérience aléatoire à l'aide de la simulation de Monte Carlo en C. Une expérience aléatoire est un processus aux résultats incertains qui peut être simulé à l'aide de techniques de probabilité.

Comprendre les expériences aléatoires

Créons un simple programme C pour démontrer une expérience aléatoire de base : la simulation du lancer d'une pièce.

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

#define NUM_ESSAIS 1000

int main() {
    // Initialiser le générateur de nombres aléatoires
    srand(time(NULL));

    // Compteur de faces
    int nb_faces = 0;

    // Simuler les lancers de pièce
    for (int i = 0; i < NUM_ESSAIS; i++) {
        // Générer un nombre aléatoire 0 ou 1
        int lancer = rand() % 2;

        // Comptabiliser les faces
        if (lancer == 0) {
            nb_faces++;
        }
    }

    // Calculer la probabilité d'obtenir face
    double probabilité = (double)nb_faces / NUM_ESSAIS;

    printf("Expérience de lancer de pièce :\n");
    printf("Nombre total d'essais : %d\n", NUM_ESSAIS);
    printf("Nombre de faces : %d\n", nb_faces);
    printf("Probabilité estimée d'obtenir face : %.2f\n", probabilité);

    return 0;
}

Exemple de sortie :

Expérience de lancer de pièce :
Nombre total d'essais : 1000
Nombre de faces : 502
Probabilité estimée d'obtenir face : 0,50

Concepts clés expliqués

1. Génération de nombres aléatoires :

   • srand(time(NULL)) initialise le générateur de nombres aléatoires
   • rand() % 2 génère soit 0 soit 1 avec une probabilité égale

2. Conception de l'expérience :

   • Nous définissons le lancer d'une pièce comme notre expérience aléatoire
   • Exécuter plusieurs essais (1000 dans ce cas)
   • Comptabiliser le nombre de résultats favorables (faces)

3. Estimation de la probabilité :

   • Probabilité = (Nombre de résultats favorables) / (Nombre total d'essais)
   • Dans ce cas, nous nous attendons à une probabilité proche de 0,5 pour obtenir face.

Compilation et exécution du programme

## Créer le fichier source
nano ~/project/coin_flip_experiment.c

## Compiler le programme
gcc ~/project/coin_flip_experiment.c -o ~/project/coin_flip_experiment

## Exécuter l'expérience
~/project/coin_flip_experiment

Exemple de compilation et de sortie d'exécution :

## Compilation
gcc ~/project/coin_flip_experiment.c -o ~/project/coin_flip_experiment

## Exécution
~/project/coin_flip_experiment
Expérience de lancer de pièce :
Nombre total d'essais : 1000
Nombre de faces : 502
Probabilité estimée d'obtenir face : 0,50

Exécution de nombreux essais aléatoires et comptage des réussites

Dans cette étape, nous étendrons notre simulation de Monte Carlo en exécutant de multiples essais aléatoires et en comptant précisément les résultats favorables. Nous démontrerons cela à travers une expérience de probabilité plus complexe : l'estimation de π (pi) à l'aide de la génération de points aléatoires.

Méthode de Monte Carlo pour l'estimation de π

Nous utiliserons une approche géométrique pour estimer π en générant des points aléatoires à l'intérieur d'un carré contenant un quart de cercle.

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

#define NUM_ESSAIS 100000

int main() {
    // Initialiser le générateur de nombres aléatoires
    srand(time(NULL));

    // Compteurs pour le total et les points à l'intérieur
    int total_points = 0;
    int points_dans_cercle = 0;

    // Exécuter de multiples essais
    for (int i = 0; i < NUM_ESSAIS; i++) {
        // Générer des coordonnées x et y aléatoires entre 0 et 1
        double x = (double)rand() / RAND_MAX;
        double y = (double)rand() / RAND_MAX;

        // Vérifier si le point est à l'intérieur du quart de cercle
        if (sqrt(x*x + y*y) <= 1.0) {
            points_dans_cercle++;
        }
        total_points++;
    }

    // Estimer π
    double estimation_pi = 4.0 * points_dans_cercle / total_points;

    printf("Expérience d'estimation de π :\n");
    printf("Points totaux : %d\n", total_points);
    printf("Points à l'intérieur du cercle : %d\n", points_dans_cercle);
    printf("Estimation de π : %.6f\n", estimation_pi);
    printf("Valeur réelle de π :    %.6f\n", M_PI);

    return 0;
}

Compilation et exécution de l'expérience

## Créer le fichier source
nano ~/project/pi_estimation.c

## Compiler le programme (notez le lien avec la bibliothèque mathématique)
gcc ~/project/pi_estimation.c -o ~/project/pi_estimation -lm

## Exécuter l'expérience
~/project/pi_estimation

Exemple de sortie :

Expérience d'estimation de π :
Points totaux : 100000
Points à l'intérieur du cercle : 78540
Estimation de π : 3,141600
Valeur réelle de π :    3,141593

Concepts clés expliqués

1. Essais multiples :

   • Nous exécutons un grand nombre d'essais aléatoires (100 000)
   • Chaque essai génère un point aléatoire dans un carré de 1x1

2. Comptage des réussites :

   • Suivre le nombre total de points et le nombre de points à l'intérieur du quart de cercle
   • La réussite est définie comme un point tombant à l'intérieur du cercle

3. Estimation de la probabilité :

   • Probabilité = (Points réussis) / (Points totaux)
   • Multiplier par 4 pour estimer π en raison de la méthode du quart de cercle

Techniques importantes

• (double)rand() / RAND_MAX génère un nombre décimal aléatoire entre 0 et 1
• sqrt(x*x + y*y) calcule la distance à partir de l'origine
• Un grand nombre d'essais améliore la précision de l'estimation

Estimation de la probabilité = Succès/Essais

Dans cette dernière étape, nous démontrerons comment calculer la probabilité en analysant le rapport entre les résultats favorables et le nombre total d'essais dans un scénario plus concret.

Expérience de probabilité de lancer de dés

Nous allons simuler le lancer de deux dés et calculer la probabilité d'obtenir une somme spécifique (par exemple, une somme de 7).

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

#define NUM_ESSAIS 100000
#define SOMME_CIBLE 7

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

int main() {
    // Initialiser le générateur de nombres aléatoires
    srand(time(NULL));

    // Compteurs pour le nombre total de lancers et les lancers réussis
    int total_lancers = 0;
    int lancers_reussies = 0;

    // Exécuter de multiples essais
    for (int i = 0; i < NUM_ESSAIS; i++) {
        // Lancer deux dés
        int de1 = lancer_de();
        int de2 = lancer_de();

        // Vérifier si la somme correspond à la cible
        if (de1 + de2 == SOMME_CIBLE) {
            lancers_reussies++;
        }
        total_lancers++;
    }

    // Calculer la probabilité
    double probabilité = (double)lancers_reussies / total_lancers;

    printf("Expérience de probabilité de lancer de dés :\n");
    printf("Somme cible : %d\n", SOMME_CIBLE);
    printf("Lancers totaux : %d\n", total_lancers);
    printf("Lancers réussis : %d\n", lancers_reussies);
    printf("Probabilité estimée : %.4f\n", probabilité);

    // Probabilité théorique pour comparaison
    printf("Probabilité théorique : %.4f\n", 1.0/6);

    return 0;
}

Compilation et exécution de l'expérience

## Créer le fichier source
nano ~/project/dice_probability.c

## Compiler le programme
gcc ~/project/dice_probability.c -o ~/project/dice_probability

## Exécuter l'expérience
~/project/dice_probability

Exemple de sortie :

Expérience de probabilité de lancer de dés :
Somme cible : 7
Lancers totaux : 100000
Lancers réussis : 16644
Probabilité estimée : 0,1664
Probabilité théorique : 0,1667

Concepts clés expliqués

1. Calcul de la probabilité :

   • Probabilité = (Nombre de résultats favorables) / (Nombre total d'essais)
   • Dans ce cas : Lancers réussis / Lancers totaux

2. Simulation de Monte Carlo :

   • Un grand nombre d'essais (100 000) fournit une estimation précise
   • La probabilité simulée correspond étroitement à la probabilité théorique

3. Aléatoire et précision :

   • srand(time(NULL)) garantit des séquences aléatoires différentes
   • Plus d'essais augmentent la précision de l'estimation

Interprétation de la probabilité

• La probabilité estimée (0,1664) est très proche de la probabilité théorique (1/6 ≈ 0,1667)
• Démonstration de la façon dont la méthode de Monte Carlo peut estimer les probabilités

Résumé

Dans ce laboratoire, nous avons appris à définir une expérience aléatoire à l'aide de la simulation de Monte Carlo en C. Nous avons créé une simulation simple de tirage d'une pièce de monnaie pour démontrer les concepts clés. Tout d'abord, nous avons semé le générateur de nombres aléatoires et simulé les lancers de pièces, en comptant le nombre de résultats favorables (faces). Ensuite, nous avons estimé la probabilité de faces en divisant le nombre de résultats favorables par le nombre total d'essais. La sortie a montré que la probabilité estimée était proche de la valeur attendue de 0,5 pour un lancer de pièce équitable.