Monte-Carlo-Simulation zur Wahrscheinlichkeitsabschätzung in C

Einführung

In diesem Lab untersuchen wir die Verwendung der Monte-Carlo-Simulation zur Abschätzung von Wahrscheinlichkeiten in der C-Programmierung. Wir beginnen mit der Definition eines einfachen Zufallsexperiments, wie z. B. dem Werfen einer Münze, und führen dann mehrere Versuche durch, um die Anzahl der erfolgreichen Ergebnisse zu zählen. Schließlich berechnen wir die geschätzte Wahrscheinlichkeit, indem wir die Anzahl der Erfolge durch die Gesamtzahl der Versuche dividieren. Dieses Lab bietet eine praktische Einführung in die grundlegenden Konzepte von Wahrscheinlichkeit und Kombinatorik mit C, die essentielle Fähigkeiten für Datenanalyse und Entscheidungsfindung sind.

Definition eines Zufallsexperiments

In diesem Schritt untersuchen wir, wie man ein Zufallsexperiment mithilfe der Monte-Carlo-Simulation in C definiert. Ein Zufallsexperiment ist ein Prozess mit ungewissen Ergebnissen, der mithilfe von Wahrscheinlichkeitstechniken simuliert werden kann.

Verständnis von Zufallsexperimenten

Erstellen wir ein einfaches C-Programm, um ein grundlegendes Zufallsexperiment zu demonstrieren: die Simulation des Münzwurfs.

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

#define NUM_TRIALS 1000

int main() {
    // Den Zufallszahlengenerator initialisieren
    srand(time(NULL));

    // Anzahl der Kopf-Ergebnisse
    int heads_count = 0;

    // Simulation der Münzwürfe
    for (int i = 0; i < NUM_TRIALS; i++) {
        // Zufällige Zahl 0 oder 1 generieren
        int flip = rand() % 2;

        // Kopf-Ergebnisse zählen
        if (flip == 0) {
            heads_count++;
        }
    }

    // Wahrscheinlichkeit für Kopf berechnen
    double probability = (double)heads_count / NUM_TRIALS;

    printf("Münzwurf-Experiment:\n");
    printf("Gesamtversuche: %d\n", NUM_TRIALS);
    printf("Anzahl Kopf: %d\n", heads_count);
    printf("Geschätzte Wahrscheinlichkeit für Kopf: %.2f\n", probability);

    return 0;
}

Beispielausgabe:

Münzwurf-Experiment:
Gesamtversuche: 1000
Anzahl Kopf: 502
Geschätzte Wahrscheinlichkeit für Kopf: 0.50

Erläuterung der Schlüsselkonzepte

1. Zufallszahlengenerierung:

   • srand(time(NULL)) initialisiert den Zufallszahlengenerator
   • rand() % 2 generiert entweder 0 oder 1 mit gleicher Wahrscheinlichkeit

2. Experimentierdesign:

   • Wir definieren einen Münzwurf als unser Zufallsexperiment
   • Führen Sie mehrere Versuche durch (in diesem Fall 1000)
   • Zählen Sie die Anzahl der erfolgreichen Ergebnisse (Kopf)

3. Wahrscheinlichkeitsschätzung:

   • Wahrscheinlichkeit = (Anzahl erfolgreicher Ergebnisse) / (Gesamtzahl der Versuche)
   • In diesem Fall erwarten wir eine Wahrscheinlichkeit von nahe 0,5 für Kopf

Kompilieren und Ausführen des Programms

## Erstellen Sie die Quelldatei
nano ~/project/coin_flip_experiment.c

## Kompilieren Sie das Programm
gcc ~/project/coin_flip_experiment.c -o ~/project/coin_flip_experiment

## Führen Sie das Experiment aus
~/project/coin_flip_experiment

Beispielausgabe für die Kompilierung und Ausführung:

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

## Ausführung
~/project/coin_flip_experiment
Münzwurf-Experiment:
Gesamtversuche: 1000
Anzahl Kopf: 502
Geschätzte Wahrscheinlichkeit für Kopf: 0.50

