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

Inheritance diagram for GaussianCam:

Collaboration diagram for GaussianCam:

Public Member Functions
	GaussianCam (const Handle< CrossAssetModel > &cam, 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 std::set< Date > &simulationDates, const McParams &mcParams, const Size timeStepsPerYear=1, const IborFallbackConfig &iborFallbackConfig=IborFallbackConfig::defaultConfig(), const std::vector< Size > &projectedStateProcessIndices={}, const std::vector< std::string > &conditionalExpectationModelStates={})

Type	type () const override

const Date &	referenceDate () const override

Size	size () 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

void	injectPaths (const std::vector< QuantLib::Real > pathTimes, const std::vector< std::vector< QuantExt::RandomVariable > > paths, const std::vector< size_t > pathIndexes, const std::vector< size_t > timeIndexes) 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

Public Member Functions inherited from AmcModel
virtual	~AmcModel ()

virtual void	injectPaths (const std::vector< QuantLib::Real > pathTimes, const std::vector< std::vector< QuantExt::RandomVariable > > variates, const std::vector< size_t > pathIndexes, const std::vector< size_t > timeIndexes)=0

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

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

RandomVariable	getDiscount (const Size idx, const Date &s, const Date &t, const Handle< YieldTermStructure > &targetCurve) const

void	populatePathValues (const Size nSamples, std::map< Date, std::vector< RandomVariable > > &paths, std::map< Date, std::vector< RandomVariable > > &irStates, std::map< Date, std::vector< std::pair< RandomVariable, RandomVariable > > > &infStates, const std::vector< Real > &times, const bool isTraining) const

Private Attributes
const Handle< CrossAssetModel >	cam_

const std::vector< Handle< YieldTermStructure > >	curves_

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

const McParams	mcParams_

const Size	timeStepsPerYear_

const std::vector< Size >	projectedStateProcessIndices_

const Real	regressionVarianceCutoff_ = Null<Real>()

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 > >	irStates_

std::map< Date, std::vector< std::pair< RandomVariable, RandomVariable > > >	infStates_

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

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

std::map< Date, std::vector< std::pair< RandomVariable, RandomVariable > > >	infStatesTraining_

bool	inTrainingPhase_ = false

std::vector< Size >	indexPositionInProcess_

std::vector< Size >	infIndexPositionInProcess_

std::vector< Size >	currencyPositionInProcess_

std::vector< Size >	irIndexPositionInCam_

std::vector< Size >	infIndexPositionInCam_

std::vector< Size >	currencyPositionInCam_

std::vector< Size >	eqIndexInCam_

std::vector< Size >	comIndexInCam_

bool	conditionalExpectationUseIr_

bool	conditionalExpectationUseInf_

bool	conditionalExpectationUseAsset_

std::map< std::tuple< Size, Date, Date >, RandomVariable >	irIndexValueCache_

const std::vector< QuantLib::Real > *	injectedPathTimes_ = nullptr

const std::vector< std::vector< QuantExt::RandomVariable > > *	injectedPaths_ = nullptr

const std::vector< size_t > *	injectedPathRelevantPathIndexes_

const std::vector< size_t > *	injectedPathRelevantTimeIndexes_

Size	overwriteModelSize_ = Null<Size>()

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

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

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 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 38 of file gaussiancam.hpp.

Constructor & Destructor Documentation

◆ GaussianCam()

GaussianCam	(	const Handle< CrossAssetModel > &	cam,
		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 std::set< Date > &	simulationDates,
		const McParams &	mcParams,
		const Size	timeStepsPerYear = `1`,
		const IborFallbackConfig &	iborFallbackConfig = `IborFallbackConfig::defaultConfig()`,
		const std::vector< Size > &	projectedStateProcessIndices = `{}`,
		const std::vector< std::string > &	conditionalExpectationModelStates = `{}`
	)

Definition at line 47 of file gaussiancam.cpp.

    : ModelImpl(curves.front()->dayCounter(), paths, currencies, irIndices, infIndices, indices, indexCurrencies,
                simulationDates, iborFallbackConfig),
      cam_(cam), curves_(curves), fxSpots_(fxSpots), mcParams_(mcParams), timeStepsPerYear_(timeStepsPerYear),
      projectedStateProcessIndices_(projectedStateProcessIndices) {
 
    // check inputs
 
    QL_REQUIRE(!cam_.empty(), "model is empty");
 
    // register with observables
 
    for (auto const& o : curves_)
        registerWith(o);
    for (auto const& o : fxSpots_)
        registerWith(o);
 
    registerWith(cam_);
 
    // set conditional expectation model states
 
    conditionalExpectationUseIr_ =
        conditionalExpectationModelStates.empty() ||
        std::find(conditionalExpectationModelStates.begin(), conditionalExpectationModelStates.end(), "IR") !=
            conditionalExpectationModelStates.end();
    conditionalExpectationUseInf_ =
        conditionalExpectationModelStates.empty() ||
        std::find(conditionalExpectationModelStates.begin(), conditionalExpectationModelStates.end(), "INF") !=
            conditionalExpectationModelStates.end();
    conditionalExpectationUseAsset_ =
        conditionalExpectationModelStates.empty() ||
        std::find(conditionalExpectationModelStates.begin(), conditionalExpectationModelStates.end(), "Asset") !=
            conditionalExpectationModelStates.end();
 
} // GaussianCam ctor

Member Function Documentation

◆ type()

Type type ( ) const

overridevirtual

Implements Model.

Definition at line 59 of file gaussiancam.hpp.

59{ return Type::MC; }

ore::data::Model::Type::MC

@ MC

◆ referenceDate()

const Date & referenceDate ( ) const

