#include <ored/scripting/models/blackscholes.hpp>

Inheritance diagram for BlackScholes:

Collaboration diagram for BlackScholes:

Public Member Functions
	BlackScholes (const Size paths, const std::vector< std::string > &currencies, const std::vector< Handle< YieldTermStructure > > &curves, const std::vector< Handle< Quote > > &fxSpots, const std::vector< std::pair< std::string, QuantLib::ext::shared_ptr< InterestRateIndex > > > &irIndices, const std::vector< std::pair< std::string, QuantLib::ext::shared_ptr< ZeroInflationIndex > > > &infIndices, const std::vector< std::string > &indices, const std::vector< std::string > &indexCurrencies, const Handle< BlackScholesModelWrapper > &model, const std::map< std::pair< std::string, std::string >, Handle< QuantExt::CorrelationTermStructure > > &correlations, const McParams &mcParams, const std::set< Date > &simulationDates, const IborFallbackConfig &iborFallbackConfig=IborFallbackConfig::defaultConfig(), const std::string &calibration="ATM", const std::map< std::string, std::vector< Real > > &calibrationStrikes={})

	BlackScholes (const Size paths, const std::string &currency, const Handle< YieldTermStructure > &curve, const std::string &index, const std::string &indexCurrency, const Handle< BlackScholesModelWrapper > &model, const McParams &mcParams, const std::set< Date > &simulationDates, const IborFallbackConfig &iborFallbackConfig=IborFallbackConfig::defaultConfig(), const std::string &calibration="ATM", const std::vector< Real > &calibrationStrikes={})

Public Member Functions inherited from BlackScholesBase
	BlackScholesBase (const Size paths, const std::vector< std::string > &currencies, const std::vector< Handle< YieldTermStructure > > &curves, const std::vector< Handle< Quote > > &fxSpots, const std::vector< std::pair< std::string, QuantLib::ext::shared_ptr< InterestRateIndex > > > &irIndices, const std::vector< std::pair< std::string, QuantLib::ext::shared_ptr< ZeroInflationIndex > > > &infIndices, const std::vector< std::string > &indices, const std::vector< std::string > &indexCurrencies, const Handle< BlackScholesModelWrapper > &model, const std::map< std::pair< std::string, std::string >, Handle< QuantExt::CorrelationTermStructure > > &correlations, const McParams &mcParams, const std::set< Date > &simulationDates, const IborFallbackConfig &iborFallbackConfig)

	BlackScholesBase (const Size paths, const std::string &currency, const Handle< YieldTermStructure > &curve, const std::string &index, const std::string &indexCurrency, const Handle< BlackScholesModelWrapper > &model, const Model::McParams &mcParams, const std::set< Date > &simulationDates, const IborFallbackConfig &iborFallbackConfig)

Type	type () const override

const Date &	referenceDate () const override

RandomVariable	npv (const RandomVariable &amount, const Date &obsdate, const Filter &filter, const boost::optional< long > &memSlot, const RandomVariable &addRegressor1, const RandomVariable &addRegressor2) const override

RandomVariable	fwdCompAvg (const bool isAvg, const std::string &index, const Date &obsdate, const Date &start, const Date &end, const Real spread, const Real gearing, const Integer lookback, const Natural rateCutoff, const Natural fixingDays, const bool includeSpread, const Real cap, const Real floor, const bool nakedOption, const bool localCapFloor) const override

void	releaseMemory () override

void	resetNPVMem () override

void	toggleTrainingPaths () const override

Size	trainingSamples () const override

Size	size () const override

Public Member Functions inherited from ModelImpl
	ModelImpl (const DayCounter &dayCounter, const Size size, const std::vector< std::string > &currencies, const std::vector< std::pair< std::string, QuantLib::ext::shared_ptr< InterestRateIndex > > > &irIndices, const std::vector< std::pair< std::string, QuantLib::ext::shared_ptr< ZeroInflationIndex > > > &infIndices, const std::vector< std::string > &indices, const std::vector< std::string > &indexCurrencies, const std::set< Date > &simulationDates, const IborFallbackConfig &iborFallbackConfig)

