The idea was to create some practical means for transforming random number paths into asset price paths, following any desired (one-factor) stochastic process. For this purpose, I have created one template class (PathGenerator), which is technically just a wrapper for RandomGenerator template class and OneFactorProcess polymorphic class hierarchy. The purpose of

**RandomGenerator**is to produce random numbers from desired probability distribution (usually that is standard normal) and the purpose of

**OneFactorProcess**implementation is to provide information for PathGenerator on how to calculate drift and diffusion coefficients for a chosen stochastic process.

## PATHS

For a marketing reasons, let us see the end product first. Simulated asset price paths for Geometric Brownian Motion and Vasicek processes are presented in Excel screenshot below. Test program (presented below) has been created in a way, that all processed asset price paths for a chosen stochastic process are exported into CSV file (which can then be imported into Excel for further investigation).

## ONE-FACTOR PROCESS

Abstract base class (OneFactorProcess) is technically just an interface, which provides practical means for a client for customizing drift and diffusion functions for different types of stochastic processes. I decided to implement polymorphic class hierarchy, since class is still pretty compact place for storing private member data and corresponding algorithms using that member data.

In the first draft, I was actually implementing drift and diffusion coefficient algorithms by using functions and lambdas, which (being initially created in main program) would then have been used inside PathGenerator object. It was technically working well, but from the viewpoint of possible end user (say, having member data and algorithm implementations in different files) it would have been quite a different story.

#pragma once // namespace MikeJuniperhillOneFactorProcessLibrary { /// <summary> /// Abstract base class for all one-factor processes /// is technically just an interface, which provides practical means /// for customizing drift and diffusion functions for different types of processes. /// </summary> class OneFactorProcess { public: virtual double drift(double x, double t) = 0; virtual double diffusion(double x, double t) = 0; }; // /// <summary> /// Implementation for Vasicek short-rate model. /// </summary> class Vasicek : public OneFactorProcess { public: Vasicek(double meanReversion, double longTermRate, double rateVolatility) : meanReversion(meanReversion), longTermRate(longTermRate), rateVolatility(rateVolatility) { } double drift(double x, double t) override { return meanReversion * (longTermRate - x); } double diffusion(double x, double t) override { return rateVolatility; } private: double meanReversion; double longTermRate; double rateVolatility; }; // /// <summary> /// Implementation for Geometric Brownian Motion. /// </summary> class GBM : public OneFactorProcess { public: GBM(double rate, double volatility) : rate(rate), volatility(volatility) { } double drift(double x, double t) override { return rate * x; } double diffusion(double x, double t) override { return x * volatility; } private: double rate; double volatility; }; }

## PATH GENERATOR

PathGenerator object is using RandomGenerator object for creating random numbers from standard normal probability distribution, by using default seeder for default uniform generator (Mersenne Twister). At some point, this class was having several different constructors for client-given seeder and client-given probability distribution. However, for the sake of clarity, I decided to remove all that optionality. In most of the cases, we want to simulate random numbers from standard normal distribution and Mersenne Twister generator still does the uniform part pretty well. It should be noted, that if such a customizing need sometimes arises, this class can be modified accordingly.

