Monte Carlo Estimator: Estimating π and Beyond

TL;DR

Built a Monte Carlo simulation in C++ to estimate π using random sampling and statistical convergence. Demonstrates how randomness can solve deterministic problems—essential for scientific computing and game development.

Who This Is For

• Game developers implementing procedural generation
• Students learning probability and simulation
• Anyone curious about computational mathematics

Prerequisites: Basic C++ knowledge, understanding of loops and random numbers, high school geometry helpful.

---

Monte Carlo methods have always fascinated me, especially the idea that randomness can be harnessed to estimate something as fundamental as π. Named after the famous casino in Monaco, these methods use repeated random sampling to solve problems that might be deterministic or even impossible to solve analytically.

So I decided to build a Monte Carlo Estimator in C++ to see this concept in action. This was a simple but eye-opening project that deepened my understanding of probability, convergence, and the elegance of using simulation to solve problems that look purely theoretical on paper.

Why estimate π this way? While we know π's value already, this project demonstrates how Monte Carlo methods can tackle complex problems in physics simulations, financial modeling, and game development—areas where analytical solutions don't exist or are too costly to compute.

What the Program Does

Imagine throwing darts randomly at a square board with a circle inscribed inside it. Some darts land inside the circle, others outside. If you throw enough darts, the ratio of darts inside the circle to total darts approximates the ratio of the circle's area to the square's area. That ratio? It's directly related to π.

Here's how the algorithm works:

1. Generate random points within a 2×2 square (from -1 to 1 on both axes)
2. Test each point using the distance formula: if x² + y² ≤ 1, it's inside the unit circle
3. Calculate the ratio of points inside the circle to total points thrown
4. Multiply by 4 to get our π estimate: π ≈ 4 × (points in circle / total points)
5. Repeat thousands or millions of times to improve accuracy
6. Watch convergence as the estimate stabilizes closer to 3.14159...

It's almost magical—watching randomness settle into predictability.

The math behind it: A unit circle (radius = 1) has area πr² = π. The square that contains it (side length = 2) has area (2)² = 4. So the ratio is π/4. By counting random points, we estimate this ratio, then multiply by 4 to get π = 4 × (circle points / total points).

What I Learned

1. Randomness in Practice

I explored how C++ generates random numbers using rand() and srand(). The srand(time(0)) seeds the random number generator with the current time, ensuring different sequences on each run. Then rand() / RAND_MAX gives us a value between 0 and 1, which we scale to our coordinate range.

While these functions are fairly basic (and std::random with distributions like std::uniform_real_distribution would be more robust for production), they were perfect for demonstrating Monte Carlo fundamentals.

// Example of random point generation
srand(time(0));  // Seed with current time
for (int i = 0; i < iterations; i++) {
    double x = (double)rand() / RAND_MAX * 2 - 1; // Scale to [-1, 1]
    double y = (double)rand() / RAND_MAX * 2 - 1; // Scale to [-1, 1]

    // Distance formula: if x² + y² ≤ 1, point is inside unit circle
    if (x*x + y*y <= 1) {
        pointsInCircle++;
    }
}

Key insight: The quality of randomness directly affects accuracy. Poor random number generators can introduce bias, which is why production systems use cryptographically secure or higher-quality pseudo-random generators.

2. Geometric Probability

This project reinforced how geometry and probability intersect in beautiful ways. Geometric probability is the idea that the likelihood of an event can be determined by comparing areas, volumes, or other geometric measures.

In our case, the probability that a random point lands inside the circle equals the ratio of the circle's area to the square's area (π/4). By generating thousands of random samples, we're empirically estimating this theoretical probability—a core principle in statistical inference.

The elegance here is profound: you can approximate π by throwing virtual darts at a square. No calculus required, no infinite series, just counting. This same principle powers everything from particle physics simulations to estimating complex integrals that have no closed-form solution.

3. Balancing Accuracy and Performance

I experimented with different iteration counts to see how quickly the estimates converged. This revealed a fundamental truth about Monte Carlo methods: error decreases with the square root of the sample size.

More samples mean better accuracy, but they also mean longer runtime—an interesting tradeoff to observe firsthand. Here's what I found:

• 1,000 iterations: Fast but wildly inaccurate (±0.05 from π)
• 100,000 iterations: Decent approximation (±0.01 from π)
• 1 million iterations: Good balance, typically within 0.001 of π
• 10 million+ iterations: Diminishing returns for casual demonstrations

The convergence rate follows the law of large numbers: to double your accuracy, you need roughly 4× more samples. This square-root relationship is why Monte Carlo methods are powerful but computationally expensive for high-precision requirements.

4. Visualizing Progress in the Console

I added print statements to display the estimation improving in real-time. Watching the output evolve was genuinely mesmerizing:

• Early iterations show wild swings: 2.8, 3.6, 2.9...
• By 10,000 samples, it stabilizes around 3.1
• At 100,000+, it hovers between 3.141 and 3.142
• Eventually, it settles remarkably close to 3.14159

Seeing the estimate converge from chaos to precision made the theory tangible. It's one thing to understand convergence mathematically; it's another to watch it happen in real-time. This immediate feedback loop is what makes programming such a powerful learning tool.

Tech Stack

• C++
• Math & Geometry
• Terminal-Based UI

Check It Out

---

It's easy to underestimate small projects like this, but they can teach you a lot. This Monte Carlo Estimator wasn't just a way to practice C++—it was a reminder that sometimes the simplest ideas can reveal the most about how math and programming work together.

If you're curious about Monte Carlo methods or just want to see the code in action, check out the repo or drop me a message—I'd love to hear your thoughts.

— Maruf