Durchführung vieler Zufallsversuche und Zählen von Erfolgen

In diesem Schritt erweitern wir unsere Monte-Carlo-Simulation, indem wir mehrere Zufallsversuche durchführen und erfolgreiche Ergebnisse genau zählen. Wir demonstrieren dies anhand eines komplexeren Wahrscheinlichkeitsexperiments: die Schätzung von π (Pi) mithilfe der Erzeugung von Zufallszahlen.

Monte-Carlo-Methode zur π-Schätzung

Wir verwenden einen geometrischen Ansatz, um π zu schätzen, indem wir Zufallszahlen innerhalb eines Quadrats generieren, das ein Viertelkreis enthält.

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

#define NUM_TRIALS 100000

int main() {
    // Zufallszahlengenerator initialisieren
    srand(time(NULL));

    // Zähler für Gesamt- und innere Punkte
    int total_points = 0;
    int points_inside_circle = 0;

    // Durchführung mehrerer Versuche
    for (int i = 0; i < NUM_TRIALS; i++) {
        // Zufällige x- und y-Koordinaten zwischen 0 und 1 generieren
        double x = (double)rand() / RAND_MAX;
        double y = (double)rand() / RAND_MAX;

        // Überprüfen, ob der Punkt innerhalb des Viertelkreises liegt
        if (sqrt(x*x + y*y) <= 1.0) {
            points_inside_circle++;
        }
        total_points++;
    }

    // Schätzung von π
    double pi_estimate = 4.0 * points_inside_circle / total_points;

    printf("π-Schätzungs-Experiment:\n");
    printf("Gesamt-Punkte: %d\n", total_points);
    printf("Punkte im Kreis: %d\n", points_inside_circle);
    printf("Geschätzte π: %.6f\n", pi_estimate);
    printf("Echte π:    %.6f\n", M_PI);

    return 0;
}

Kompilieren und Ausführen des Experiments

## Erstellen Sie die Quelldatei
nano ~/project/pi_estimation.c

## Kompilieren Sie das Programm (beachten Sie die Verknüpfung mit der Mathematikbibliothek)
gcc ~/project/pi_estimation.c -o ~/project/pi_estimation -lm

## Führen Sie das Experiment aus
~/project/pi_estimation

Beispielausgabe:

π-Schätzungs-Experiment:
Gesamt-Punkte: 100000
Punkte im Kreis: 78540
Geschätzte π: 3.141600
Echte π:    3.141593

Erläuterung der Schlüsselkonzepte

1. Mehrere Versuche:

   • Wir führen eine große Anzahl von Zufallsversuchen (100.000) durch.
   • Jeder Versuch generiert einen Zufalls-Punkt in einem 1x1 Quadrat.

2. Erfolgszählung:

   • Verfolgen Sie Gesamt-Punkte und Punkte innerhalb des Viertelkreises.
   • Erfolg ist definiert als ein Punkt, der innerhalb des Kreises fällt.

3. Wahrscheinlichkeitsschätzung:

   • Wahrscheinlichkeit = (Erfolgreiche Punkte) / (Gesamt-Punkte)
   • Multiplizieren Sie mit 4, um π zu schätzen, aufgrund der Methode des Viertelkreises.

Wichtige Techniken

• (double)rand() / RAND_MAX generiert eine zufällige Dezimalzahl zwischen 0 und 1.
• sqrt(x*x + y*y) berechnet die Entfernung vom Ursprung.
• Eine große Anzahl von Versuchen verbessert die Genauigkeit der Schätzung.

Wahrscheinlichkeitsschätzung = Erfolge/Versuche

In diesem letzten Schritt zeigen wir, wie man die Wahrscheinlichkeit berechnet, indem man das Verhältnis von erfolgreichen Ergebnissen zu den Gesamtversuchen in einem praxisnäheren Szenario analysiert.

Würfelwurf-Wahrscheinlichkeitsexperiment

Wir simulieren den Wurf zweier Würfel und berechnen die Wahrscheinlichkeit, eine bestimmte Summe (z. B. die Summe 7) zu erhalten.

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

