BlackScholesCG Class Reference

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

Inheritance diagram for BlackScholesCG:

Collaboration diagram for BlackScholesCG:

Public Member Functions
	BlackScholesCG (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 std::set< Date > &simulationDates, const IborFallbackConfig &iborFallbackConfig=IborFallbackConfig::defaultConfig(), const std::string &calibration="ATM", const std::map< std::string, std::vector< Real > > &calibrationStrikes={})
	BlackScholesCG (const Size paths, const std::string &currency, const Handle< YieldTermStructure > &curve, const std::string &index, const std::string &indexCurrency, const Handle< BlackScholesModelWrapper > &model, 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 BlackScholesCGBase
	BlackScholesCGBase (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 std::set< Date > &simulationDates, const IborFallbackConfig &iborFallbackConfig)
	BlackScholesCGBase (const Size paths, const std::string &currency, const Handle< YieldTermStructure > &curve, const std::string &index, const std::string &indexCurrency, const Handle< BlackScholesModelWrapper > &model, const std::set< Date > &simulationDates, const IborFallbackConfig &iborFallbackConfig)
Type	type () const override
const Date &	referenceDate () const override
std::size_t	npv (const std::size_t amount, const Date &obsdate, const std::size_t filter, const boost::optional< long > &memSlot, const std::size_t addRegressor1, const std::size_t addRegressor2) const override
std::size_t	fwdCompAvg (const bool isAvg, const std::string &indexInput, 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
Real	getDirectFxSpotT0 (const std::string &forCcy, const std::string &domCcy) const override
Real	getDirectDiscountT0 (const Date &paydate, const std::string &currency) const override
Public Member Functions inherited from ModelCGImpl
	ModelCGImpl (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
std::size_t	dt (const Date &d1, const Date &d2) const override
std::size_t	pay (const std::size_t amount, const Date &obsdate, const Date &paydate, const std::string &currency) const override
std::size_t	discount (const Date &obsdate, const Date &paydate, const std::string &currency) const override
std::size_t	eval (const std::string &index, const Date &obsdate, const Date &fwddate, const bool returnMissingMissingAsNull=false, const bool ignoreTodaysFixing=false) const override
std::size_t	fxSpotT0 (const std::string &forCcy, const std::string &domCcy) const override
std::size_t	barrierProbability (const std::string &index, const Date &obsdate1, const Date &obsdate2, const std::size_t barrier, const bool above) const override
Real	extractT0Result (const RandomVariable &value) const override
std::size_t	cgVersion () const override
const std::vector< std::vector< std::size_t > > &	randomVariates () const override
std::vector< std::pair< std::size_t, double > >	modelParameters () const override
std::vector< std::pair< std::size_t, std::function< double(void)> > > &	modelParameterFunctors () const override
Public Member Functions inherited from ModelCG
	ModelCG (const QuantLib::Size n)
virtual	~ModelCG ()
QuantLib::ext::shared_ptr< QuantExt::ComputationGraph >	computationGraph ()
virtual Type	type () const =0
virtual QuantLib::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 std::size_t	dt (const Date &d1, const Date &d2) const
virtual std::size_t	pay (const std::size_t amount, const Date &obsdate, const Date &paydate, const std::string &currency) const =0
virtual std::size_t	discount (const Date &obsdate, const Date &paydate, const std::string &currency) const =0
virtual std::size_t	npv (const std::size_t amount, const Date &obsdate, const std::size_t filter, const boost::optional< long > &memSlot, const std::size_t addRegressor1, const std::size_t addRegressor2) const =0
virtual std::size_t	eval (const std::string &index, const Date &obsdate, const Date &fwddate, const bool returnMissingFixingAsNull=false, const bool ignoreTodaysFixing=false) const =0
virtual std::size_t	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 std::size_t	barrierProbability (const std::string &index, const Date &obsdate1, const Date &obsdate2, const std::size_t barrier, const bool above) const =0
virtual std::size_t	fxSpotT0 (const std::string &forCcy, const std::string &domCcy) const =0
virtual Real	extractT0Result (const QuantExt::RandomVariable &value) const =0
virtual void	resetNPVMem ()
const std::map< std::string, boost::any > &	additionalResults () const
virtual std::size_t	cgVersion () const =0
virtual const std::vector< std::vector< std::size_t > > &	randomVariates () const =0
virtual std::vector< std::pair< std::size_t, double > >	modelParameters () const =0
virtual std::vector< std::pair< std::size_t, std::function< double(void)> > > &	modelParameterFunctors () const =0
virtual Real	getDirectFxSpotT0 (const std::string &forCcy, const std::string &domCcy) const =0
virtual Real	getDirectDiscountT0 (const Date &paydate, const std::string &currency) const =0
void	calculate () const override

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

Private Attributes
const std::string	calibration_
const std::map< std::string, std::vector< Real > >	calibrationStrikes_

Additional Inherited Members
Public Types inherited from ModelCG
enum class	Type { MC , FD }
Protected Member Functions inherited from BlackScholesCGBase
void	performCalculations () const override
std::size_t	getIndexValue (const Size indexNo, const Date &d, const Date &fwd=Null< Date >()) const override
std::size_t	getIrIndexValue (const Size indexNo, const Date &d, const Date &fwd=Null< Date >()) const override
std::size_t	getInfIndexValue (const Size indexNo, const Date &d, const Date &fwd=Null< Date >()) const override
std::size_t	getDiscount (const Size idx, const Date &s, const Date &t) const override
std::size_t	getNumeraire (const Date &s) const override
std::size_t	getFxSpot (const Size idx) const override
Protected Member Functions inherited from ModelCGImpl
virtual std::size_t	getIndexValue (const Size indexNo, const Date &d, const Date &fwd=Null< Date >()) const =0
virtual std::size_t	getIrIndexValue (const Size indexNo, const Date &d, const Date &fwd=Null< Date >()) const =0
virtual std::size_t	getInfIndexValue (const Size indexNo, const Date &d, const Date &fwd) const =0
virtual std::size_t	getDiscount (const Size idx, const Date &s, const Date &t) const =0
virtual std::size_t	getNumeraire (const Date &s) const =0
virtual std::size_t	getFxSpot (const Size idx) const =0
virtual std::size_t	getFutureBarrierProb (const std::string &index, const Date &obsdate1, const Date &obsdate2, const std::size_t barrier, const bool above) const =0
std::size_t	addModelParameter (const std::string &id, std::function< double(void)> f) const
void	performCalculations () const override
Protected Attributes inherited from BlackScholesCGBase
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 std::vector< Date >	simulationDates_
Date	referenceDate_
std::set< Date >	effectiveSimulationDates_
TimeGrid	timeGrid_
std::vector< Size >	positionInTimeGrid_
std::map< Date, std::vector< std::size_t > >	underlyingPaths_
std::size_t	underlyingPathsCgVersion_ = 0
Protected Attributes inherited from ModelCGImpl
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_
std::vector< std::vector< size_t > >	randomVariates_
std::vector< std::pair< std::size_t, std::function< double(void)> > >	modelParameters_
Protected Attributes inherited from ModelCG
std::map< std::string, boost::any >	additionalResults_
QuantLib::ext::shared_ptr< QuantExt::ComputationGraph >	g_

Detailed Description

Definition at line 31 of file blackscholescg.hpp.

Constructor & Destructor Documentation

BlackScholesCG() [1/2]

BlackScholesCG	(	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 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 45 of file blackscholescg.cpp.

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

BlackScholesCG() [2/2]

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

Definition at line 37 of file blackscholescg.cpp.

    : BlackScholesCG(paths, {currency}, {curve}, {}, {}, {}, {index}, {indexCurrency}, model, {}, simulationDates,
                     iborFallbackConfig, calibration, {{index, calibrationStrikes}}) {}

Member Function Documentation

getFutureBarrierProb()

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

overrideprivatevirtual

Implements ModelCGImpl.

Definition at line 423 of file blackscholescg.cpp.

                                                                                                  {
 
    // get the underlying values at the start and end points of the period
 
    std::size_t v1 = eval(index, obsdate1, Null<Date>());
    std::size_t v2 = eval(index, obsdate2, Null<Date>());
 
    // check the barrier at the two endpoints
 
    std::size_t barrierHit = cg_const(*g_, 0.0);
    if (above) {
        barrierHit = cg_min(*g_, cg_const(*g_, 1.0), cg_add(*g_, barrierHit, cg_indicatorGeq(*g_, v1, barrier)));
        barrierHit = cg_min(*g_, cg_const(*g_, 1.0), cg_add(*g_, barrierHit, cg_indicatorGeq(*g_, v2, barrier)));
    } else {
        barrierHit =
            cg_min(*g_, cg_const(*g_, 1.0),
                   cg_add(*g_, barrierHit, cg_subtract(*g_, cg_const(*g_, 1.0), cg_indicatorGt(*g_, v1, barrier))));
        barrierHit =
            cg_min(*g_, cg_const(*g_, 1.0),
                   cg_add(*g_, barrierHit, cg_subtract(*g_, cg_const(*g_, 1.0), cg_indicatorGt(*g_, 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) {
            std::size_t res;
            if (ir != irIndices_.end())
                res = getIrIndexValue(std::distance(irIndices_.begin(), ir), d);
            else
                res = getInfIndexValue(std::distance(infIndices_.begin(), inf), d);
 
            if (above) {
                barrierHit =
                    cg_min(*g_, cg_const(*g_, 1.0), cg_add(*g_, barrierHit, cg_indicatorGeq(*g_, res, barrier)));
            } else {
                barrierHit = cg_min(
                    *g_, cg_const(*g_, 1.0),
                    cg_add(*g_, barrierHit, cg_subtract(*g_, cg_const(*g_, 1.0), cg_indicatorGt(*g_, res, barrier))));
            }
            ++d;
        }
    }
 
    // return the result if we have an IR / INF index
 
    if (ir != irIndices_.end() || inf != infIndices_.end())
        return barrierHit;
 
    // 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]
 
    std::size_t variance = cg_const(*g_, 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>()) {
                std::string id =
                    "__cov_" + std::to_string(ind1) + "_" + std::to_string(ind1) + "_" + std::to_string(i - 1);
                variance = cg_add(*g_, variance, cg_var(*g_, id));
            }
            if (ind2 != Null<Size>()) {
                std::string id =
                    "__cov_" + std::to_string(ind2) + "_" + std::to_string(ind2) + "_" + std::to_string(i - 1);
                variance = cg_add(*g_, variance, cg_var(*g_, id));
            }
            if (ind1 != Null<Size>() && ind2 != Null<Size>()) {
                std::string id =
                    "__cov_" + std::to_string(ind1) + "_" + std::to_string(ind2) + "_" + std::to_string(i - 1);
                variance = cg_subtract(*g_, variance, cg_mult(*g_, cg_const(*g_, 2.0), cg_var(*g_, id)));
            }
        }
    }
 
    // compute the hit probability
    // see e.g. formulas 2, 4 in Emmanuel Gobet, Advanced Monte Carlo methods for barrier and related exotic options
 
    std::size_t eps = cg_const(*g_, 1E-14);
 
    variance = cg_max(*g_, variance, eps);
    std::size_t adjBarrier = cg_max(*g_, barrier, eps);
 
    std::size_t hitProb = cg_min(*g_, cg_const(*g_, 1.0),
                                 cg_exp(*g_, cg_mult(*g_,
                                                     cg_mult(*g_, cg_div(*g_, cg_const(*g_, -2.0), variance),
                                                             cg_log(*g_, cg_div(*g_, v1, adjBarrier))),
                                                     cg_log(*g_, cg_div(*g_, v2, adjBarrier)))));
 
    barrierHit = cg_add(*g_, barrierHit, cg_mult(*g_, cg_subtract(*g_, cg_const(*g_, 1.0), barrierHit), hitProb));
 
    return barrierHit;
} // getFutureBarrierProb()

Here is the call graph for this function:

performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 242 of file blackscholescg.cpp.

                                               {
 
    BlackScholesCGBase::performCalculations();
 
    // nothing to do if we do not have any indices or if underlying paths are populated already
 
    if (indices_.empty() || !underlyingPaths_.empty())
        return;
 
    // exit if there are no future simulation dates (i.e. only the reference date)
 
    if (effectiveSimulationDates_.size() == 1)
        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<std::size_t>(model_->processes().size(), ComputationGraph::nan);
    }
 
    // 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");
    }
 
    // generate computation graph of underlying paths dependend on the drift and sqrtCov between simulation
    // dates, which we treat as model parameters
 
    auto sqrtCovCalc =
        QuantLib::ext::make_shared<SqrtCovCalculator>(indices_, indexCurrencies_, correlations_, effectiveSimulationDates_,
                                              timeGrid_, positionInTimeGrid_, model_, calibrationStrikes);
 
    std::vector<std::vector<std::size_t>> drift(effectiveSimulationDates_.size() - 1,
                                                std::vector<std::size_t>(indices_.size(), ComputationGraph::nan));
    std::vector<std::vector<std::vector<std::size_t>>> sqrtCov(
        effectiveSimulationDates_.size() - 1,
        std::vector<std::vector<std::size_t>>(indices_.size(),
                                              std::vector<std::size_t>(indices_.size(), ComputationGraph::nan)));
    std::vector<std::vector<std::vector<std::size_t>>> cov(
        effectiveSimulationDates_.size() - 1,
        std::vector<std::vector<std::size_t>>(indices_.size(),
                                              std::vector<std::size_t>(indices_.size(), ComputationGraph::nan)));
 
    // precompute sqrtCov nodes and add model parameters for covariance (needed in futureBarrierProbability())
 
    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) {
                std::string id = "__sqrtCov_" + std::to_string(j) + "_" + std::to_string(k) + "_" + std::to_string(i);
                sqrtCov[i][j][k] =
                    addModelParameter(id, [sqrtCovCalc, i, j, k] { return sqrtCovCalc->sqrtCov(i, j, k); });
                id = "__cov_" + std::to_string(j) + "_" + std::to_string(k) + "_" + std::to_string(i);
                cov[i][j][k] = addModelParameter(id, [sqrtCovCalc, i, j, k] { return sqrtCovCalc->cov(i, j, k); });
            }
        }
    }
 
    // precompute drift nodes
 
    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<std::size_t> discountRatio(indices_.size(), cg_const(*g_, 1.0));
    auto date = effectiveSimulationDates_.begin();
    for (Size i = 0; i < effectiveSimulationDates_.size() - 1; ++i) {
        Date d = *(++date);
        for (Size j = 0; j < indices_.size(); ++j) {
            auto p = model_->processes().at(j);
            std::string id = std::to_string(j) + "_" + ore::data::to_string(d);
            std::size_t div= addModelParameter("__div_" + id, [p, d]() { return p->dividendYield()->discount(d); });
            std::size_t rfr = addModelParameter("__rfr_" + id, [p, d]() { return p->riskFreeRate()->discount(d); });
            std::size_t tmp = cg_div(*g_, rfr, div);
            drift[i][j] = cg_subtract(*g_, cg_negative(*g_, cg_log(*g_, cg_div(*g_, tmp, discountRatio[j]))),
                                      cg_mult(*g_, cg_const(*g_, 0.5), cov[i][j][j]));
            discountRatio[j] = tmp;
            if (forCcyDaIndex[j] != Null<Size>()) {
                drift[i][j] = cg_subtract(*g_, drift[i][j], cov[i][forCcyDaIndex[j]][j]);
            }
        }
    }
 
    // set required random variates
 
 
    randomVariates_ = std::vector<std::vector<std::size_t>>(
        indices_.size(), std::vector<std::size_t>(effectiveSimulationDates_.size() - 1));
 
    for (Size j = 0; j < indices_.size(); ++j) {
        for (Size i = 0; i < effectiveSimulationDates_.size() - 1; ++i) {
            randomVariates_[j][i] = cg_var(*g_, "__rv_" + std::to_string(j) + "_" + std::to_string(i),
                                           ComputationGraph::VarDoesntExist::Create);
        }
    }
 
    // evolve the process using correlated normal variates and set the underlying path values
 
    std::vector<std::size_t> logState(indices_.size());
    for (Size j = 0; j < indices_.size(); ++j) {
        std::string id = "__x0_" + std::to_string(j);
        auto p = model_->processes().at(j);
        logState[j] = addModelParameter(id, [p] { return std::log(p->x0()); });
        underlyingPaths_[*effectiveSimulationDates_.begin()][j] = cg_exp(*g_, logState[j]);
    }
 
    date = effectiveSimulationDates_.begin();
    for (Size i = 0; i < effectiveSimulationDates_.size() - 1; ++i) {
        ++date;
        for (Size j = 0; j < indices_.size(); ++j) {
            for (Size k = 0; k < indices_.size(); ++k) {
                logState[j] = cg_add(*g_, logState[j], cg_mult(*g_, sqrtCov[i][j][k], randomVariates_[k][i]));
            }
            logState[j] = cg_add(*g_, logState[j], drift[i][j]);
            underlyingPaths_[*date][j] = cg_exp(*g_, logState[j]);
        }
    }
 
    // set additional results provided by this model
 
    for (auto const& c : correlations_) {
        additionalResults_["BlackScholes.Correlation_" + c.first.first + "_" + c.first.second] =
            c.second->correlation(0.0);
    }
 
    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;
        }
    }
} // performCalculations()

Here is the call graph for this function:

Member Data Documentation

calibration_

const std::string calibration_

private

Definition at line 67 of file blackscholescg.hpp.

calibrationStrikes_

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

private

Definition at line 70 of file blackscholescg.hpp.