const std::string &	baseCcy () const override

Real	dt (const Date &d1, const Date &d2) const override

RandomVariable	pay (const RandomVariable &amount, const Date &obsdate, const Date &paydate, const std::string &currency) const override

RandomVariable	discount (const Date &obsdate, const Date &paydate, const std::string &currency) const override

RandomVariable	eval (const std::string &index, const Date &obsdate, const Date &fwddate, const bool returnMissingMissingAsNull=false, const bool ignoreTodaysFixing=false) const override

Real	fxSpotT0 (const std::string &forCcy, const std::string &domCcy) const override

RandomVariable	barrierProbability (const std::string &index, const Date &obsdate1, const Date &obsdate2, const RandomVariable &barrier, const bool above) const override

Real	extractT0Result (const RandomVariable &value) const override

Public Member Functions inherited from Model
	Model (const Size n)

virtual	~Model ()

virtual Type	type () const =0

virtual Size	size () const

virtual Size	trainingSamples () const

virtual void	toggleTrainingPaths () const

virtual const Date &	referenceDate () const =0

virtual const std::string &	baseCcy () const =0

virtual Real	dt (const Date &d1, const Date &d2) const

Real	timeFromReference (const Date &d) const

virtual RandomVariable	pay (const RandomVariable &amount, const Date &obsdate, const Date &paydate, const std::string &currency) const =0

virtual RandomVariable	discount (const Date &obsdate, const Date &paydate, const std::string &currency) const =0

virtual RandomVariable	npv (const RandomVariable &amount, const Date &obsdate, const Filter &filter, const boost::optional< long > &memSlot, const RandomVariable &addRegressor1, const RandomVariable &addRegressor2) const =0

virtual RandomVariable	eval (const std::string &index, const Date &obsdate, const Date &fwddate, const bool returnMissingFixingAsNull=false, const bool ignoreTodaysFixing=false) const =0

virtual RandomVariable	fwdCompAvg (const bool isAvg, const std::string &index, const Date &obsdate, const Date &start, const Date &end, const Real spread, const Real gearing, const Integer lookback, const Natural rateCutoff, const Natural fixingDays, const bool includeSpread, const Real cap, const Real floor, const bool nakedOption, const bool localCapFloor) const =0

virtual RandomVariable	barrierProbability (const std::string &index, const Date &obsdate1, const Date &obsdate2, const RandomVariable &barrier, const bool above) const =0

virtual Real	fxSpotT0 (const std::string &forCcy, const std::string &domCcy) const =0

virtual Real	extractT0Result (const RandomVariable &value) const =0

virtual void	releaseMemory ()

virtual void	resetNPVMem ()

const std::map< std::string, boost::any > &	additionalResults () const

Private Member Functions
RandomVariable	getFutureBarrierProb (const std::string &index, const Date &obsdate1, const Date &obsdate2, const RandomVariable &barrier, const bool above) const override

void	performCalculations () const override

void	populatePathValues (const Size nSamples, std::map< Date, std::vector< RandomVariable > > &paths, const QuantLib::ext::shared_ptr< MultiPathVariateGeneratorBase > &gen, const std::vector< Array > &drift, const std::vector< Matrix > &sqrtCov) const

Private Attributes
std::vector< Matrix >	covariance_

const std::string	calibration_

const std::map< std::string, std::vector< Real > >	calibrationStrikes_

Additional Inherited Members
Public Types inherited from Model
enum class	Type { MC , FD }

Protected Member Functions inherited from BlackScholesBase
void	performCalculations () const override

RandomVariable	getIndexValue (const Size indexNo, const Date &d, const Date &fwd=Null< Date >()) const override

RandomVariable	getIrIndexValue (const Size indexNo, const Date &d, const Date &fwd=Null< Date >()) const override