overridevirtual

Implements Model.

Definition at line 116 of file gaussiancam.cpp.

                                             {
    calculate();
    return referenceDate_;
}

Here is the caller graph for this function:

◆ size()

Size size ( ) const

overridevirtual

Reimplemented from Model.

Definition at line 93 of file gaussiancam.cpp.

                             {
    if (injectedPathTimes_ == nullptr)
        if (inTrainingPhase_)
            return mcParams_.trainingSamples;
        else
            return Model::size();
    else {
        return overwriteModelSize_;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ npv()

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

overridevirtual

Implements Model.

Definition at line 576 of file gaussiancam.cpp.

                                                                           {
 
    calculate();
 
    // short cut, if amount is deterministic and no memslot is given
 
    if (amount.deterministic() && !memSlot)
        return amount;
 
    // if obsdate is today, take a plain expectation
 
    if (obsdate == referenceDate())
        return expectation(amount);
 
    // build the state
 
    std::vector<const RandomVariable*> state;
 
    if (conditionalExpectationUseAsset_ && !underlyingPaths_.empty()) {
        for (auto const& r : underlyingPaths_.at(obsdate))
            state.push_back(&r);
    }
 
    // TODO we include zero vol ir states here, we could exclude them
    if (conditionalExpectationUseIr_) {
        for (auto const& r : irStates_.at(obsdate))
            state.push_back(&r);
    }
 
    // valid for both DK and JY
    if (conditionalExpectationUseInf_) {
        for (auto const& r : infStates_.at(obsdate)) {
            state.push_back(&r.first);
            state.push_back(&r.second);
        }
    }
 
    Size nModelStates = state.size();
 
    // if memSlot is given we have to make sure the state always has the same size
    if (addRegressor1.initialised() && (memSlot || !addRegressor1.deterministic()))
        state.push_back(&addRegressor1);
    if (addRegressor2.initialised() && (memSlot || !addRegressor2.deterministic()))
        state.push_back(&addRegressor2);
 
    Size nAddReg = state.size() - nModelStates;
 
    // if the state is empty, return the plain expectation (no conditioning)
 
    if (state.empty()) {
        return expectation(amount);
    }
 
    // the regression model is given by coefficients and an optional coordinate transform
 
    Array coeff;
    Matrix coordinateTransform;
 
    // if a memSlot is given and coefficients / coordinate transform are stored, we use them
 
    bool haveStoredModel = false;
 
    if (memSlot) {
        if (auto it = storedRegressionModel_.find(*memSlot); it != storedRegressionModel_.end()) {
            coeff = std::get<0>(it->second);
            coordinateTransform = std::get<2>(it->second);
            QL_REQUIRE(std::get<1>(it->second) == state.size(),
                       "GaussianCam::npv(): stored regression coefficients at mem slot "
                           << *memSlot << " are for state size " << std::get<1>(it->second) << ", actual state size is "
                           << state.size() << " (before possible coordinate transform).");
            haveStoredModel = true;
        }
    }
 
    // if we do not have retrieved a model in the previous step, we create it now
 
    std::vector<RandomVariable> transformedState;
 
    if(!haveStoredModel) {
 
        // factor reduction to reduce dimensionalitty and handle collinearity
 
        if (mcParams_.regressionVarianceCutoff != Null<Real>()) {
            coordinateTransform = pcaCoordinateTransform(state, mcParams_.regressionVarianceCutoff);
            transformedState = applyCoordinateTransform(state, coordinateTransform);
            state = vec2vecptr(transformedState);
        }
 
        // train coefficients
 
        coeff = regressionCoefficients(amount, state,
                                       multiPathBasisSystem(state.size(), mcParams_.regressionOrder,
                                                            mcParams_.polynomType, std::min(size(), trainingSamples())),
                                       filter, RandomVariableRegressionMethod::QR);
        DLOG("GaussianCam::npv(" << ore::data::to_string(obsdate) << "): regression coefficients are " << coeff
                                 << " (got model state size " << nModelStates << " and " << nAddReg
                                 << " additional regressors, coordinate transform " << coordinateTransform.columns()
                                 << " -> " << coordinateTransform.rows() << ")");
 
        // store model if requried
 
        if (memSlot) {
            storedRegressionModel_[*memSlot] = std::make_tuple(coeff, nModelStates + nAddReg, coordinateTransform);
        }
 
    } else {
 
        // apply the stored coordinate transform to the state
 
        if(!coordinateTransform.empty()) {
            transformedState = applyCoordinateTransform(state, coordinateTransform);
            state = vec2vecptr(transformedState);
        }
    }
 
    // compute conditional expectation and return the result
 
    return conditionalExpectation(state,
                                  multiPathBasisSystem(state.size(), mcParams_.regressionOrder, mcParams_.polynomType,
                                                       std::min(size(), trainingSamples())),
                                  coeff);
}

Here is the call graph for this function:

◆ fwdCompAvg()

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

overridevirtual

Implements Model.

Definition at line 523 of file gaussiancam.cpp.

                                                                                               {
    calculate();
    auto ir = std::find_if(irIndices_.begin(), irIndices_.end(),
                           [&indexInput](const std::pair<IndexInfo, QuantLib::ext::shared_ptr<InterestRateIndex>>& p) {
                               return p.first.name() == indexInput;
                           });
    QL_REQUIRE(ir != irIndices_.end(),
               "GaussianCam::fwdComp() ir index " << indexInput << " not found, this is unexpected");
    Size irIndexPos = irIndexPositionInCam_[std::distance(irIndices_.begin(), ir)];
    LgmVectorised lgmv(cam_->lgm(irIndexPos)->parametrization());
    auto on = QuantLib::ext::dynamic_pointer_cast<OvernightIndex>(ir->second);
    QL_REQUIRE(on, "GaussianCam::fwdCompAvg(): expected on index for " << indexInput);
    // only used to extract fixing and value dates
    auto coupon = QuantLib::ext::make_shared<QuantExt::OvernightIndexedCoupon>(
        end, 1.0, start, end, on, gearing, spread, Date(), Date(), DayCounter(), false, includeSpread, lookback * Days,
        rateCutoff, fixingDays);
    // get model time and state
    Date effobsdate = std::max(referenceDate(), obsdate);
    const auto& modelState = irStates_.at(effobsdate)[irIndexPos];
    const auto& modelTime = timeFromReference(effobsdate);
    if (isAvg) {
        return lgmv.averagedOnRate(on, coupon->fixingDates(), coupon->valueDates(), coupon->dt(), rateCutoff,
                                   includeSpread, spread, gearing, lookback * Days, cap, floor, localCapFloor,
                                   nakedOption, modelTime, modelState);
    } else {
        return lgmv.compoundedOnRate(on, coupon->fixingDates(), coupon->valueDates(), coupon->dt(), rateCutoff,
                                     includeSpread, spread, gearing, lookback * Days, cap, floor, localCapFloor,
                                     nakedOption, modelTime, modelState);
    }
}

Here is the call graph for this function:

◆ releaseMemory()

void releaseMemory ( )

overridevirtual

Reimplemented from Model.

Definition at line 104 of file gaussiancam.cpp.

                                {
    underlyingPaths_.clear();
    underlyingPathsTraining_.clear();
    irStates_.clear();
    infStates_.clear();
    irStatesTraining_.clear();
    infStatesTraining_.clear();
    irIndexValueCache_.clear();
}

◆ resetNPVMem()

void resetNPVMem ( )

overridevirtual

Reimplemented from Model.

Definition at line 114 of file gaussiancam.cpp.

114{ storedRegressionModel_.clear(); }

◆ toggleTrainingPaths()

void toggleTrainingPaths ( ) const

overridevirtual

Reimplemented from Model.

Definition at line 701 of file gaussiancam.cpp.

                                            {
    std::swap(underlyingPaths_, underlyingPathsTraining_);
    std::swap(irStates_, irStatesTraining_);
    std::swap(infStates_, infStatesTraining_);
    inTrainingPhase_ = !inTrainingPhase_;
    irIndexValueCache_.clear();
}

◆ trainingSamples()

Size trainingSamples ( ) const

overridevirtual

Reimplemented from Model.

Definition at line 709 of file gaussiancam.cpp.

709{ return mcParams_.trainingSamples; }

Here is the caller graph for this function:

◆ injectPaths()

void injectPaths	(	const std::vector< QuantLib::Real > *	pathTimes,
		const std::vector< std::vector< QuantExt::RandomVariable > > *	paths,
		const std::vector< size_t > *	pathIndexes,
		const std::vector< size_t > *	timeIndexes
	)

overridevirtual

Implements AmcModel.

Definition at line 711 of file gaussiancam.cpp.

                                                                                                          {
 
    if (pathTimes == nullptr) {
        // reset injected path data
        injectedPathTimes_ = nullptr;
        injectedPaths_ = nullptr;
        injectedPathRelevantPathIndexes_ = nullptr;
        injectedPathRelevantTimeIndexes_ = nullptr;
        return;
    }
 
    QL_REQUIRE(!pathTimes->empty(), "GaussianCam::injectPaths(): injected path times empty");
 
    QL_REQUIRE(pathTimes->size() == paths->size(), "GaussianCam::injectPaths(): path times ("
                                                       << pathTimes->size() << ") must match path size ("
                                                       << paths->size() << ")");
 
    QL_REQUIRE(pathIndexes->size() == timeIndexes->size(),
               "GaussianCam::injectPaths(): path indexes size (" << pathIndexes->size() << ") must match time indexes size ("
                                                          << timeIndexes->size() << ")");
 
    QL_REQUIRE(projectedStateProcessIndices_.size() == cam_->dimension(),
               "GaussianCam::injectPaths(): number of projected state process indices ("
                   << projectedStateProcessIndices_.size() << ") must match model dimension (" << cam_->dimension());
 
    Size maxProjectedStateProcessIndex =
        *std::max_element(projectedStateProcessIndices_.begin(), projectedStateProcessIndices_.end());
 
    for (auto const& v : *paths) {
        QL_REQUIRE(v.size() > maxProjectedStateProcessIndex, "GaussianCam::injectPaths(): dimension of variates ("
                                                                 << v.size()
                                                                 << ") must cover max projected state process index ("
                                                                 << maxProjectedStateProcessIndex << ")");
        overwriteModelSize_ = v.front().size();
    }
 
    injectedPathTimes_ = pathTimes;
    injectedPaths_ = paths;
    injectedPathRelevantPathIndexes_ = pathIndexes;
    injectedPathRelevantTimeIndexes_ = timeIndexes;
    update();
}

◆ 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 82 of file gaussiancam.hpp.

                                                                                                        {
        QL_FAIL("getFutureBarrierProb not implemented by GaussianCam");
    }

◆ performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 121 of file gaussiancam.cpp.

                                            {
 
    QL_REQUIRE(!inTrainingPhase_, "GaussianCam::performCalculations(): state inTrainingPhase should be false, this was "
                                  "not resetted appropriately.");
 
    referenceDate_ = curves_.front()->referenceDate();
 
    // set up time grid
 
    effectiveSimulationDates_.clear();
    effectiveSimulationDates_.insert(referenceDate());
    for (auto const& d : simulationDates_) {
        if (d >= referenceDate())
            effectiveSimulationDates_.insert(d);
    }
 
    std::vector<Real> times;
    for (auto const& d : effectiveSimulationDates_) {
        times.push_back(timeFromReference(d));
    }
 
    Size steps = std::max(std::lround(timeStepsPerYear_ * times.back() + 0.5), 1l);
    timeGrid_ = TimeGrid(times.begin(), times.end(), steps);
    positionInTimeGrid_.resize(times.size());
    for (Size i = 0; i < positionInTimeGrid_.size(); ++i)
        positionInTimeGrid_[i] = timeGrid_.index(times[i]);
 
    // clear underlying paths
 
    underlyingPaths_.clear();
    underlyingPathsTraining_.clear();
    irStates_.clear();
    infStates_.clear();
 
    // 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>(indices_.size(), RandomVariable(size(), 0.0));
        irStates_[d] = std::vector<RandomVariable>(currencies_.size(), RandomVariable(size(), 0.0));
        infStates_[d] = std::vector<std::pair<RandomVariable, RandomVariable>>(
            infIndices_.size(), std::make_pair(RandomVariable(size(), 0.0), RandomVariable(size(), 0.0)));
 
        if(trainingSamples() != Null<Size>() && injectedPathTimes_ == nullptr) {
            underlyingPathsTraining_[d] =
                std::vector<RandomVariable>(indices_.size(), RandomVariable(trainingSamples(), 0.0));
            irStatesTraining_[d] =
                std::vector<RandomVariable>(currencies_.size(), RandomVariable(trainingSamples(), 0.0));
            infStatesTraining_[d] = std::vector<std::pair<RandomVariable, RandomVariable>>(
                infIndices_.size(),
                std::make_pair(RandomVariable(trainingSamples(), 0.0), RandomVariable(trainingSamples(), 0.0)));
        }
 
    }
 
    // populate index mappings
 
    currencyPositionInProcess_.clear();
    currencyPositionInCam_.clear();
    for (Size i = 0; i < currencies_.size(); ++i) {
        currencyPositionInProcess_.push_back(
            cam_->pIdx(CrossAssetModel::AssetType::IR, cam_->ccyIndex(parseCurrency(currencies_[i]))));
        currencyPositionInCam_.push_back(
            cam_->idx(CrossAssetModel::AssetType::IR, cam_->ccyIndex(parseCurrency(currencies_[i]))));
    }
 
    irIndexPositionInCam_.clear();
    for (Size i = 0; i < irIndices_.size(); ++i) {
        irIndexPositionInCam_.push_back(cam_->ccyIndex(irIndices_[i].second->currency()));
    }
 
    infIndexPositionInProcess_.clear();
    infIndexPositionInCam_.clear();
    for (Size i = 0; i < infIndices_.size(); ++i) {
        Size infIdx = cam_->infIndex(infIndices_[i].first.infName());
        infIndexPositionInProcess_.push_back(cam_->pIdx(CrossAssetModel::AssetType::INF, infIdx));
        infIndexPositionInCam_.push_back(infIdx);
    }
 
    indexPositionInProcess_.clear();
    eqIndexInCam_.resize(indices_.size());
    comIndexInCam_.resize(indices_.size());
    std::fill(eqIndexInCam_.begin(), eqIndexInCam_.end(), Null<Size>());
    std::fill(comIndexInCam_.begin(), comIndexInCam_.end(), Null<Size>());
    for (Size i = 0; i < indices_.size(); ++i) {
        if (indices_[i].isFx()) {
            // FX
            Size ccyIdx = cam_->ccyIndex(parseCurrency(indexCurrencies_[i]));
            QL_REQUIRE(ccyIdx > 0, "fx index '" << indices_[i] << "' has unexpected for ccy = base ccy");
            indexPositionInProcess_.push_back(cam_->pIdx(CrossAssetModel::AssetType::FX, ccyIdx - 1));
        } else if (indices_[i].isEq()) {
            // EQ
            Size eqIdx = cam_->eqIndex(indices_[i].eq()->name());
            indexPositionInProcess_.push_back(cam_->pIdx(CrossAssetModel::AssetType::EQ, eqIdx));
            eqIndexInCam_[i] = eqIdx;
        } else if(indices_[i].isComm()) {
            // COM
            Size comIdx = cam_->comIndex(indices_[i].commName());
            indexPositionInProcess_.push_back(cam_->pIdx(CrossAssetModel::AssetType::COM, comIdx));
            comIndexInCam_[i] = comIdx;
        } else {
            QL_FAIL("GuassianCam::performCalculations(): index '" << indices_[i].name()
                                                                  << "' expected to be FX, EQ, COMM");
        }
    }
 
    // populate path values
 
    populatePathValues(size(), underlyingPaths_, irStates_, infStates_, times, false);
    if (trainingSamples() != Null<Size>() && injectedPathTimes_ == nullptr) {
        populatePathValues(trainingSamples(), underlyingPathsTraining_, irStatesTraining_, infStatesTraining_, times,
                           true);
    }
}

Here is the call graph for this function:

◆ getIndexValue()

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

overrideprivatevirtual

Implements ModelImpl.

Definition at line 427 of file gaussiancam.cpp.

                                                                                                  {
    auto res = underlyingPaths_.at(d).at(indexNo);
    if (comIndexInCam_[indexNo] != Null<Size>()) {
        // handle com (TODO: performace optimization via vectorized version of com model)
        RandomVariable tmp(res.size());
        for (Size i = 0; i < tmp.size(); ++i) {
            tmp.set(i, cam_->comModel(comIndexInCam_[indexNo])
                           ->forwardPrice(timeFromReference(d), timeFromReference(fwd != Null<Date>() ? fwd : d),
                                          Array(1, std::log(res[i]))));
        }
        return tmp;
    } else if (fwd != Null<Date>()) {
        // handle fx, eq -> incorporate forwarding factor if applicable
        auto ccy = std::find(currencies_.begin(), currencies_.end(), indexCurrencies_[indexNo]);
        QL_REQUIRE(ccy != currencies_.end(), "GaussianCam::getIndexValue(): can not get currency for index #"
                                                 << indexNo << "(" << indices_.at(indexNo) << ")");
        if (indices_[indexNo].isFx()) {
            res *= getDiscount(std::distance(currencies_.begin(), ccy), d, fwd) / getDiscount(0, d, fwd);
        } else if (eqIndexInCam_[indexNo] != Null<Size>()) {
            // the CAM assumes a deterministic dividend curve for EQ
            auto div = cam_->eqbs(eqIndexInCam_[indexNo])->equityDivYieldCurveToday();
            res *= RandomVariable(size(), div->discount(fwd) / div->discount(d)) /
                   getDiscount(std::distance(currencies_.begin(), ccy), d, fwd,
                               cam_->eqbs(eqIndexInCam_[indexNo])->equityIrCurveToday());
        } else if (comIndexInCam_[indexNo] != Null<Size>()) {
 
        } else {
            QL_FAIL("GaussianGam::getIndexValue(): did not recognise  index #" << indexNo << "("
                                                                               << indices_.at(indexNo));
        }
    }
    return res;
}

Here is the call graph for this function:

◆ getIrIndexValue()

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

overrideprivatevirtual

Implements ModelImpl.

Definition at line 461 of file gaussiancam.cpp.

                                                                                                    {
    Date fixingDate = d;
    if (fwd != Null<Date>())
        fixingDate = fwd;
    // ensure a valid fixing date
    fixingDate = irIndices_[indexNo].second->fixingCalendar().adjust(fixingDate);
    // look up required fixing in cache and return it if found
    if (auto cacheValue = irIndexValueCache_.find(std::make_tuple(indexNo, d, fixingDate));
        cacheValue != irIndexValueCache_.end()) {
        return cacheValue->second;
    }
    // compute value, add to cache and return it
    Size currencyIdx = irIndexPositionInCam_[indexNo];
    LgmVectorised lgmv(cam_->irlgm1f(currencyIdx));
    auto result =
        lgmv.fixing(irIndices_[indexNo].second, fixingDate, timeFromReference(d), irStates_.at(d).at(currencyIdx));
    irIndexValueCache_[std::make_tuple(indexNo, d, fixingDate)] = result;
    return result;
}

Here is the call graph for this function:

◆ getInfIndexValue()

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

overrideprivatevirtual

Implements ModelImpl.

Definition at line 481 of file gaussiancam.cpp.

                                                                                                     {
    Date fixingDate = d;
    Date obsDate = d;
    if (fwd != Null<Date>())
        fixingDate = fwd;
    Size lag = getInflationSimulationLag(infIndices_[indexNo].second);
    auto const& state = infStates_.at(obsDate + lag).at(indexNo);
    Size camIndex = infIndexPositionInCam_[indexNo];
    Real t = infIndices_[indexNo].second->zeroInflationTermStructure()->timeFromReference(obsDate + lag);
    Real T = infIndices_[indexNo].second->zeroInflationTermStructure()->timeFromReference(fixingDate + lag);
    QL_DEPRECATED_DISABLE_WARNING
    bool isInterpolated = infIndices_[indexNo].second->interpolated();
    QL_DEPRECATED_ENABLE_WARNING
    Real baseFixing =
        infIndices_[indexNo].second->fixing(infIndices_[indexNo].second->zeroInflationTermStructure()->baseDate());
    RandomVariable result(size());
 
    if (cam_->modelType(CrossAssetModel::AssetType::INF, camIndex) == CrossAssetModel::ModelType::DK) {
        InfDkVectorised infdkv(*cam_);
        RandomVariable baseFixingVec(size(), baseFixing);
        QL_REQUIRE(t < T || close_enough(t, T), "infdkI: t (" << t << ") <= T (" << T << ") required");
        auto dk = infdkv.infdkI(camIndex, t, T, state.first, state.second, isInterpolated);
        result = baseFixingVec * dk.first * (fixingDate != obsDate ? dk.second : RandomVariable(size(), 1.0));
    } else if (cam_->modelType(CrossAssetModel::AssetType::INF, camIndex) == CrossAssetModel::ModelType::JY) {
        result = exp(state.second);
        if (fixingDate != obsDate) {
            // we need a forward cpi, TODO vectorise this computation
            RandomVariable growthFactor(size());
            growthFactor.expand();
            for (Size p = 0; p < size(); ++p) {
                growthFactor.data()[p] =
                    inflationGrowth(*cam_, indexNo, t, T, state.first[p], state.second[p], isInterpolated);
            }
            result *= growthFactor;
        }
    } else {
        QL_FAIL("GaussianCam::getInfIndexValue(): unknown model type for inflation index "
                << infIndices_[indexNo].first.name());
    }
    return result;
}

Here is the call graph for this function:

◆ getDiscount() [1/2]

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

overrideprivatevirtual

Implements ModelImpl.

Definition at line 558 of file gaussiancam.cpp.

                                                                                          {
    return getDiscount(idx, s, t, Handle<YieldTermStructure>());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getNumeraire()

RandomVariable getNumeraire ( const Date & s ) const

overrideprivatevirtual

Implements ModelImpl.

Definition at line 569 of file gaussiancam.cpp.

                                                            {
    LgmVectorised lgmv(cam_->lgm(currencyPositionInCam_[0])->parametrization());
    return lgmv.numeraire(timeFromReference(s), irStates_.at(s)[0]);
}

Here is the call graph for this function:

◆ getFxSpot()

Real getFxSpot ( const Size idx ) const

overrideprivatevirtual

Implements ModelImpl.

Definition at line 574 of file gaussiancam.cpp.

574{ return fxSpots_.at(idx)->value(); }

◆ getDiscount() [2/2]

RandomVariable getDiscount	(	const Size	idx,
		const Date &	s,
		const Date &	t,
		const Handle< YieldTermStructure > &	targetCurve
	)		const

private

Definition at line 562 of file gaussiancam.cpp.

                                                                                             {
    LgmVectorised lgmv(cam_->lgm(currencyPositionInCam_[idx])->parametrization());
    return lgmv.discountBond(timeFromReference(s), curves_.front()->timeFromReference(t), irStates_.at(s)[idx],
                             targetCurve);
}

Here is the call graph for this function:

◆ populatePathValues()

void populatePathValues	(	const Size	nSamples,
		std::map< Date, std::vector< RandomVariable > > &	paths,
		std::map< Date, std::vector< RandomVariable > > &	irStates,
		std::map< Date, std::vector< std::pair< RandomVariable, RandomVariable > > > &	infStates,
		const std::vector< Real > &	times,
		const bool	isTraining
	)		const

private

Definition at line 235 of file gaussiancam.cpp.

                                                                                                {
    // get state process
 
    auto process = cam_->stateProcess();
 
    // set reference date values, if there are no future simulation dates, we are done
 
    // FX, EQ, COMM indcies
    for (Size k = 0; k < indices_.size(); ++k) {
        paths[referenceDate_][k].setAll(process->initialValues().at(indexPositionInProcess_[k]));
    }
 
    // IR states per currency (they are all just 0)
    for (Size k = 0; k < currencies_.size(); ++k) {
        irStates[referenceDate()][k].setAll(0.0);
    }
 
    // INF DK or JY state, we happen to have two components (x,y) for each, so no case distinction needed
    for (Size k = 0; k < infIndices_.size(); ++k) {
        infStates[referenceDate()].push_back(
            std::make_pair(RandomVariable(nSamples, process->initialValues().at(infIndexPositionInProcess_[k])),
                           RandomVariable(nSamples, process->initialValues().at(infIndexPositionInProcess_[k] + 1))));
    }
 
    if (effectiveSimulationDates_.size() == 1)
        return;
 
    // populate path values
 
    if (process->size() == 1 && injectedPathTimes_ == nullptr) {
 
        // we treat the case of a one dimensional process separately for optimisation reasons; we know that in
        // this case we have a single, driftless LGM process for currency 0
 
        auto lgmProcess = QuantLib::ext::dynamic_pointer_cast<StochasticProcess1D>(cam_->lgm(0)->stateProcess());
 
        std::vector<Real> stdDevs(times.size() - 1);
        for (Size i = 0; i < times.size() - 1; ++i) {
            stdDevs[i] = lgmProcess->stdDeviation(times[i], 0.0, times[i + 1] - times[i]);
        }
 
        // generate paths using own variate generator
        auto gen =
            makeMultiPathVariateGenerator(isTraining ? mcParams_.trainingSequenceType : mcParams_.sequenceType, 1,
                                          times.size() - 1, isTraining ? mcParams_.trainingSeed : mcParams_.seed,
                                          mcParams_.sobolOrdering, mcParams_.sobolDirectionIntegers);
 
        for (auto s = std::next(irStates.begin(), 1); s != irStates.end(); ++s)
            for (auto& r : s->second)
                r.expand();
 
        for (Size path = 0; path < nSamples; ++path) {
            auto p = gen->next();
            Real state = 0.0;
            auto date = effectiveSimulationDates_.begin();
            for (Size i = 0; i < times.size() - 1; ++i) {
                state += stdDevs[i] * p.value[i][0];
                ++date;
                irStates[*date][0].data()[path] = state;
            }
        }
 
    } else {
 
        // case process size > 1 or we have injected paths, we use the normal process interface to evolve the process
 
        QuantLib::ext::shared_ptr<MultiPathGeneratorBase> pathGen;
 
        // build a temporary repository of the state prcess values, since we want to access them not path by path
        // below - for efficiency reasons the loop over the paths should be the innermost loop there!
 
        std::vector<std::vector<std::vector<Real>>> pathValues(
            effectiveSimulationDates_.size() - 1,
            std::vector<std::vector<Real>>(process->size(), std::vector<Real>(nSamples)));
 
        if (injectedPathTimes_ == nullptr) {
 
            // the usual path generator
 
            if (auto tmp = QuantLib::ext::dynamic_pointer_cast<CrossAssetStateProcess>(process)) {
                tmp->resetCache(timeGrid_.size() - 1);
            }
 
            auto pathGen =
                makeMultiPathGenerator(isTraining ? mcParams_.trainingSequenceType : mcParams_.sequenceType, process,
                                       timeGrid_, isTraining ? mcParams_.trainingSeed : mcParams_.seed,
                                       mcParams_.sobolOrdering, mcParams_.sobolDirectionIntegers);
            for (Size i = 0; i < nSamples; ++i) {
                MultiPath path = pathGen->next().value;
                for (Size j = 0; j < effectiveSimulationDates_.size() - 1; ++j) {
                    for (Size k = 0; k < process->size(); ++k) {
                        pathValues[j][k][i] = path[k][positionInTimeGrid_[j + 1]];
                    }
                }
            }
        } else {
 
            // simple linear interpolation of injected paths, TODO explore the usage of Brownian Bridges here
 
            std::vector<Real> relevantPathTimes;
            std::vector<Size> relevantPathIndices;
 
            for (Size j = 0; j < injectedPathRelevantTimeIndexes_->size(); ++j) {
                size_t pathIdx = (*injectedPathRelevantPathIndexes_)[j];
                size_t timeIdx = (*injectedPathRelevantTimeIndexes_)[j];
                relevantPathTimes.push_back((*injectedPathTimes_)[timeIdx]);
                relevantPathIndices.push_back(pathIdx);
            }
            Array y(relevantPathTimes.size());
            auto pathInterpolator =
                LinearFlat().interpolate(relevantPathTimes.begin(), relevantPathTimes.end(), y.begin());
            pathInterpolator.enableExtrapolation();
            for (Size i = 0; i < nSamples; ++i) {
                for (Size k = 0; k < process->size(); ++k) {
                    for (Size j = 0; j < relevantPathTimes.size(); ++j) {
                        y[j] = (*injectedPaths_)[relevantPathIndices[j]][projectedStateProcessIndices_[k]][i];
                    }
                    pathInterpolator.update();
                    for (Size j = 0; j < times.size() - 1; ++j) {
                        pathValues[j][k][i] = pathInterpolator(times[j + 1]);
                    }
                }
            }
        }
 
        // FX, EQ, COMM indices
        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();
            }
        }
        for (Size k = 0; k < indices_.size(); ++k) {
            for (Size j = 1; j < effectiveSimulationDates_.size(); ++j) {
                for (Size i = 0; i < nSamples; ++i) {
                    rvs[k][j - 1]->data()[i] = std::exp(pathValues[j - 1][indexPositionInProcess_[k]][i]);
                }
            }
        }
 
        // IR states per currency
        std::vector<std::vector<RandomVariable*>> rvs2(
            currencies_.size(), std::vector<RandomVariable*>(effectiveSimulationDates_.size() - 1));
        auto date2 = effectiveSimulationDates_.begin();
        for (Size i = 0; i < effectiveSimulationDates_.size() - 1; ++i) {
            ++date2;
            for (Size j = 0; j < currencies_.size(); ++j) {
                rvs2[j][i] = &irStates[*date2][j];
                rvs2[j][i]->expand();
            }
        }
        for (Size k = 0; k < currencies_.size(); ++k) {
            for (Size j = 1; j < effectiveSimulationDates_.size(); ++j) {
                for (Size i = 0; i < nSamples; ++i) {
                    rvs2[k][j - 1]->data()[i] = pathValues[j - 1][currencyPositionInProcess_[k]][i];
                }
            }
        }
 
        // INF states per index, again we do not need to distinguish DK and JY here
        std::vector<std::vector<RandomVariable*>> rvs3a(
            infIndices_.size(), std::vector<RandomVariable*>(effectiveSimulationDates_.size() - 1));
        std::vector<std::vector<RandomVariable*>> rvs3b(
            infIndices_.size(), std::vector<RandomVariable*>(effectiveSimulationDates_.size() - 1));
        auto date3 = effectiveSimulationDates_.begin();
        for (Size i = 0; i < effectiveSimulationDates_.size() - 1; ++i) {
            ++date3;
            for (Size j = 0; j < infIndices_.size(); ++j) {
                rvs3a[j][i] = &infStates[*date3][j].first;
                rvs3b[j][i] = &infStates[*date3][j].second;
                rvs3a[j][i]->expand();
                rvs3b[j][i]->expand();
            }
        }
        for (Size k = 0; k < infIndices_.size(); ++k) {
            for (Size j = 1; j < effectiveSimulationDates_.size(); ++j) {
                for (Size i = 0; i < nSamples; ++i) {
                    rvs3a[k][j - 1]->data()[i] = pathValues[j - 1][infIndexPositionInProcess_[k]][i];
                    rvs3b[k][j - 1]->data()[i] = pathValues[j - 1][infIndexPositionInProcess_[k] + 1][i];
                }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ cam_

const Handle<CrossAssetModel> cam_

private

Definition at line 104 of file gaussiancam.hpp.

◆ curves_

const std::vector<Handle<YieldTermStructure> > curves_

private

Definition at line 105 of file gaussiancam.hpp.

◆ fxSpots_

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

private

Definition at line 106 of file gaussiancam.hpp.

◆ mcParams_

const McParams mcParams_

private

Definition at line 107 of file gaussiancam.hpp.

◆ timeStepsPerYear_

const Size timeStepsPerYear_

private

Definition at line 108 of file gaussiancam.hpp.

◆ projectedStateProcessIndices_

const std::vector<Size> projectedStateProcessIndices_

private

Definition at line 109 of file gaussiancam.hpp.

◆ regressionVarianceCutoff_

const Real regressionVarianceCutoff_ = Null<Real>()

private

Definition at line 110 of file gaussiancam.hpp.

◆ referenceDate_

Date referenceDate_

mutableprivate

Definition at line 113 of file gaussiancam.hpp.

◆ effectiveSimulationDates_

std::set<Date> effectiveSimulationDates_

mutableprivate

Definition at line 114 of file gaussiancam.hpp.

◆ timeGrid_

TimeGrid timeGrid_

mutableprivate

Definition at line 115 of file gaussiancam.hpp.

◆ positionInTimeGrid_

std::vector<Size> positionInTimeGrid_

mutableprivate

Definition at line 116 of file gaussiancam.hpp.

◆ underlyingPaths_

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

mutableprivate

Definition at line 117 of file gaussiancam.hpp.

◆ irStates_

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

mutableprivate

Definition at line 118 of file gaussiancam.hpp.

◆ infStates_

std::map<Date, std::vector<std::pair<RandomVariable, RandomVariable> > > infStates_

mutableprivate

Definition at line 120 of file gaussiancam.hpp.

◆ underlyingPathsTraining_

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

mutableprivate

Definition at line 121 of file gaussiancam.hpp.

◆ irStatesTraining_

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

mutableprivate

Definition at line 122 of file gaussiancam.hpp.

◆ infStatesTraining_

std::map<Date, std::vector<std::pair<RandomVariable, RandomVariable> > > infStatesTraining_

mutableprivate

Definition at line 124 of file gaussiancam.hpp.

◆ inTrainingPhase_

bool inTrainingPhase_ = false

mutableprivate

Definition at line 125 of file gaussiancam.hpp.

◆ indexPositionInProcess_

std::vector<Size> indexPositionInProcess_

mutableprivate

Definition at line 126 of file gaussiancam.hpp.

◆ infIndexPositionInProcess_

std::vector<Size> infIndexPositionInProcess_

mutableprivate

Definition at line 127 of file gaussiancam.hpp.

◆ currencyPositionInProcess_

std::vector<Size> currencyPositionInProcess_

mutableprivate

Definition at line 128 of file gaussiancam.hpp.

◆ irIndexPositionInCam_

std::vector<Size> irIndexPositionInCam_

mutableprivate

Definition at line 129 of file gaussiancam.hpp.

◆ infIndexPositionInCam_

std::vector<Size> infIndexPositionInCam_

mutableprivate

Definition at line 130 of file gaussiancam.hpp.

◆ currencyPositionInCam_

std::vector<Size> currencyPositionInCam_

mutableprivate

Definition at line 131 of file gaussiancam.hpp.

◆ eqIndexInCam_

std::vector<Size> eqIndexInCam_

mutableprivate

Definition at line 132 of file gaussiancam.hpp.

◆ comIndexInCam_

std::vector<Size> comIndexInCam_

mutableprivate

Definition at line 133 of file gaussiancam.hpp.

◆ conditionalExpectationUseIr_

bool conditionalExpectationUseIr_

mutableprivate

Definition at line 134 of file gaussiancam.hpp.

◆ conditionalExpectationUseInf_

bool conditionalExpectationUseInf_

mutableprivate

Definition at line 135 of file gaussiancam.hpp.

◆ conditionalExpectationUseAsset_

bool conditionalExpectationUseAsset_

mutableprivate

Definition at line 136 of file gaussiancam.hpp.

◆ irIndexValueCache_

std::map<std::tuple<Size, Date, Date>, RandomVariable> irIndexValueCache_

mutableprivate

Definition at line 139 of file gaussiancam.hpp.

◆ injectedPathTimes_

const std::vector<QuantLib::Real>* injectedPathTimes_ = nullptr

private

Definition at line 142 of file gaussiancam.hpp.

◆ injectedPaths_

const std::vector<std::vector<QuantExt::RandomVariable> >* injectedPaths_ = nullptr

private

Definition at line 143 of file gaussiancam.hpp.

◆ injectedPathRelevantPathIndexes_

const std::vector<size_t>* injectedPathRelevantPathIndexes_

private

Definition at line 144 of file gaussiancam.hpp.

◆ injectedPathRelevantTimeIndexes_

const std::vector<size_t>* injectedPathRelevantTimeIndexes_

private

Definition at line 145 of file gaussiancam.hpp.

◆ overwriteModelSize_

Size overwriteModelSize_ = Null<Size>()

private

Definition at line 146 of file gaussiancam.hpp.

◆ storedRegressionModel_

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

mutableprivate

Definition at line 149 of file gaussiancam.hpp.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GaussianCam()

Member Function Documentation

◆ type()

◆ referenceDate()

◆ size()

◆ npv()

◆ fwdCompAvg()

◆ releaseMemory()

◆ resetNPVMem()

◆ toggleTrainingPaths()

◆ trainingSamples()

◆ injectPaths()

◆ getFutureBarrierProb()

◆ performCalculations()

◆ getIndexValue()

◆ getIrIndexValue()

◆ getInfIndexValue()

◆ getDiscount() [1/2]

◆ getNumeraire()

◆ getFxSpot()

◆ getDiscount() [2/2]

◆ populatePathValues()

Member Data Documentation

◆ cam_

◆ curves_

◆ fxSpots_

◆ mcParams_

◆ timeStepsPerYear_

◆ projectedStateProcessIndices_

◆ regressionVarianceCutoff_

◆ referenceDate_

◆ effectiveSimulationDates_

◆ timeGrid_

◆ positionInTimeGrid_

◆ underlyingPaths_

◆ irStates_

◆ infStates_

◆ underlyingPathsTraining_

◆ irStatesTraining_

◆ infStatesTraining_

◆ inTrainingPhase_

◆ indexPositionInProcess_

◆ infIndexPositionInProcess_

◆ currencyPositionInProcess_

◆ irIndexPositionInCam_

◆ infIndexPositionInCam_

◆ currencyPositionInCam_

◆ eqIndexInCam_

◆ comIndexInCam_

◆ conditionalExpectationUseIr_

◆ conditionalExpectationUseInf_

◆ conditionalExpectationUseAsset_

◆ irIndexValueCache_

◆ injectedPathTimes_

◆ injectedPaths_

◆ injectedPathRelevantPathIndexes_

◆ injectedPathRelevantTimeIndexes_

◆ overwriteModelSize_

◆ storedRegressionModel_