C ++ 11 — C ++ Монте-Карло Портфель Pricer

Я разрабатываю оценщик портфельных опционов, используя Монте-Карло, но я столкнулся с проблемой. Моя программа компилируется и запускается. Тогда у меня есть вектор вне диапазона, когда программа должна вычислить цену портфеля. Что делать? Я приложил свой Portfolio.cpp и мой Monte Carlo.cpp,

PortFolio.cpp:

#include "Portfolio.h"#include <iostream>
#include <numeric>

Portfolio::Portfolio(const vector<VanillaOption>& Option_){

numberOfOptions = Option_.size();

for (unsigned int i = 0; i < getNumberOfOptions(); ++i) {
theOption.push_back(Option_[i].clone());
}

}

shared_ptr<Portfolio> Portfolio::clone() const {
return shared_ptr<Portfolio>(new Portfolio(*this));
}

void Portfolio::setOptionPrice(const double& price) {
optionPrice.push_back(price);
}

double Portfolio::getOptionPrice(const unsigned int& index)const {
return optionPrice[index];
}

double Portfolio::getNumberOfOptions()const {
return theOption.size();
}

double Portfolio::getPayOff(const unsigned int& index, const vector<double>&          spot) const {
return theOption[(int)index]->getPayOff(spot);
}

double Portfolio::getExpiry(const unsigned int& index)const {
return theOption[index]->getExpiry();
}

double Portfolio::getOptionValueP()const {
double sum = 0;

for (unsigned int i = 0; i <getNumberOfOptions(); i++) {sum  = std::accumulate(optionPrice.begin(), optionPrice.end(),0.0) * positionValue;
}

return sum;
}

Это моя реализация MonteCarlo для портфолио:

PortfolioSimulation::PortfolioSimulation(const unsigned long& numberOfPaths_,     const unsigned long& numberofTimeSteps_) {
setNumberOfPaths(numberOfPaths_);
setNumberOfTimeSteps(numberofTimeSteps_);
}

Portfolio PortfolioSimulation::operator()(
const Portfolio& thePortfolio_,
vector<UnderlyingAsset>& vTheAsset_,
const vector<shared_ptr<Process>>& vTheProcess_)const {

//Assign passing values to local variables
vector<shared_ptr<Process>> vTheProcess = vTheProcess_;
Portfolio thePortfolio = thePortfolio_;
vector<UnderlyingAsset> vTheAsset = vTheAsset_;

const unsigned int numberOfOptions = (int)thePortfolio.getNumberOfOptions();
vector<vector<double>> simulatedSpot(numberOfOptions,vector<double>(getNumberOfTimeSteps()));
vector<double> runningSum(numberOfOptions,1);
vector<double > mean(numberOfOptions,1);
vector<double> simulatedPayOff(numberOfOptions,1);
double time[2];

const double numberOfPaths = getNumberOfPaths();
const double numberOfTimeSteps = getNumberOfTimeSteps();

//Path simulation
for (unsigned int i = 0; i < numberOfPaths; i++) {

//Option
for (unsigned int j = 0; j < numberOfOptions; j++) {

//Initialise values every paths
const double step = thePortfolio.getExpiry(j) / getNumberOfTimeSteps();
vTheAsset[j] = vTheAsset_[j];
time[0] = 0;
time[1] = step;

//Time Steps
for (unsigned int k = 0; k < numberOfTimeSteps; k++) {

simulatedSpot[j][k] = (*vTheProcess[j])(vTheAsset[j], time[0], time[1]);
vTheAsset[j].setSpot(simulatedSpot[j][k]);
time[0] = time[1];
time[1] += step;

}

simulatedPayOff[j] = thePortfolio.getPayOff(j, simulatedSpot[j]);
runningSum[j] += simulatedPayOff[j];
}

}for (unsigned int i = 0; i < numberOfOptions; i++) {
mean[i] = runningSum[i] /getNumberOfPaths();
mean[i] *= exp(-vTheAsset[i].getRate()*thePortfolio.getExpiry(i));                  thePortfolio.setOptionPrice(mean[i]);
}

return thePortfolio;
}