RandomVariable	getInfIndexValue (const Size indexNo, const Date &d, const Date &fwd=Null< Date >()) const override

RandomVariable	getDiscount (const Size idx, const Date &s, const Date &t) const override

RandomVariable	getNumeraire (const Date &s) const override

Real	getFxSpot (const Size idx) const override

Matrix	getCorrelation () const

virtual RandomVariable	getIndexValue (const Size indexNo, const Date &d, const Date &fwd=Null< Date >()) const =0

virtual RandomVariable	getIrIndexValue (const Size indexNo, const Date &d, const Date &fwd=Null< Date >()) const =0

virtual RandomVariable	getInfIndexValue (const Size indexNo, const Date &d, const Date &fwd) const =0

virtual RandomVariable	getDiscount (const Size idx, const Date &s, const Date &t) const =0

virtual RandomVariable	getNumeraire (const Date &s) const =0

virtual Real	getFxSpot (const Size idx) const =0

virtual RandomVariable	getFutureBarrierProb (const std::string &index, const Date &obsdate1, const Date &obsdate2, const RandomVariable &barrier, const bool above) const =0

Protected Member Functions inherited from Model
void	performCalculations () const override

Protected Attributes inherited from BlackScholesBase
const std::vector< Handle< YieldTermStructure > >	curves_

const std::vector< Handle< Quote > >	fxSpots_

const Handle< BlackScholesModelWrapper >	model_

const std::map< std::pair< std::string, std::string >, Handle< QuantExt::CorrelationTermStructure > >	correlations_

const McParams	mcParams_

const std::vector< Date >	simulationDates_

Date	referenceDate_

std::set< Date >	effectiveSimulationDates_

TimeGrid	timeGrid_

std::vector< Size >	positionInTimeGrid_

std::map< Date, std::vector< RandomVariable > >	underlyingPaths_

std::map< Date, std::vector< RandomVariable > >	underlyingPathsTraining_

bool	inTrainingPhase_ = false

std::map< long, std::tuple< Array, Size, Matrix > >	storedRegressionModel_

Protected Attributes inherited from ModelImpl
const DayCounter	dayCounter_

const std::vector< std::string >	currencies_

const std::vector< std::string >	indexCurrencies_

const std::set< Date >	simulationDates_

const IborFallbackConfig	iborFallbackConfig_

std::vector< std::pair< IndexInfo, QuantLib::ext::shared_ptr< InterestRateIndex > > >	irIndices_

std::vector< std::pair< IndexInfo, QuantLib::ext::shared_ptr< ZeroInflationIndex > > >	infIndices_

std::vector< IndexInfo >	indices_

Protected Attributes inherited from Model
std::map< std::string, boost::any >	additionalResults_

Detailed Description

Definition at line 33 of file blackscholes.hpp.

Constructor & Destructor Documentation

◆ BlackScholes() [1/2]

BlackScholes	(	const Size	paths,
		const std::vector< std::string > &	currencies,
		const std::vector< Handle< YieldTermStructure > > &	curves,
		const std::vector< Handle< Quote > > &	fxSpots,
		const std::vector< std::pair< std::string, QuantLib::ext::shared_ptr< InterestRateIndex > > > &	irIndices,
		const std::vector< std::pair< std::string, QuantLib::ext::shared_ptr< ZeroInflationIndex > > > &	infIndices,
		const std::vector< std::string > &	indices,
		const std::vector< std::string > &	indexCurrencies,
		const Handle< BlackScholesModelWrapper > &	model,
		const std::map< std::pair< std::string, std::string >, Handle< QuantExt::CorrelationTermStructure > > &	correlations,
		const McParams &	mcParams,
		const std::set< Date > &	simulationDates,
		const IborFallbackConfig &	iborFallbackConfig = `IborFallbackConfig::defaultConfig()`,
		const std::string &	calibration = `"ATM"`,
		const std::map< std::string, std::vector< Real > > &	calibrationStrikes = `{}`
	)

