Write Python code that uses Monte Carlo simulation to estimate the value of pi.
- User
Write Python code that uses Monte Carlo simulation to estimate the value of pi.
Assistant
Contemplating the Approach
I've been focusing on the Monte Carlo method. I'm visualizing a square with a circle inscribed within it. Randomly generated points within the square will either fall inside the circle or outside it. The ratio of points inside the circle to the total points, multiplied by four, should approximate pi. Now, I'm thinking about how to best translate this visual model into Python code, starting with random number generation and area calculations.
Deconstructing the Algorithm
I'm solidifying the Monte Carlo strategy: We'll generate random (x, y) coordinates within a unit square. Then, for each point, calculate if it falls inside the unit circle (using the distance formula). The ratio of points inside to the total, times four, gives us pi's approximation. I'm considering using NumPy for efficient random number generation and array operations.
Analyzing the Code's Core
I'm deep in the implementation. The core logic is set. Generating random (x, y) pairs, checking if they fall within the unit circle (radius 1 centered at origin), and counting "hits." The critical part is translating the geometric concept into a clear and efficient Python loop, which I believe I've done. Next, I plan to consider vectorization.
Considering Refinements & Options
I'm now focusing on optimizing the code and providing alternatives. I'm planning a standard, loop-based implementation (using the
randommodule) for clarity and a NumPy-based version for speed. Additionally, I'll generate a plot using Matplotlib to visually represent the simulation, enhancing understanding. I'll need to define a range for my unit square.Planning the Implementation
I'm now mapping out the code structure. I'll need to define functions for the core calculation, potentially using the standard
randommodule for a simpler approach. Then, I'll build a NumPy-based version for speed, and finally, a visualization component. I'm focusing on providing multiple, easily understandable options.Here are three ways to solve this.
- Standard Python: Best for understanding the logic.
- NumPy: Best for performance (standard Python loops are slow for large numbers).
- Start-to-Finish with Visualization: Best for seeing how the math works visually.
The Concept
We assume a square with a side length of . Inside, we inscribe a quarter-circle.
- Area of Square
- Area of Quarter Circle
If we generate random points inside the square, the ratio of points falling inside the circle to the total points is . Therefore, .
1. The Standard Approach (No external libraries)
This uses the built-in
randommodule. It is easy to read but slower for very large simulations ().import random def monte_carlo_pi(n): points_inside_circle = 0 points_total = n for _ in range(points_total): # Generate random x, y in [0, 1] x = random.random() y = random.random() # Check if the point is inside the circle (x^2 + y^2 <= r^2) # Here r = 1 distance = x**2 + y**2 if distance <= 1: points_inside_circle += 1 return 4 * (points_inside_circle / points_total) # Run the simulation n_samples = 1000000 # 1 million iterations pi_estimate = monte_carlo_pi(n_samples) print(f"Estimated Pi after {n_samples} iterations: {pi_estimate}")
2. The High-Performance Approach (NumPy)
If you need high precision, you need massive iteration counts.
NumPyperforms vectorised operations, calculating millions of points simultaneously rather than looping through them one by one.import numpy as np def numpy_pi(n): # Generate N random x and y values simultaneously x = np.random.rand(n) y = np.random.rand(n) # Calculate x^2 + y^2 for the whole array # Determine how many are <= 1 inside_circle = np.sum(x**2 + y**2 <= 1) return 4 * inside_circle / n # Run with 10 million points n_samples = 10000000 pi_estimate = numpy_pi(n_samples) print(f"Estimated Pi (NumPy) after {n_samples} iterations: {pi_estimate}")
3. The Visual Approach
This script generates a scatter plot showing the square, the arc of the circle, and where the random "darts" landed.
Requires
matplotlib:pip install matplotlibimport random import matplotlib.pyplot as plt def visualize_pi(num_points): points_inside_x = [] points_inside_y = [] points_outside_x = [] points_outside_y = [] count_inside = 0 for _ in range(num_points): x = random.random() y = random.random() if x**2 + y**2 <= 1: count_inside += 1 points_inside_x.append(x) points_inside_y.append(y) else: points_outside_x.append(x) points_outside_y.append(y) estimated_pi = 4 * count_inside / num_points # Plotting plt.figure(figsize=(6, 6)) # Draw points plt.scatter(points_inside_x, points_inside_y, color='blue', s=1, label='Inside') plt.scatter(points_outside_x, points_outside_y, color='red', s=1, label='Outside') # Draw circle boundary for reference circle = plt.Circle((0, 0), 1, color='black', fill=False, linewidth=2) plt.gca().add_artist(circle) plt.title(f"Monte Carlo Simulation (N={num_points})\nEstimated Pi = {estimated_pi}") plt.xlabel("x") plt.ylabel("y") plt.legend(loc='upper right') plt.axis('equal') # Ensures square aspect ratio plt.xlim(0, 1) plt.ylim(0, 1) plt.show() # Run with a smaller number so the graph renders quickly visualize_pi(10000)
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.