#define NUM_TRIALS 100000
#define TARGET_SUM 7

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

int main() {
    // Zufallszahlengenerator initialisieren
    srand(time(NULL));

    // Zähler für Gesamt- und erfolgreiche Würfe
    int total_rolls = 0;
    int successful_rolls = 0;

    // Durchführung mehrerer Versuche
    for (int i = 0; i < NUM_TRIALS; i++) {
        // Zwei Würfel werfen
        int die1 = roll_die();
        int die2 = roll_die();

        // Überprüfen, ob die Summe dem Ziel entspricht
        if (die1 + die2 == TARGET_SUM) {
            successful_rolls++;
        }
        total_rolls++;
    }

    // Wahrscheinlichkeit berechnen
    double probability = (double)successful_rolls / total_rolls;

    printf("Würfelwurf-Wahrscheinlichkeitsexperiment:\n");
    printf("Zielsumme: %d\n", TARGET_SUM);
    printf("Gesamt-Würfe: %d\n", total_rolls);
    printf("Erfolgreiche Würfe: %d\n", successful_rolls);
    printf("Geschätzte Wahrscheinlichkeit: %.4f\n", probability);

    // Theoretische Wahrscheinlichkeit zum Vergleich
    printf("Theoretische Wahrscheinlichkeit: %.4f\n", 1.0/6);

    return 0;
}

Kompilieren und Ausführen des Experiments

## Erstellen Sie die Quelldatei
nano ~/project/dice_probability.c

## Kompilieren Sie das Programm
gcc ~/project/dice_probability.c -o ~/project/dice_probability

## Führen Sie das Experiment aus
~/project/dice_probability

Beispielausgabe:

Würfelwurf-Wahrscheinlichkeitsexperiment:
Zielsumme: 7
Gesamt-Würfe: 100000
Erfolgreiche Würfe: 16644
Geschätzte Wahrscheinlichkeit: 0.1664
Theoretische Wahrscheinlichkeit: 0.1667

Erläuterung der Schlüsselkonzepte

1. Wahrscheinlichkeitsberechnung:

   • Wahrscheinlichkeit = (Anzahl erfolgreicher Ergebnisse) / (Gesamtzahl der Versuche)
   • In diesem Fall: Erfolgreiche Würfe / Gesamt-Würfe

2. Monte-Carlo-Simulation:

   • Eine große Anzahl von Versuchen (100.000) liefert eine genaue Schätzung.
   • Die simulierte Wahrscheinlichkeit entspricht in etwa der theoretischen Wahrscheinlichkeit.

3. Zufälligkeit und Genauigkeit:

   • srand(time(NULL)) stellt sicher, dass verschiedene Zufallsfolgen verwendet werden.
   • Mehr Versuche erhöhen die Genauigkeit der Schätzung.

Interpretation der Wahrscheinlichkeit

• Die geschätzte Wahrscheinlichkeit (0,1664) liegt sehr nahe an der theoretischen Wahrscheinlichkeit (1/6 ≈ 0,1667).
• Dies zeigt, wie die Monte-Carlo-Methode zur Schätzung von Wahrscheinlichkeiten verwendet werden kann.

Zusammenfassung

In diesem Labor haben wir gelernt, wie man ein Zufallsexperiment mithilfe der Monte-Carlo-Simulation in C definiert. Wir haben eine einfache Münzwurfsimulation erstellt, um die wichtigsten Konzepte zu demonstrieren. Zuerst haben wir den Zufallszahlengenerator initialisiert und Münzwürfe simuliert, wobei wir die Anzahl der erfolgreichen Ergebnisse (Kopf) gezählt haben. Anschließend haben wir die Wahrscheinlichkeit für Kopf geschätzt, indem wir die Anzahl der erfolgreichen Ergebnisse durch die Gesamtzahl der Versuche dividiert haben. Die Ausgabe zeigte, dass die geschätzte Wahrscheinlichkeit nahe am erwarteten Wert von 0,5 für einen fairen Münzwurf lag.