Definition at line 42 of file blackscholes.cpp.

    : BlackScholesBase(paths, currencies, curves, fxSpots, irIndices, infIndices, indices, indexCurrencies, model,
                       correlations, mcParams, simulationDates, iborFallbackConfig),
      calibration_(calibration), calibrationStrikes_(calibrationStrikes) {}

◆ BlackScholes() [2/2]

BlackScholes	(	const Size	paths,
		const std::string &	currency,
		const Handle< YieldTermStructure > &	curve,
		const std::string &	index,
		const std::string &	indexCurrency,
		const Handle< BlackScholesModelWrapper > &	model,
		const McParams &	mcParams,
		const std::set< Date > &	simulationDates,
		const IborFallbackConfig &	iborFallbackConfig = `IborFallbackConfig::defaultConfig()`,
		const std::string &	calibration = `"ATM"`,
		const std::vector< Real > &	calibrationStrikes = `{}`
	)

Definition at line 34 of file blackscholes.cpp.

39 : BlackScholes(paths, {currency}, {curve}, {}, {}, {}, {index}, {indexCurrency}, model, {}, mcParams,

40 simulationDates, iborFallbackConfig, calibration, {{index, calibrationStrikes}}) {}

ore::data::BlackScholes::BlackScholes

BlackScholes(const Size paths, const std::vector< std::string > &currencies, const std::vector< Handle< YieldTermStructure > > &curves, const std::vector< Handle< Quote > > &fxSpots, const std::vector< std::pair< std::string, QuantLib::ext::shared_ptr< InterestRateIndex > > > &irIndices, const std::vector< std::pair< std::string, QuantLib::ext::shared_ptr< ZeroInflationIndex > > > &infIndices, const std::vector< std::string > &indices, const std::vector< std::string > &indexCurrencies, const Handle< BlackScholesModelWrapper > &model, const std::map< std::pair< std::string, std::string >, Handle< QuantExt::CorrelationTermStructure > > &correlations, const McParams &mcParams, const std::set< Date > &simulationDates, const IborFallbackConfig &iborFallbackConfig=IborFallbackConfig::defaultConfig(), const std::string &calibration="ATM", const std::map< std::string, std::vector< Real > > &calibrationStrikes={})

Definition: blackscholes.cpp:42

Member Function Documentation

◆ getFutureBarrierProb()

RandomVariable getFutureBarrierProb	(	const std::string &	index,
		const Date &	obsdate1,
		const Date &	obsdate2,
		const RandomVariable &	barrier,
		const bool	above
	)		const

overrideprivatevirtual

Implements ModelImpl.

