tempCodeRunnerFile.cpp

#include <iostream>  // To display output
#include <vector>    //To store
#include <cmath>     // To use math functions
#include <random>    // To use random device and mt19937
#include <algorithm> // To use max, min algo
#include <fstream>   // To save data to files
#include <chrono>    //  To measure latency (Speed)

class Stock
{
public:
    std::string symbol;
    double price;
    double volatility;
};

// Monte Carlo Simulator - Amazing tech
double MonteCarloSimulator(const Stock &stock, double strikePrice, double timeInYears, double riskFreeRate, int N)
{

    // 1. Setup Random Engine and normal distribution
    std::random_device rd;
    std::mt19937 gen(rd());
    std::normal_distribution<double> dist(0.0, 1.0);

    // 2. PRE-CALCULATION
    double driftInDay = (riskFreeRate - 0.5 * stock.volatility * stock.volatility) * (timeInYears / 252);
    double diffusionInDay = stock.volatility * std::sqrt(timeInYears / 252);

    double totalPayoff = 0.0;

    // File setup for Python later
    std::ofstream file("simulation_data.csv");
    file << "Simulation,Price\n"; // CSV Header

    // 3. The Loop (100,000 simulations)
    for (int i = 0; i < N; ++i)
    {

        double currentStockPrice = stock.price;  // Start at $100 every path
        double barrierPrice = stock.price * 0.8; // Barrier at $80
        bool isKnockedOut = false;

        // Loop 2: Walk through the 252 days
        for (int day = 0; day < 252; ++day)
        {
            // A. Get new random shock for TODAY
            double Z = dist(gen);

            // B. Evolve the price (Note the *= operator)
            // We use 'currentStockPrice' on both sides so it updates!
            currentStockPrice *= std::exp(driftInDay + diffusionInDay * Z);

            // C. Check Barrier
            if (currentStockPrice <= barrierPrice)
            {
                isKnockedOut = true;
                break;
            }
        }

        // D. Calculate Payoff ONLY at the end, if not knocked out
        double payoff = 0.0;
        if (!isKnockedOut)
        {
            payoff = std::max(currentStockPrice - strikePrice, 0.0);
        }
        totalPayoff += payoff;

        // Save data (Only need final price for histogram)
        if (i < 100)
        {
            file << i << "," << currentStockPrice << "\n";
        }
    }
    file.close();

    // 4. Discount to Present Value
    double averagePayoff = totalPayoff / N;
    return averagePayoff * std::exp(-riskFreeRate * timeInYears);
}

int main()
{
    Stock apple;
    apple.symbol = "AAPL";
    apple.price = 100.0;
    apple.volatility = 0.2; // 20% Volatility

    double strikePrice = 100.0;
    double r = 0.05; // 5% Risk Free Rate
    double T = 1.0;  // 1 Year
    int N = 100000;  // 100k Simulations

    std::cout << "Starting Simulation for " << apple.symbol << "..." << std::endl;

    // MEASURING LATENCY
    auto start = std::chrono::high_resolution_clock::now();

    double optionPrice = MonteCarloSimulator(apple, strikePrice, T, r, N);

    auto end = std::chrono::high_resolution_clock::now();

    std::chrono::duration<double> elapsed = end - start;

    std::cout << "--------------------------------" << std::endl;
    std::cout << "Theoretical Option Price: " << optionPrice << std::endl;
    std::cout << "Time Taken: " << elapsed.count() << " seconds" << std::endl;
    std::cout << "Simulations per Second: " << (N / elapsed.count()) << std::endl;
    std::cout << "Data saved to 'simulation_data.csv'" << std::endl;

    return 0;
}