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
Zufallszahlengenerierung:
srand(time(NULL))initialisiert den Zufallszahlengeneratorrand() % 2generiert entweder 0 oder 1 mit gleicher Wahrscheinlichkeit
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)
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
Mehrere Versuche:
- Wir führen eine große Anzahl von Zufallsversuchen (100.000) durch.
- Jeder Versuch generiert einen Zufalls-Punkt in einem 1x1 Quadrat.
Erfolgszählung:
- Verfolgen Sie Gesamt-Punkte und Punkte innerhalb des Viertelkreises.
- Erfolg ist definiert als ein Punkt, der innerhalb des Kreises fällt.
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_MAXgeneriert 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
Wahrscheinlichkeitsberechnung:
- Wahrscheinlichkeit = (Anzahl erfolgreicher Ergebnisse) / (Gesamtzahl der Versuche)
- In diesem Fall: Erfolgreiche Würfe / Gesamt-Würfe
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.
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.