Definition at line 292 of file blackscholes.cpp.

                                                                                                         {
 
    // get the underlying values at the start and end points of the period
 
    RandomVariable v1 = eval(index, obsdate1, Null<Date>());
    RandomVariable v2 = eval(index, obsdate2, Null<Date>());
 
    // check the barrier at the two endpoints
 
    Filter barrierHit(barrier.size(), false);
    if (above) {
        barrierHit = barrierHit || v1 >= barrier;
        barrierHit = barrierHit || v2 >= barrier;
    } else {
        barrierHit = barrierHit || v1 <= barrier;
        barrierHit = barrierHit || v2 <= barrier;
    }
 
    // for IR / INF indices we have to check each date, this is fast though, since the index values are deteministic
    // here
 
    auto ir = std::find_if(irIndices_.begin(), irIndices_.end(), comp(index));
    auto inf = std::find_if(infIndices_.begin(), infIndices_.end(), comp(index));
    if (ir != irIndices_.end() || inf != infIndices_.end()) {
        Date d = obsdate1 + 1;
        while (d < obsdate2) {
            RandomVariable res;
            if (ir != irIndices_.end())
                res = getIrIndexValue(std::distance(irIndices_.begin(), ir), d);
            else
                res = getInfIndexValue(std::distance(infIndices_.begin(), inf), d);
            if (res.initialised()) {
                if (above) {
                    barrierHit = barrierHit || res >= barrier;
                } else {
                    barrierHit = barrierHit || res <= barrier;
                }
            }
            ++d;
        }
    }
 
    // Convert the bool result we have obtained so far to 1 / 0
 
    RandomVariable result(barrierHit, 1.0, 0.0);
 
    // return the result if we have an IR / INF index
 
    if (ir != irIndices_.end() || inf != infIndices_.end())
        return result;
 
    // Now handle the dynamic indices in this model
 
    // first make sure that v1 is not a historical fixing to avoid differences to a daily MC simulation where
    // the process starts to evolve at the market data spot (only matters if the two values differ, which they
    // should not too much anyway)
 
    if (obsdate1 == referenceDate()) {
        v1 = eval(index, obsdate1, Null<Date>(), false, true);
    }
 
    IndexInfo indexInfo(index);
 
    // if we have an FX index, we "normalise" the tag by GENERIC (since it does not matter for projections), this
    // is the same as in ModelImpl::eval()
 
    if (indexInfo.isFx())
        indexInfo = IndexInfo("FX-GENERIC-" + indexInfo.fx()->sourceCurrency().code() + "-" +
                              indexInfo.fx()->targetCurrency().code());
 
    // get the average volatility over the period for the underlying, this is an approximation that could be refined
    // by sampling more points in the interval and doing the below calculation for each subinterval - this would
    // be slower though, so probably in the end we want this to be configurable in the model settings
 
    // We might have one or two indices contributing to the desired volatility, since FX indices might require a
    // triangulation. We look for the indices ind1 and ind2 so that the index is the quotient of the two.
 
    Size ind1 = Null<Size>(), ind2 = Null<Size>();
 
    auto i = std::find(indices_.begin(), indices_.end(), indexInfo);
    if (i != indices_.end()) {
        // we find the index directly in the index list
        ind1 = std::distance(indices_.begin(), i);
    } else {
        // we can maybe triangulate an FX index (again, this is similar to ModelImpl::eval())
        // if not, we can only try something else for FX indices
        QL_REQUIRE(indexInfo.isFx(), "BlackScholes::getFutureBarrierProb(): index " << index << " not handled");
        // is it a trivial fx index (CCY-CCY) or can we triangulate it?
        if (indexInfo.fx()->sourceCurrency() == indexInfo.fx()->targetCurrency()) {
            // pseudo FX index FX-GENERIC-CCY-CCY, leave ind1 and ind2 both set to zero
        } else {
            // if not, we can only try something else for FX indices
            QL_REQUIRE(indexInfo.isFx(), "BlackScholes::getFutureBarrierProb(): index " << index << " not handled");
            if (indexInfo.fx()->sourceCurrency() == indexInfo.fx()->targetCurrency()) {
                // nothing to do, leave ind1 and ind2 = null
            } else {
                for (Size i = 0; i < indexCurrencies_.size(); ++i) {
                    if (indices_[i].isFx()) {
                        if (indexInfo.fx()->sourceCurrency().code() == indexCurrencies_[i])
                            ind1 = i;
                        if (indexInfo.fx()->targetCurrency().code() == indexCurrencies_[i])
                            ind2 = i;
                    }
                }
            }
        }
    }
 
    // accumulate the variance contributions over [obsdate1, obsdate2]
 
    Real variance = 0.0;
 
    for (Size i = 1; i < effectiveSimulationDates_.size(); ++i) {
 
        Date d1 = *std::next(effectiveSimulationDates_.begin(), i - 1);
        Date d2 = *std::next(effectiveSimulationDates_.begin(), i);
 
        if (obsdate1 <= d1 && d2 <= obsdate2) {
            if (ind1 != Null<Size>()) {
                variance += covariance_[i - 1][ind1][ind1];
            }
            if (ind2 != Null<Size>()) {
                variance += covariance_[i - 1][ind2][ind2];
            }
            if (ind1 != Null<Size>() && ind2 != Null<Size>()) {
                variance -= 2.0 * covariance_[i - 1][ind1][ind2];
            }
        }
    }
 
    // compute the hit probability
    // see e.g. formulas 2, 4 in Emmanuel Gobet, Advanced Monte Carlo methods for barrier and related exotic options
 
    if (!QuantLib::close_enough(variance, 0.0)) {
        RandomVariable eps = RandomVariable(barrier.size(), 1E-14);
        RandomVariable hitProb = exp(RandomVariable(barrier.size(), -2.0 / variance) * log(v1 / max(barrier, eps)) *
                                     log(v2 / max(barrier, eps)));
        result = result + applyInverseFilter(hitProb, barrierHit);
    }
 
    return result;
}