#pragma once // #include "RandomGenerator.h" #include "OneFactorProcess.h" namespace MJRandom = MikeJuniperhillRandomGeneratorTemplate; namespace MJProcess = MikeJuniperhillOneFactorProcessLibrary; // template <typename Generator = std::mt19937, typename Distribution = std::normal_distribution<double>> class PathGenerator { public: /// <summary> /// Constructor for PathGenerator template class. /// <para> - using default seeder from chrono library </para> /// <para> - using standard normal distribution </para> /// <para> - using mersenne twister uniform generator </para> /// </summary> PathGenerator(double spot, double maturity, std::shared_ptr<MJProcess::OneFactorProcess>& process) : spot(spot), maturity(maturity), process(process) { // create default seeder lambda function for random generator this->seeder = [](void) -> unsigned long { return static_cast<unsigned long> (std::chrono::steady_clock::now().time_since_epoch().count()); }; // create random generator generator = std::unique_ptr<MJRandom::RandomGenerator<Generator, Distribution>> (new MJRandom::RandomGenerator<Generator, Distribution>(this->seeder)); } /// <summary> /// Functor, which fills auxiliary vector reference with asset prices following a given stochastic process. /// </summary> void operator()(std::vector<double>& v) { // transform initialized vector into a path containing random numbers (*generator)(v); // double dt = maturity / (v.size() - 1); double dw = 0.0; double s = spot; double t = 0.0; v[0] = s; // 1st path element is always the current spot price // // transform random number vector into a path containing asset prices for (auto it = v.begin() + 1; it != v.end(); ++it) { t += dt; dw = (*it) * std::sqrt(dt); (*it) = s + (*process).drift(s, t) * dt + (*process).diffusion(s, t) * dw; s = (*it); } } private: double spot; double maturity; std::function<unsigned long(void)> seeder; std::shared_ptr<MJProcess::OneFactorProcess> process; std::unique_ptr<MJRandom::RandomGenerator<Generator, Distribution>> generator; };

## TESTER

Presented test program is creating two different one-factor processes (Geometric Brownian Motion, Vasicek) and using PathGenerator for simulating asset price paths. All processed paths for the both cases will then be printed into CSV file for further investigations (Excel). I dare to say, that the process of generating asset price paths for one-factor process is easy and straightforward with PathGenerator class. For testing purposes, RandomGenerator header file should be included in the project.

#include "PathGenerator.h" #include <fstream> // // printer : after a simulation iteration, append a path content into a file // this inefficient idiom is not suitable for anything else but crude testing void Print(const std::vector<double>& v, const std::string& filePathName) { std::ofstream file(filePathName, std::ios_base::app); for (auto& element : v) { file << std::to_string(element) << ";"; } file << std::endl; } // int main() { // define and delete output CSV test files const std::string fileForVasicekProcess = "C:\\temp\\paths.vasicek.csv"; const std::string fileForBrownianMotion = "C:\\temp\\paths.brownianMotion.csv"; std::remove(fileForVasicekProcess.c_str()); std::remove(fileForBrownianMotion.c_str()); // // create auxiliary vector container for path processing double t = 3.0; // time to maturity int nPaths = 250; // number of simulated paths int nSteps = 1095; // number of time steps in one path (3 years * 365 days = 1095 steps) // the size of vector must be the number of desired time steps // plus one, since the first vector item will be the current asset spot price std::vector<double> path(nSteps + 1); // // example 1 : create paths using vasicek process double r = 0.0095; double longTermRate = 0.05; double meanReversion = 0.2; double rateVolatility = 0.0075; std::shared_ptr<MJProcess::OneFactorProcess> vasicek = std::shared_ptr<MJProcess::Vasicek>(new MJProcess::Vasicek(meanReversion, longTermRate, rateVolatility)); PathGenerator<> shortRateProcess(r, t, vasicek); for (int i = 0; i != nPaths; ++i) { shortRateProcess(path); // generate a path Print(path, fileForVasicekProcess); // print a path } // // example 2 : create paths using geometric brownian process double s = 100.0; double rate = 0.02; double volatility = 0.25; std::shared_ptr<MJProcess::OneFactorProcess> brownianMotion = std::shared_ptr<MJProcess::GBM>(new MJProcess::GBM(rate, volatility)); PathGenerator<> equityPriceProcess(s, t, brownianMotion); for (int i = 0; i != nPaths; ++i) { equityPriceProcess(path); // generate a path Print(path, fileForBrownianMotion); // print a path } return 0; }

Finally, thanks for reading my blog and have a very pleasant waiting time for Christmas.

-Mike

## No comments:

## Post a Comment