HestonModel

import numpy as np
from MonteCarlo import monte_carlo_simulation

class HestonMonteCarlo:
    def __init__(self, kappa, theta, sigma, rho, v0, r=0.0):
        self.kappa = kappa
        self.theta = theta
        self.sigma = sigma
        self.rho = rho
        self.v0 = v0
        self.r = r
    
    def simulate_paths(self, S0, T, dt, n_paths, n_steps):
        paths = np.zeros((n_paths, n_steps + 1))
        for i in range(n_paths):
            # Initialize the path
            paths[i, 0] = S0
            v = self.v0
            for t in range(1, n_steps + 1):
                # Generate correlated Brownian motions
                Z1 = np.random.normal(0, 1)
                Z2 = self.rho * Z1 + np.sqrt(1 - self.rho ** 2) * np.random.normal(0, 1)

                # Euler discretization for the stock price and volatility
                paths[i, t] = paths[i, t - 1] * np.exp((self.r - 0.5 * v) * dt + np.sqrt(v * dt) * Z1)
                v += self.kappa * (self.theta - v) * dt + self.sigma * np.sqrt(v * dt) * Z2
                v = max(v, 0)  # Ensure volatility is non-negative

        return paths

# Example usage:
if __name__ == "__main__":
    # Example parameters
    kappa = 2.0
    theta = 0.1
    sigma = 0.3
    rho = -0.7
    v0 = 0.1
    r = 0.05
    S0 = 100.0
    T = 1.0
    dt = 1/252
    n_paths = 1000
    n_steps = int(T / dt)

    # Create Heston model object
    heston_model = HestonMonteCarlo(kappa, theta, sigma, rho, v0, r)

    # Simulate paths
    paths = heston_model.simulate_paths(S0, T, dt, n_paths, n_steps)

    # Call monte_carlo_simulation from MonteCarlo.py
    simulated_prices = monte_carlo_simulation(paths[:, -1], None, 100)
    print(simulated_prices)