Here is the call graph for this function:

◆ performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 56 of file blackscholes.cpp.

                                             {
 
    BlackScholesBase::performCalculations();
 
    // nothing to do if we do not have any indices
 
    if (indices_.empty())
        return;
 
    // init underlying path where we map a date to a randomvariable representing the path values
 
    for (auto const& d : effectiveSimulationDates_) {
        underlyingPaths_[d] = std::vector<RandomVariable>(model_->processes().size(), RandomVariable(size(), 0.0));
        if (trainingSamples() != Null<Size>())
            underlyingPathsTraining_[d] =
                std::vector<RandomVariable>(model_->processes().size(), RandomVariable(trainingSamples(), 0.0));
    }
 
    // compile the correlation matrix
 
    Matrix correlation = getCorrelation();
 
    // determine calibration strikes
 
    std::vector<Real> calibrationStrikes;
    if (calibration_ == "ATM") {
        calibrationStrikes.resize(indices_.size(), Null<Real>());
    } else if (calibration_ == "Deal") {
        for (Size i = 0; i < indices_.size(); ++i) {
            auto f = calibrationStrikes_.find(indices_[i].name());
            if (f != calibrationStrikes_.end() && !f->second.empty()) {
                calibrationStrikes.push_back(f->second[0]);
                TLOG("calibration strike for index '" << indices_[i] << "' is " << f->second[0]);
            } else {
                calibrationStrikes.push_back(Null<Real>());
                TLOG("calibration strike for index '" << indices_[i] << "' is ATMF");
            }
        }
    } else {
        QL_FAIL("BlackScholes: calibration '" << calibration_ << "' not supported, expected ATM, Deal");
    }
 
    // set reference date values, if there are no future simulation dates we are done
 
    for (Size l = 0; l < indices_.size(); ++l) {
        underlyingPaths_[*effectiveSimulationDates_.begin()][l].setAll(model_->processes()[l]->x0());
        if (trainingSamples() != Null<Size>()) {
            underlyingPathsTraining_[*effectiveSimulationDates_.begin()][l].setAll(model_->processes()[l]->x0());
        }
    }
 
    if (effectiveSimulationDates_.size() == 1)
        return;
 
    // compute drift and covariances of log spots to evolve the process; the covariance computation is done
    // on the refined grid where we assume the volatilities to be constant
 
    // used for dirf adjustment eq / com that are not in base ccy below
    std::vector<Size> forCcyDaIndex(indices_.size(), Null<Size>());
    for (Size j = 0; j < indices_.size(); ++j) {
        if (!indices_[j].isFx()) {
            // do we have an fx index with the desired currency?
            for (Size jj = 0; jj < indices_.size(); ++jj) {
                if (indices_[jj].isFx()) {
                    if (indexCurrencies_[jj] == indexCurrencies_[j])
                        forCcyDaIndex[j] = jj;
                }
            }
        }
    }
 
    std::vector<Array> drift(effectiveSimulationDates_.size() - 1, Array(indices_.size(), 0.0));
    std::vector<Matrix> sqrtCov;
    covariance_ =
        std::vector<Matrix>(effectiveSimulationDates_.size() - 1, Matrix(indices_.size(), indices_.size(), 0.0));
    Array variance(indices_.size(), 0.0), discountRatio(indices_.size(), 1.0);
    Size tidx = 1; // index in the refined time grid
 
    for (Size i = 1; i < effectiveSimulationDates_.size(); ++i) {
 
        // covariance
 
        while (tidx <= positionInTimeGrid_[i]) {
            Array d_variance(indices_.size());
            for (Size j = 0; j < indices_.size(); ++j) {
                Real tmp = model_->processes()[j]->blackVolatility()->blackVariance(
                    timeGrid_[tidx],
                    calibrationStrikes[j] == Null<Real>()
                        ? atmForward(model_->processes()[j]->x0(), model_->processes()[j]->riskFreeRate(),
                                     model_->processes()[j]->dividendYield(), timeGrid_[tidx])
                        : calibrationStrikes[j]);
                d_variance[j] = std::max(tmp - variance[j], 1E-20);
                variance[j] = tmp;
            }
            for (Size j = 0; j < indices_.size(); ++j) {
                covariance_[i - 1][j][j] += d_variance[j];
                for (Size k = 0; k < j; ++k) {
                    Real tmp = correlation[k][j] * std::sqrt(d_variance[j] * d_variance[k]);
                    covariance_[i - 1][k][j] += tmp;
                    covariance_[i - 1][j][k] += tmp;
                }
            }
            ++tidx;
        }
 
        // salvage covariance matrix using spectral method if not positive semidefinite
 
        SymmetricSchurDecomposition jd(covariance_[i - 1]);
 
        bool needsSalvaging = false;
        for (Size k = 0; k < covariance_[i - 1].rows(); ++k) {
            if (jd.eigenvalues()[k] < -1E-16)
                needsSalvaging = true;
        }
 
        if (needsSalvaging) {
            Matrix diagonal(covariance_[i - 1].rows(), covariance_[i - 1].rows(), 0.0);
            for (Size k = 0; k < jd.eigenvalues().size(); ++k) {
                diagonal[k][k] = std::sqrt(std::max<Real>(jd.eigenvalues()[k], 0.0));
            }
            covariance_[i - 1] = jd.eigenvectors() * diagonal * diagonal * transpose(jd.eigenvectors());
        }
 
        // compute the _unique_ pos semidefinite square root
 
        sqrtCov.push_back(CholeskyDecomposition(covariance_[i - 1], true));
 
        // drift
 
        Date d = *std::next(effectiveSimulationDates_.begin(), i);
        for (Size j = 0; j < indices_.size(); ++j) {
            Real tmp = model_->processes()[j]->riskFreeRate()->discount(d) /
                       model_->processes()[j]->dividendYield()->discount(d);
            drift[i - 1][j] = -std::log(tmp / discountRatio[j]) - 0.5 * covariance_[i - 1][j][j];
            discountRatio[j] = tmp;
 
            // drift adjustment for eq / com indices that are not in base ccy
            if (forCcyDaIndex[j] != Null<Size>()) {
                drift[i - 1][j] -= covariance_[i - 1][forCcyDaIndex[j]][j];
            }
        }
    }
 
    // evolve the process using correlated normal variates and set the underlying path values
 
    populatePathValues(size(), underlyingPaths_,
                       makeMultiPathVariateGenerator(mcParams_.sequenceType, indices_.size(),
                                                     effectiveSimulationDates_.size() - 1, mcParams_.seed,
                                                     mcParams_.sobolOrdering, mcParams_.sobolDirectionIntegers),
                       drift, sqrtCov);
 
    if (trainingSamples() != Null<Size>()) {
        populatePathValues(trainingSamples(), underlyingPathsTraining_,
                           makeMultiPathVariateGenerator(mcParams_.trainingSequenceType, indices_.size(),
                                                         effectiveSimulationDates_.size() - 1, mcParams_.trainingSeed,
                                                         mcParams_.sobolOrdering, mcParams_.sobolDirectionIntegers),
                           drift, sqrtCov);
    }
 
    // set additional results provided by this model
 
    for (Size i = 0; i < indices_.size(); ++i) {
        for (Size j = 0; j < i; ++j) {
            additionalResults_["BlackScholes.Correlation_" + indices_[i].name() + "_" + indices_[j].name()] =
                correlation(i, j);
        }
    }
 
    for (Size i = 0; i < calibrationStrikes.size(); ++i) {
        additionalResults_["BlackScholes.CalibrationStrike_" + indices_[i].name()] =
            (calibrationStrikes[i] == Null<Real>() ? "ATMF" : std::to_string(calibrationStrikes[i]));
    }
 
    for (Size i = 0; i < indices_.size(); ++i) {
        Size timeStep = 0;
        for (auto const& d : effectiveSimulationDates_) {
            Real t = timeGrid_[positionInTimeGrid_[timeStep]];
            Real forward = atmForward(model_->processes()[i]->x0(), model_->processes()[i]->riskFreeRate(),
                                      model_->processes()[i]->dividendYield(), t);
            if (timeStep > 0) {
                Real volatility = model_->processes()[i]->blackVolatility()->blackVol(
                    t, calibrationStrikes[i] == Null<Real>() ? forward : calibrationStrikes[i]);
                additionalResults_["BlackScholes.Volatility_" + indices_[i].name() + "_" + ore::data::to_string(d)] =
                    volatility;
            }
            additionalResults_["BlackScholes.Forward_" + indices_[i].name() + "_" + ore::data::to_string(d)] = forward;
            ++timeStep;
        }
    }
}

