Monte Carlo simulations using Python for different mathematical problems:

 Here are a few more Monte Carlo simulations using Python for different mathematical problems:

1. Monte Carlo Integration

Monte Carlo integration is a method to approximate definite integrals using random sampling. For example, let’s estimate the value of the integral of the function  over the interval [0, 1].

Example: Estimating the integral of  from 0 to 1

The exact solution is .

Here’s how we can use Monte Carlo integration:

import numpy as np

def monte_carlo_integration(num_samples: int) -> float:

    # Randomly sample points from 0 to 1

    x = np.random.uniform(0, 1, num_samples)

    

    # Apply the function to each sampled point

    y = x**2

    

    # Estimate the integral as the mean of f(x)

    integral_estimate = np.mean(y)

    

    return integral_estimate

# Run the simulation with a large number of samples

num_samples = 1000000

integral_estimate = monte_carlo_integration(num_samples)

integral_estimate

Explanation:

We generate random points  uniformly in the interval [0, 1].

We compute  for each point.

The mean of the function values approximates the integral.

2. Monte Carlo Simulation for Buffon's Needle Problem

Buffon's Needle is a famous problem that estimates the value of π by dropping needles on a floor with parallel lines spaced equally apart. The probability that a needle will cross a line relates to the value of π.

Problem Setup:

Needles of length  are dropped on a floor with lines spaced distance  apart.

If , the probability  that the needle crosses a line is .

We can use this relationship to estimate π.

import numpy as np

def buffon_needle(num_trials: int, needle_length: float, line_distance: float) -> float:

    hits = 0

    for _ in range(num_trials):

        # Drop the needle: random angle and position

        angle = np.random.uniform(0, np.pi / 2)

        center_distance = np.random.uniform(0, line_distance / 2)

        

        # Check if the needle crosses a line

        if center_distance <= (needle_length / 2) * np.sin(angle):

            hits += 1

    

    # Estimate π from the probability

    pi_estimate = (2 * needle_length * num_trials) / (hits * line_distance)

    

    return pi_estimate

# Parameters for the simulation

needle_length = 1

line_distance = 1

num_trials = 1000000

# Run the Buffon Needle simulation

pi_estimate = buffon_needle(num_trials, needle_length, line_distance)

pi_estimate

Explanation:

We simulate the random drop of a needle by generating a random angle and position.

The number of times the needle crosses a line helps estimate π.

3. Estimating the Area of a Circle Using Monte Carlo

We can estimate the area of a circle using random sampling within a bounding square. If we throw random points into a square that bounds a circle, the ratio of points inside the circle to the total points approximates the area of the circle.

Example: Estimating the area of a unit circle

The exact area of a unit circle (radius 1) is π.

import numpy as np

def monte_carlo_circle_area(num_points: int) -> float:

    # Generate random points in the square [-1, 1] x [-1, 1]

    x = np.random.uniform(-1, 1, num_points)

    y = np.random.uniform(-1, 1, num_points)

    

    # Check how many points fall inside the circle

    inside_circle = (x**2 + y**2) <= 1

    

    # Estimate the area of the circle

    area_estimate = 4 * np.mean(inside_circle)  # since square area is 4

    return area_estimate

# Run the simulation with a large number of points

num_points = 1000000

circle_area_estimate = monte_carlo_circle_area(num_points)

circle_area_estimate

Explanation:

We randomly generate points within a square that bounds the circle.

The fraction of points inside the circle helps estimate the area (multiplied by 4 to account for the area of the square).

4. Monte Carlo Simulation for Estimating Stock Option Prices (Black-Scholes Model)

The Black-Scholes model is widely used to price options. Monte Carlo simulation can help estimate the price of an option based on random samples of the underlying asset’s future price.

Example: Estimating the price of a European call option

Given the stock price , strike price , risk-free rate , volatility , and time to maturity , we can simulate the future stock price and estimate the option price.

import numpy as np

def monte_carlo_option_price(S0, K, r, sigma, T, num_simulations):

    # Simulate future stock prices using geometric Brownian motion

    Z = np.random.standard_normal(num_simulations)

    ST = S0 * np.exp((r - 0.5 * sigma**2) * T + sigma * np.sqrt(T) * Z)

    

    # Calculate the payoff for a European call option

    payoff = np.maximum(ST - K, 0)

    

    # Discount the expected payoff back to present value

    option_price = np.exp(-r * T) * np.mean(payoff)

    

    return option_price

# Parameters for the simulation

S0 = 100    # Initial stock price

K = 105     # Strike price

r = 0.05    # Risk-free rate

sigma = 0.2 # Volatility

T = 1       # Time to maturity (1 year)

num_simulations = 1000000

# Run the Monte Carlo option pricing simulation

option_price_estimate = monte_carlo_option_price(S0, K, r, sigma, T, num_simulations)

option_price_estimate

Explanation:

We simulate future stock prices  using a random sample from a normal distribution.

We calculate the payoff of the option for each simulation and then discount it back to the present value.

The average payoff provides the estimated option price.

These are some additional mathematical and financial Monte Carlo simulations you can implement in Python. Each demonstrates a different aspect of Monte Carlo techniques applied to various problems. Let me know if you'd like to dive deeper into any of these examples!

This work is licensed under a Creative Commons Attribution 4.0 International License.