Here is the call graph for this function:

◆ populatePathValues()

void populatePathValues	(	const Size	nSamples,
		std::map< Date, std::vector< RandomVariable > > &	paths,
		const QuantLib::ext::shared_ptr< MultiPathVariateGeneratorBase > &	gen,
		const std::vector< Array > &	drift,
		const std::vector< Matrix > &	sqrtCov
	)		const

private

Definition at line 247 of file blackscholes.cpp.

                                                                                                             {
 
    std::vector<std::vector<RandomVariable*>> rvs(indices_.size(),
                                                  std::vector<RandomVariable*>(effectiveSimulationDates_.size() - 1));
    auto date = effectiveSimulationDates_.begin();
    for (Size i = 0; i < effectiveSimulationDates_.size() - 1; ++i) {
        ++date;
        for (Size j = 0; j < indices_.size(); ++j) {
            rvs[j][i] = &paths[*date][j];
            rvs[j][i]->expand();
        }
    }
 
    Array logState(indices_.size()), logState0(indices_.size());
    for (Size j = 0; j < indices_.size(); ++j) {
        logState0[j] = std::log(model_->processes()[j]->x0());
    }
 
    for (Size path = 0; path < nSamples; ++path) {
        auto seq = gen->next();
        logState = logState0;
        for (Size i = 0; i < effectiveSimulationDates_.size() - 1; ++i) {
            for (Size j = 0; j < indices_.size(); ++j) {
                for (Size k = 0; k < indices_.size(); ++k)
                    logState[j] += sqrtCov[i][j][k] * seq.value[i][k];
            }
            logState += drift[i];
            for (Size j = 0; j < indices_.size(); ++j)
                rvs[j][i]->data()[path] = std::exp(logState[j]);
        }
    }
} // populatePathValues()

Here is the caller graph for this function:

Member Data Documentation

◆ covariance_

std::vector<Matrix> covariance_

mutableprivate

Definition at line 72 of file blackscholes.hpp.

◆ calibration_

const std::string calibration_

private

Definition at line 75 of file blackscholes.hpp.

◆ calibrationStrikes_

const std::map<std::string, std::vector<Real> > calibrationStrikes_

private

Definition at line 78 of file blackscholes.hpp.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BlackScholes() [1/2]

◆ BlackScholes() [2/2]

Member Function Documentation

◆ getFutureBarrierProb()

◆ performCalculations()

◆ populatePathValues()

Member Data Documentation

◆ covariance_

◆ calibration_

◆ calibrationStrikes_