CrossAssetModel Class Reference

Cross Asset Model. More...

#include <qle/models/crossassetmodel.hpp>

Inheritance diagram for CrossAssetModel:

Collaboration diagram for CrossAssetModel:

Classes
struct	cache_hasher
struct	cache_key

Public Types
enum class	AssetType : Size {   IR = 0 , FX = 1 , INF = 2 , CR = 3 ,   EQ = 4 , COM = 5 , CrState = 6 }
enum class	ModelType {   LGM1F , HW , BS , DK ,   CIRPP , JY , GAB , GENERIC }
enum class	Discretization { Euler , Exact }

Public Member Functions
	CrossAssetModel (const std::vector< QuantLib::ext::shared_ptr< Parametrization > > &parametrizations, const Matrix &correlation=Matrix(), const SalvagingAlgorithm::Type salvaging=SalvagingAlgorithm::None, const IrModel::Measure measure=IrModel::Measure::LGM, const Discretization discretization=Discretization::Exact)
	CrossAssetModel (const std::vector< QuantLib::ext::shared_ptr< IrModel > > &currencyModels, const std::vector< QuantLib::ext::shared_ptr< FxBsParametrization > > &fxParametrizations, const Matrix &correlation=Matrix(), const SalvagingAlgorithm::Type salvaging=SalvagingAlgorithm::None, const IrModel::Measure measure=IrModel::Measure::LGM, const Discretization discretization=Discretization::Exact)
QuantLib::ext::shared_ptr< CrossAssetStateProcess >	stateProcess () const
Size	dimension () const
Size	brownians () const
Size	auxBrownians () const
Size	totalNumberOfParameters () const
Size	components (const AssetType t) const
Size	brownians (const AssetType t, const Size i) const
Size	auxBrownians (const AssetType t, const Size i) const
Size	stateVariables (const AssetType t, const Size i) const
ModelType	modelType (const AssetType t, const Size i) const
IrModel::Measure	measure () const
Size	ccyIndex (const Currency &ccy) const
Size	eqIndex (const std::string &eqName) const
Size	infIndex (const std::string &index) const
Size	crName (const std::string &name) const
Size	comIndex (const std::string &comName) const
void	update () override
void	generateArguments () override
const std::vector< QuantLib::ext::shared_ptr< Parametrization > > &	parametrizations () const
const QuantLib::ext::shared_ptr< Parametrization >	ir (const Size ccy) const
const QuantLib::ext::shared_ptr< Parametrization >	fx (const Size ccy) const
const QuantLib::ext::shared_ptr< Parametrization >	inf (const Size i) const
const QuantLib::ext::shared_ptr< Parametrization >	cr (const Size i) const
const QuantLib::ext::shared_ptr< Parametrization >	eq (const Size i) const
const QuantLib::ext::shared_ptr< Parametrization >	com (const Size i) const
const QuantLib::ext::shared_ptr< Parametrization >	crstate (const Size i) const
const QuantLib::ext::shared_ptr< IrModel >	irModel (const Size ccy) const
QuantLib::Real	numeraire (const Size ccy, const QuantLib::Time t, const QuantLib::Array &x, const QuantLib::Handle< QuantLib::YieldTermStructure > &discountCurve=Handle< YieldTermStructure >(), const QuantLib::Array &aux=Array()) const
QuantLib::Real	discountBond (const Size ccy, const QuantLib::Time t, const QuantLib::Time T, const QuantLib::Array &x, const QuantLib::Handle< QuantLib::YieldTermStructure > &discountCurve=Handle< YieldTermStructure >()) const
const QuantLib::ext::shared_ptr< HwModel >	hw (const Size ccy) const
const QuantLib::ext::shared_ptr< IrHwParametrization >	irhw (const Size ccy) const
const QuantLib::ext::shared_ptr< LinearGaussMarkovModel >	lgm (const Size ccy) const
const QuantLib::ext::shared_ptr< IrLgm1fParametrization >	irlgm1f (const Size ccy) const
Real	numeraire (const Size ccy, const Time t, const Real x, Handle< YieldTermStructure > discountCurve=Handle< YieldTermStructure >()) const
Real	bankAccountNumeraire (const Size ccy, const Time t, const Real x, const Real y, Handle< YieldTermStructure > discountCurve=Handle< YieldTermStructure >()) const
Real	discountBond (const Size ccy, const Time t, const Time T, const Real x, Handle< YieldTermStructure > discountCurve=Handle< YieldTermStructure >()) const
Real	reducedDiscountBond (const Size ccy, const Time t, const Time T, const Real x, Handle< YieldTermStructure > discountCurve=Handle< YieldTermStructure >()) const
Real	discountBondOption (const Size ccy, Option::Type type, const Real K, const Time t, const Time S, const Time T, Handle< YieldTermStructure > discountCurve=Handle< YieldTermStructure >()) const
const QuantLib::ext::shared_ptr< FxModel >	fxModel (const Size ccy) const
const QuantLib::ext::shared_ptr< FxBsParametrization >	fxbs (const Size ccy) const
const QuantLib::ext::shared_ptr< InfDkParametrization >	infdk (const Size i) const
const QuantLib::ext::shared_ptr< InfJyParameterization >	infjy (const Size i) const
	Inflation JY component. More...
const QuantLib::ext::shared_ptr< CrLgm1fParametrization >	crlgm1f (const Size i) const
const QuantLib::ext::shared_ptr< CrCirpp >	crcirppModel (const Size i) const
const QuantLib::ext::shared_ptr< CrCirppParametrization >	crcirpp (const Size i) const
const QuantLib::ext::shared_ptr< EqBsParametrization >	eqbs (const Size ccy) const
const QuantLib::ext::shared_ptr< CommodityModel >	comModel (const Size com) const
const QuantLib::ext::shared_ptr< CommoditySchwartzParametrization >	combs (const Size ccy) const
const QuantLib::ext::shared_ptr< CrStateParametrization >	crstateParam (const Size index) const
const Matrix &	correlation () const
void	checkCorrelationMatrix () const
Size	idx (const AssetType t, const Size i) const
Size	cIdx (const AssetType t, const Size i, const Size offset=0) const
Size	wIdx (const AssetType t, const Size i, const Size offset=0) const
Size	pIdx (const AssetType t, const Size i, const Size offset=0) const
Real	correlation (const AssetType s, const Size i, const AssetType t, const Size j, const Size iOffset=0, const Size jOffset=0) const
void	setCorrelation (const AssetType s, const Size i, const AssetType t, const Size j, const Real value, const Size iOffset=0, const Size jOffset=0)
Discretization	discretization () const
SalvagingAlgorithm::Type	salvagingAlgorithm () const
void	setIntegrationPolicy (const QuantLib::ext::shared_ptr< Integrator > integrator, const bool usePiecewiseIntegration=true) const
const QuantLib::ext::shared_ptr< Integrator >	integrator () const
std::pair< Real, Real >	infdkV (const Size i, const Time t, const Time T)
std::pair< Real, Real >	infdkI (const Size i, const Time t, const Time T, const Real z, const Real y)
Real	infdkYY (const Size i, const Time t, const Time S, const Time T, const Real z, const Real y, const Real irz)
std::pair< Real, Real >	crlgm1fS (const Size i, const Size ccy, const Time t, const Time T, const Real z, const Real y) const
std::pair< Real, Real >	crcirppS (const Size i, const Time t, const Time T, const Real y, const Real s) const
virtual Handle< DefaultProbabilityTermStructure >	crTs (const Size i) const
virtual std::pair< Real, Real >	crS (const Size i, const Size ccy, const Time t, const Time T, const Real z, const Real y) const
void	calibrateIrLgm1fVolatilitiesIterative (const Size ccy, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &helpers, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >())
void	calibrateIrLgm1fReversionsIterative (const Size ccy, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &helpers, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >())
void	calibrateIrLgm1fGlobal (const Size ccy, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &helpers, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >())
void	calibrateBsVolatilitiesIterative (const AssetType &assetType, const Size aIdx, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &helpers, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >())
void	calibrateBsVolatilitiesGlobal (const AssetType &assetType, const Size aIdx, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &helpers, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >())
void	calibrateInfDkVolatilitiesIterative (const Size index, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &helpers, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >())
void	calibrateInfDkReversionsIterative (const Size index, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &helpers, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >())
void	calibrateInfDkVolatilitiesGlobal (const Size index, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &helpers, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >())
void	calibrateInfDkReversionsGlobal (const Size index, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &helpers, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >())
void	calibrateInfJyGlobal (QuantLib::Size index, const std::vector< QuantLib::ext::shared_ptr< QuantLib::CalibrationHelper > > &helpers, QuantLib::OptimizationMethod &method, const QuantLib::EndCriteria &endCriteria, const std::map< QuantLib::Size, bool > &toCalibrate, const QuantLib::Constraint &constraint=QuantLib::Constraint(), const std::vector< QuantLib::Real > &weights=std::vector< QuantLib::Real >())
void	calibrateInfJyIterative (QuantLib::Size inflationModelIndex, QuantLib::Size parameterIndex, const std::vector< QuantLib::ext::shared_ptr< QuantLib::CalibrationHelper > > &helpers, QuantLib::OptimizationMethod &method, const QuantLib::EndCriteria &endCriteria, const QuantLib::Constraint &constraint=QuantLib::Constraint(), const std::vector< QuantLib::Real > &weights=std::vector< QuantLib::Real >())
void	calibrateCrLgm1fVolatilitiesIterative (const Size index, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &helpers, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >())
void	calibrateCrLgm1fReversionsIterative (const Size index, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &helpers, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >())
std::vector< bool >	MoveParameter (const AssetType t, const Size param, const Size index, const Size i)
Public Member Functions inherited from LinkableCalibratedModel
	LinkableCalibratedModel ()
void	update () override
virtual void	calibrate (const std::vector< QuantLib::ext::shared_ptr< CalibrationHelper > > &, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >(), const std::vector< bool > &fixParameters=std::vector< bool >())
	Calibrate to a set of market instruments (usually caps/swaptions) More...
virtual void	calibrate (const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &, OptimizationMethod &method, const EndCriteria &endCriteria, const Constraint &constraint=Constraint(), const std::vector< Real > &weights=std::vector< Real >(), const std::vector< bool > &fixParameters=std::vector< bool >())
	for backward compatibility More...
Real	value (const Array &params, const std::vector< QuantLib::ext::shared_ptr< CalibrationHelper > > &)
Real	value (const Array &params, const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &)
	for backward compatibility More...
const QuantLib::ext::shared_ptr< Constraint > &	constraint () const
EndCriteria::Type	endCriteria () const
	Returns end criteria result. More...
const Array &	problemValues () const
	Returns the problem values. More...
Array	params () const
	Returns array of arguments on which calibration is done. More...
virtual void	setParams (const Array &params)
virtual void	setParam (Size idx, const Real value)

Static Public Attributes
static constexpr Size	numberOfAssetTypes = 7

Protected Member Functions
	CrossAssetModel (const std::vector< QuantLib::ext::shared_ptr< Parametrization > > &parametrizations, const Matrix &correlation, SalvagingAlgorithm::Type salvaging, IrModel::Measure measure, const Discretization discretization, const bool)
Size	arguments (const AssetType t, const Size i) const
Size	aIdx (const AssetType t, const Size i, const Size offset=0) const
virtual std::pair< AssetType, ModelType >	getComponentType (const Size i) const
virtual Size	getNumberOfParameters (const Size i) const
virtual Size	getNumberOfBrownians (const Size i) const
virtual Size	getNumberOfAuxBrownians (const Size i) const
virtual Size	getNumberOfStateVariables (const Size i) const
void	updateIndices (const AssetType &t, const Size i, const Size cIdx, const Size wIdx, const Size pIdx, const Size aIdx)
virtual void	initialize ()
virtual void	initializeParametrizations ()
virtual void	initializeCorrelation ()
virtual void	initializeArguments ()
virtual void	finalizeArguments ()
virtual void	checkModelConsistency () const
virtual void	initDefaultIntegrator ()
Real	infV (const Size idx, const Size ccy, const Time t, const Time T) const
Real	crV (const Size idx, const Size ccy, const Time t, const Time T) const
void	appendToFixedParameterVector (const AssetType t, const AssetType v, const Size param, const Size index, const Size i, std::vector< bool > &res)
virtual void	generateArguments ()

Protected Attributes
boost::unordered_map< cache_key, std::pair< Real, Real >, cache_hasher >	cache_crlgm1fS_
boost::unordered_map< cache_key, std::pair< Real, Real >, cache_hasher >	cache_infdkI_
std::vector< Size >	components_
std::vector< std::vector< Size > >	idx_
std::vector< std::vector< Size > >	cIdx_
std::vector< std::vector< Size > >	wIdx_
std::vector< std::vector< Size > >	pIdx_
std::vector< std::vector< Size > >	aIdx_
std::vector< std::vector< Size > >	brownians_
std::vector< std::vector< Size > >	auxBrownians_
std::vector< std::vector< Size > >	stateVariables_
std::vector< std::vector< Size > >	numArguments_
Size	totalDimension_
Size	totalNumberOfBrownians_
Size	totalNumberOfAuxBrownians_
Size	totalNumberOfParameters_
std::vector< std::vector< ModelType > >	modelType_
std::vector< QuantLib::ext::shared_ptr< Parametrization > >	p_
std::vector< QuantLib::ext::shared_ptr< IrModel > >	irModels_
std::vector< QuantLib::ext::shared_ptr< FxModel > >	fxModels_
std::vector< QuantLib::ext::shared_ptr< CrCirpp > >	crcirppModel_
std::vector< QuantLib::ext::shared_ptr< CommodityModel > >	comModels_
Matrix	rho_
SalvagingAlgorithm::Type	salvaging_
IrModel::Measure	measure_
Discretization	discretization_
QuantLib::ext::shared_ptr< Integrator >	integrator_
QuantLib::ext::shared_ptr< CrossAssetStateProcess >	stateProcess_
Protected Attributes inherited from LinkableCalibratedModel
std::vector< QuantLib::ext::shared_ptr< Parameter > >	arguments_
QuantLib::ext::shared_ptr< Constraint >	constraint_
EndCriteria::Type	endCriteria_
Array	problemValues_

Detailed Description

Cross Asset Model.

Definition at line 58 of file crossassetmodel.hpp.

Member Enumeration Documentation

AssetType

enum class AssetType : Size

strong

Enumerator
IR
FX
INF
CR
EQ
COM
CrState

Definition at line 60 of file crossassetmodel.hpp.

: Size { IR = 0, FX = 1, INF = 2, CR = 3, EQ = 4, COM = 5, CrState = 6 };

ModelType

enum class ModelType

strong

Enumerator
LGM1F
HW
BS
DK
CIRPP
JY
GAB
GENERIC

Definition at line 61 of file crossassetmodel.hpp.

{ LGM1F, HW, BS, DK, CIRPP, JY, GAB, GENERIC };

Discretization

enum class Discretization

strong

Enumerator
Euler
Exact

Definition at line 62 of file crossassetmodel.hpp.

{ Euler, Exact };

Constructor & Destructor Documentation

CrossAssetModel() [1/3]

CrossAssetModel	(	const std::vector< QuantLib::ext::shared_ptr< Parametrization > > &	parametrizations,
		const Matrix &	correlation = Matrix(),
		const SalvagingAlgorithm::Type	salvaging = SalvagingAlgorithm::None,
		const IrModel::Measure	measure = IrModel::Measure::LGM,
		const Discretization	discretization = Discretization::Exact
	)

Parametrizations must be given in the following order

• IR (first parametrization defines the domestic currency)
• FX (for all pairs domestic-ccy defined by the IR models)
• INF (optionally, ccy must be a subset of the IR ccys)
• CR (optionally, ccy must be a subset of the IR ccys)
• EQ (for all names equity currency defined in Parametrization)
• COM (for all names commodity currency defined in Parametrization) If the correlation matrix is not given, it is initialized as the unit matrix (and can be customized after construction of the model).

All IR components must be of type HW or LGM1F, i.e. you can't mix the two types.

Definition at line 87 of file crossassetmodel.cpp.

    : LinkableCalibratedModel(), p_(parametrizations), rho_(correlation), salvaging_(salvaging), measure_(measure),
      discretization_(discretization) {
    initialize();
}

Here is the call graph for this function:

CrossAssetModel() [2/3]

CrossAssetModel	(	const std::vector< QuantLib::ext::shared_ptr< IrModel > > &	currencyModels,
		const std::vector< QuantLib::ext::shared_ptr< FxBsParametrization > > &	fxParametrizations,
		const Matrix &	correlation = Matrix(),
		const SalvagingAlgorithm::Type	salvaging = SalvagingAlgorithm::None,
		const IrModel::Measure	measure = IrModel::Measure::LGM,
		const Discretization	discretization = Discretization::Exact
	)

IR-FX model based constructor

Definition at line 95 of file crossassetmodel.cpp.

    : LinkableCalibratedModel(), irModels_(currencyModels), rho_(correlation), salvaging_(salvaging), measure_(measure),
      discretization_(discretization) {
    for (Size i = 0; i < currencyModels.size(); ++i) {
        p_.push_back(currencyModels[i]->parametrizationBase());
    }
    for (Size i = 0; i < fxParametrizations.size(); ++i) {
        p_.push_back(fxParametrizations[i]);
    }
    initialize();
}

Here is the call graph for this function:

CrossAssetModel() [3/3]

CrossAssetModel ( const std::vector< QuantLib::ext::shared_ptr< Parametrization > > &  parametrizations, const Matrix &  correlation, SalvagingAlgorithm::Type  salvaging, IrModel::Measure  measure, const Discretization  discretization, const bool    )

protected

Definition at line 422 of file crossassetmodel.hpp.

        : LinkableCalibratedModel(), p_(parametrizations), rho_(correlation), salvaging_(salvaging), measure_(measure), discretization_(discretization) {
    }

Member Function Documentation

stateProcess()

QuantLib::ext::shared_ptr< CrossAssetStateProcess > stateProcess

(

)

const

returns the state process with a given discretization

Definition at line 110 of file crossassetmodel.cpp.

                                                                                  {
    if (stateProcess_ == nullptr) {
        stateProcess_ = QuantLib::ext::make_shared<CrossAssetStateProcess>(shared_from_this());
    }
    return stateProcess_;
}

Here is the caller graph for this function:

dimension()

Size dimension

(

)

const

total dimension of model (sum of number of state variables)

Definition at line 513 of file crossassetmodel.hpp.

{ return totalDimension_; }

Here is the caller graph for this function:

brownians() [1/2]

Size brownians

(

)

const

total number of Brownian motions (excluding aux brownians)

Definition at line 515 of file crossassetmodel.hpp.

{ return totalNumberOfBrownians_; }

Here is the caller graph for this function:

auxBrownians() [1/2]

Size auxBrownians

(

)

const

total number of aux Brownian motions

Definition at line 517 of file crossassetmodel.hpp.

{ return totalNumberOfAuxBrownians_; }

Here is the caller graph for this function:

totalNumberOfParameters()

Size totalNumberOfParameters

(

)

const

total number of parameters that can be calibrated

Definition at line 519 of file crossassetmodel.hpp.

{ return totalNumberOfParameters_; }

components()

Size components

(

const AssetType

t

)

const

number of components for an asset class

Definition at line 117 of file crossassetmodel.cpp.

{ return components_[(Size)t]; }

Here is the caller graph for this function:

brownians() [2/2]

Size brownians	(	const AssetType	t,
		const Size	i
	)		const

number of brownian motions for a component excluding aux Brownians

Definition at line 176 of file crossassetmodel.cpp.

                                                                     {
    QL_REQUIRE(brownians_[(Size)t].size() > i,
               "CrossAssetModel::brownians(): asset class " << t << ", component " << i << " not known.");
    return brownians_[(Size)t][i];
}

auxBrownians() [2/2]

Size auxBrownians	(	const AssetType	t,
		const Size	i
	)		const

number of aux brownian motions for a component

Definition at line 182 of file crossassetmodel.cpp.

                                                                        {
    QL_REQUIRE(auxBrownians_[(Size)t].size() > i,
               "CrossAssetModel::auxBrownians(): asset class " << t << ", component " << i << " not known.");
    return auxBrownians_[(Size)t][i];
}

stateVariables()

Size stateVariables	(	const AssetType	t,
		const Size	i
	)		const

number of state variables for a component

Definition at line 188 of file crossassetmodel.cpp.

                                                                          {
    QL_REQUIRE(stateVariables_[(Size)t].size() > i,
               "CrossAssetModel::stateVariables(): asset class " << t << ", component " << i << " not known.");
    return stateVariables_[(Size)t][i];
}

Here is the caller graph for this function:

modelType()

CrossAssetModel::ModelType modelType	(	const AssetType	t,
		const Size	i
	)		const

model type of a component

Definition at line 200 of file crossassetmodel.cpp.

                                                                                         {
    QL_REQUIRE(modelType_[(Size)t].size() > i,
               "CrossAssetModel::modelType(): asset class " << t << ", component " << i << " not known.");
    return modelType_[(Size)t][i];
}

Here is the caller graph for this function:

measure()

IrModel::Measure measure

(

)

const

Choice of probability measure

Definition at line 122 of file crossassetmodel.hpp.

{ return measure_; }

Here is the caller graph for this function:

ccyIndex()

Size ccyIndex

(

const Currency &

ccy

)

const

return index for currency (0 = domestic, 1 = first foreign currency and so on)

Definition at line 119 of file crossassetmodel.cpp.

                                                        {
    Size i = 0;
    while (i < components(CrossAssetModel::AssetType::IR) && ir(i)->currency() != ccy)
        ++i;
    QL_REQUIRE(i < components(CrossAssetModel::AssetType::IR),
               "currency " << ccy.code() << " not present in cross asset model");
    return i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eqIndex()

Size eqIndex

(

const std::string &

eqName

)

const

return index for equity (0 = first equity)

Definition at line 128 of file crossassetmodel.cpp.

                                                         {
    Size i = 0;
    while (i < components(CrossAssetModel::AssetType::EQ) && eq(i)->name() != name)
        ++i;
    QL_REQUIRE(i < components(CrossAssetModel::AssetType::EQ),
               "equity name " << name << " not present in cross asset model");
    return i;
}

Here is the call graph for this function:

infIndex()

Size infIndex

(

const std::string &

index

)

const

return index for inflation (0 = first inflation index)

Definition at line 146 of file crossassetmodel.cpp.

                                                           {
    Size i = 0;
    while (i < components(CrossAssetModel::AssetType::INF) && inf(i)->name() != index)
        ++i;
    QL_REQUIRE(i < components(CrossAssetModel::AssetType::INF),
               "inflation index " << index << " not present in cross asset model");
    return i;
}

Here is the call graph for this function:

crName()

Size crName

(

const std::string &

name

)

const

return index for credit (0 = first credit name)

Definition at line 155 of file crossassetmodel.cpp.

                                                        {
    Size i = 0;
    while (i < components(CrossAssetModel::AssetType::CR) && cr(i)->name() != name)
        ++i;
    QL_REQUIRE(i < components(CrossAssetModel::AssetType::INF),
               "credit name " << name << " not present in cross asset model");
    return i;
}

Here is the call graph for this function:

comIndex()

Size comIndex

(

const std::string &

comName

)

const

return index for commodity (0 = first equity)

Definition at line 137 of file crossassetmodel.cpp.

                                                          {
    Size i = 0;
    while (i < components(CrossAssetModel::AssetType::COM) && com(i)->name() != name)
        ++i;
    QL_REQUIRE(i < components(CrossAssetModel::AssetType::COM),
               "commodity name " << name << " not present in cross asset model");
    return i;
}

Here is the call graph for this function:

update()

void update ( )

override

observer and linked calibrated model interface

Definition at line 164 of file crossassetmodel.cpp.

                             {
    cache_crlgm1fS_.clear();
    cache_infdkI_.clear();
    for (Size i = 0; i < p_.size(); ++i) {
        p_[i]->update();
    }
    stateProcess()->resetCache(0); // disable cache
    notifyObservers();
}

Here is the call graph for this function:

Here is the caller graph for this function:

generateArguments()

void generateArguments ( )

overridevirtual

Reimplemented from LinkableCalibratedModel.

Definition at line 174 of file crossassetmodel.cpp.

{ update(); }

Here is the call graph for this function:

parametrizations()

const std::vector< QuantLib::ext::shared_ptr< Parametrization > > & parametrizations

(

)

const

the vector of parametrizations

Definition at line 145 of file crossassetmodel.hpp.

{ return p_; }

ir()

const QuantLib::ext::shared_ptr< Parametrization > ir

(

const Size

ccy

)

const

components per asset class, see below for specific model type inspectors

Definition at line 521 of file crossassetmodel.hpp.

                                                                                            {
    return p_[idx(CrossAssetModel::AssetType::IR, ccy)];
}

Here is the call graph for this function:

Here is the caller graph for this function:

fx()

const QuantLib::ext::shared_ptr< Parametrization > fx

(

const Size

ccy

)

const

Definition at line 525 of file crossassetmodel.hpp.

                                                                                            {
    return p_[idx(CrossAssetModel::AssetType::FX, ccy)];
}

Here is the call graph for this function:

Here is the caller graph for this function:

inf()

const QuantLib::ext::shared_ptr< Parametrization > inf

(

const Size

i

)

const

Definition at line 529 of file crossassetmodel.hpp.

                                                                                           {
    return p_[idx(CrossAssetModel::AssetType::INF, i)];
}

Here is the call graph for this function:

Here is the caller graph for this function:

cr()

const QuantLib::ext::shared_ptr< Parametrization > cr

(

const Size

i

)

const

Definition at line 533 of file crossassetmodel.hpp.

                                                                                          {
    return p_[idx(CrossAssetModel::AssetType::CR, i)];
}

Here is the call graph for this function:

Here is the caller graph for this function:

eq()

const QuantLib::ext::shared_ptr< Parametrization > eq

(

const Size

i

)

const

Definition at line 537 of file crossassetmodel.hpp.

                                                                                          {
    return QuantLib::ext::static_pointer_cast<Parametrization>(p_[idx(CrossAssetModel::AssetType::EQ, i)]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

com()

const QuantLib::ext::shared_ptr< Parametrization > com

(

const Size

i

)

const

Definition at line 541 of file crossassetmodel.hpp.

                                                                                           {
    return QuantLib::ext::static_pointer_cast<Parametrization>(p_[idx(CrossAssetModel::AssetType::COM, i)]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

crstate()

const QuantLib::ext::shared_ptr< Parametrization > crstate

(

const Size

i

)

const

irModel()

const QuantLib::ext::shared_ptr< IrModel > irModel

(

const Size

ccy

)

const

Definition at line 545 of file crossassetmodel.hpp.

                                                                                         {
    return irModels_[ccy];
}

Here is the caller graph for this function:

numeraire() [1/2]

QuantLib::Real numeraire	(	const Size	ccy,
		const QuantLib::Time	t,
		const QuantLib::Array &	x,
		const QuantLib::Handle< QuantLib::YieldTermStructure > &	discountCurve = Handle<YieldTermStructure>(),
		const QuantLib::Array &	aux = Array()
	)		const

numeraire

Definition at line 628 of file crossassetmodel.hpp.

                                                                                 {
    return irModel(ccy)->numeraire(t, x, discountCurve, aux);
}

Here is the call graph for this function:

discountBond() [1/2]

QuantLib::Real discountBond	(	const Size	ccy,
		const QuantLib::Time	t,
		const QuantLib::Time	T,
		const QuantLib::Array &	x,
		const QuantLib::Handle< QuantLib::YieldTermStructure > &	discountCurve = Handle< YieldTermStructure >()
	)		const

discount bond

hw()

const QuantLib::ext::shared_ptr< HwModel > hw

(

const Size

ccy

)

const

HW components, ccy=0 refers to the domestic currency

Definition at line 557 of file crossassetmodel.hpp.

                                                                                    {
    auto tmp = QuantLib::ext::dynamic_pointer_cast<HwModel>(irModels_[idx(CrossAssetModel::AssetType::IR, ccy)]);
    QL_REQUIRE(tmp, "model at " << ccy << " is not IR-HW");
    return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

irhw()

const QuantLib::ext::shared_ptr< IrHwParametrization > irhw

(

const Size

ccy

)

const

Definition at line 563 of file crossassetmodel.hpp.

                                                                                                  {
    return hw(ccy)->parametrization();
}

Here is the call graph for this function:

lgm()

const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > lgm

(

const Size

ccy

)

const

LGM1F components, ccy=0 refers to the domestic currency

Definition at line 567 of file crossassetmodel.hpp.

                                                                                                    {
    auto tmp = QuantLib::ext::dynamic_pointer_cast<LinearGaussMarkovModel>(irModels_[idx(CrossAssetModel::AssetType::IR, ccy)]);
    QL_REQUIRE(tmp, "model at " << ccy << " is not IR-LGM1F");
    return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

irlgm1f()

const QuantLib::ext::shared_ptr< IrLgm1fParametrization > irlgm1f

(

const Size

ccy

)

const

Definition at line 573 of file crossassetmodel.hpp.

                                                                                                        {
    return lgm(ccy)->parametrization();
}

Here is the call graph for this function:

Here is the caller graph for this function:

numeraire() [2/2]

Real numeraire	(	const Size	ccy,
		const Time	t,
		const Real	x,
		Handle< YieldTermStructure >	discountCurve = Handle<YieldTermStructure>()
	)		const

DEPRECATED LGM measure numeraire

Definition at line 634 of file crossassetmodel.hpp.

                                                                                       {
    return lgm(ccy)->numeraire(t, x, discountCurve);
}

Here is the call graph for this function:

bankAccountNumeraire()

Real bankAccountNumeraire	(	const Size	ccy,
		const Time	t,
		const Real	x,
		const Real	y,
		Handle< YieldTermStructure >	discountCurve = Handle<YieldTermStructure>()
	)		const

DEPRECATED LGM - Bank account measure numeraire B(t) as a function of drifted LGM state variable x and drift-free auxiliary state variable y

Definition at line 639 of file crossassetmodel.hpp.

                                                                                                  {
    return lgm(ccy)->bankAccountNumeraire(t, x, y, discountCurve);
}

Here is the call graph for this function:

discountBond() [2/2]

Real discountBond	(	const Size	ccy,
		const Time	t,
		const Time	T,
		const Real	x,
		Handle< YieldTermStructure >	discountCurve = Handle<YieldTermStructure>()
	)		const

DEPRECATED LGM specific discountBond

Definition at line 644 of file crossassetmodel.hpp.

                                                                                          {
    return lgm(ccy)->discountBond(t, T, x, discountCurve);
}

Here is the call graph for this function:

reducedDiscountBond()

Real reducedDiscountBond	(	const Size	ccy,
		const Time	t,
		const Time	T,
		const Real	x,
		Handle< YieldTermStructure >	discountCurve = Handle<YieldTermStructure>()
	)		const

DEPRECATED LGM specific discountBond

Definition at line 649 of file crossassetmodel.hpp.

                                                                                                 {
    return lgm(ccy)->reducedDiscountBond(t, T, x, discountCurve);
}

Here is the call graph for this function:

discountBondOption()

Real discountBondOption	(	const Size	ccy,
		Option::Type	type,
		const Real	K,
		const Time	t,
		const Time	S,
		const Time	T,
		Handle< YieldTermStructure >	discountCurve = Handle<YieldTermStructure>()
	)		const

DEPRECATED LGM specific discountBond

Definition at line 654 of file crossassetmodel.hpp.

                                                                                                {
    return lgm(ccy)->discountBondOption(type, K, t, S, T, discountCurve);
}

Here is the call graph for this function:

fxModel()

const QuantLib::ext::shared_ptr< FxModel > fxModel

(

const Size

ccy

)

const

Definition at line 549 of file crossassetmodel.hpp.

                                                                                         {
    return fxModels_[ccy];
}

fxbs()

const QuantLib::ext::shared_ptr< FxBsParametrization > fxbs

(

const Size

ccy

)

const

FXBS components, ccy=0 referes to the first foreign currency, so it corresponds to ccy+1 if you want to get the corresponding irmgl1f component

Definition at line 660 of file crossassetmodel.hpp.

                                                                                                  {
    QuantLib::ext::shared_ptr<FxBsParametrization> tmp =
        QuantLib::ext::dynamic_pointer_cast<FxBsParametrization>(p_[idx(CrossAssetModel::AssetType::FX, ccy)]);
    QL_REQUIRE(tmp, "model at " << ccy << " is not FX-BS");
    return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

infdk()

const QuantLib::ext::shared_ptr< InfDkParametrization > infdk

(

const Size

i

)

const

INF DK components

Definition at line 577 of file crossassetmodel.hpp.

                                                                                                  {
    QuantLib::ext::shared_ptr<InfDkParametrization> tmp =
        QuantLib::ext::dynamic_pointer_cast<InfDkParametrization>(p_[idx(CrossAssetModel::AssetType::INF, i)]);
    QL_REQUIRE(tmp, "model at " << i << " is not INF-DK");
    return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

infjy()

const QuantLib::ext::shared_ptr< InfJyParameterization > infjy

(

const Size

i

)

const

Inflation JY component.

Definition at line 584 of file crossassetmodel.hpp.

                                                                                                   {
    auto tmp = QuantLib::ext::dynamic_pointer_cast<InfJyParameterization>(p_[idx(CrossAssetModel::AssetType::INF, i)]);
    QL_REQUIRE(tmp, "model at " << i << " is not INF-JY");
    return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

crlgm1f()

const QuantLib::ext::shared_ptr< CrLgm1fParametrization > crlgm1f

(

const Size

i

)

const

CR LGM 1F components

Definition at line 590 of file crossassetmodel.hpp.

                                                                                                      {
    QuantLib::ext::shared_ptr<CrLgm1fParametrization> tmp =
        QuantLib::ext::dynamic_pointer_cast<CrLgm1fParametrization>(p_[idx(CrossAssetModel::AssetType::CR, i)]);
    QL_REQUIRE(tmp, "model at " << i << " is not CR-LGM");
    return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

crcirppModel()

const QuantLib::ext::shared_ptr< CrCirpp > crcirppModel

(

const Size

i

)

const

CR CIR++ components

Definition at line 597 of file crossassetmodel.hpp.

                                                                                            {
    QuantLib::ext::shared_ptr<CrCirpp> tmp = crcirppModel_[i];
    QL_REQUIRE(tmp, "model at " << i << " is not CR-CIRPP");
    return tmp;
}

crcirpp()

const QuantLib::ext::shared_ptr< CrCirppParametrization > crcirpp

(

const Size

i

)

const

Definition at line 603 of file crossassetmodel.hpp.

                                                                                                      {
    QuantLib::ext::shared_ptr<CrCirppParametrization> tmp =
        QuantLib::ext::dynamic_pointer_cast<CrCirppParametrization>(p_[idx(CrossAssetModel::AssetType::CR, i)]);
    QL_REQUIRE(tmp, "model at " << i << " is not CR-CIRPP");
    return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eqbs()

const QuantLib::ext::shared_ptr< EqBsParametrization > eqbs

(

const Size

ccy

)

const

EQBS components

Definition at line 610 of file crossassetmodel.hpp.

                                                                                                   {
    QuantLib::ext::shared_ptr<EqBsParametrization> tmp =
        QuantLib::ext::dynamic_pointer_cast<EqBsParametrization>(p_[idx(CrossAssetModel::AssetType::EQ, name)]);
    QL_REQUIRE(tmp, "model at " << name << " is not EQ-BS");
    return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

comModel()

const QuantLib::ext::shared_ptr< CommodityModel > comModel

(

const Size

com

)

const

Definition at line 553 of file crossassetmodel.hpp.

                                                                                                 {
    return comModels_[com];
}

Here is the call graph for this function:

Here is the caller graph for this function:

combs()

const QuantLib::ext::shared_ptr< CommoditySchwartzParametrization > combs

(

const Size

ccy

)

const

COMBS components

Definition at line 617 of file crossassetmodel.hpp.

                                                                                                                 {
    QuantLib::ext::shared_ptr<CommoditySchwartzParametrization> tmp =
        QuantLib::ext::dynamic_pointer_cast<CommoditySchwartzParametrization>(p_[idx(CrossAssetModel::AssetType::COM, name)]);
    QL_REQUIRE(tmp, "model at " << name << " is not COM-BS");
    return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

crstateParam()

const QuantLib::ext::shared_ptr< CrStateParametrization > crstateParam

(

const Size

index

)

const

CreditState components

Definition at line 624 of file crossassetmodel.hpp.

                                                                                                           {
    return QuantLib::ext::static_pointer_cast<CrStateParametrization>(p_[idx(CrossAssetModel::AssetType::CrState, i)]);
}

Here is the call graph for this function:

correlation() [1/2]

const Matrix & correlation

(

)

const

correlation linking the different marginal models, note that the use of asset class pairs specific inspectors is recommended instead of the global matrix directly

Definition at line 667 of file crossassetmodel.hpp.

{ return rho_; }

Here is the caller graph for this function:

checkCorrelationMatrix()

void checkCorrelationMatrix

(

)

const

check if correlation matrix is valid

Definition at line 663 of file crossassetmodel.cpp.

                                                   {
    Size n = rho_.rows();
    Size m = rho_.columns();
    QL_REQUIRE(rho_.columns() == n, "correlation matrix (" << n << " x " << m << " must be square");
    for (Size i = 0; i < n; ++i) {
        for (Size j = 0; j < m; ++j) {
            QL_REQUIRE(close_enough(rho_[i][j], rho_[j][i]), "correlation matrix is not symmetric, for (i,j)=("
                                                                 << i << "," << j << ") rho(i,j)=" << rho_[i][j]
                                                                 << " but rho(j,i)=" << rho_[j][i]);
            QL_REQUIRE(close_enough(std::abs(rho_[i][j]), 1.0) || (rho_[i][j] > -1.0 && rho_[i][j] < 1.0),
                       "correlation matrix has invalid entry at (i,j)=(" << i << "," << j << ") equal to "
                                                                         << rho_[i][j]);
        }
        QL_REQUIRE(close_enough(rho_[i][i], 1.0), "correlation matrix must have unit diagonal elements, "
                                                  "but rho(i,i)="
                                                      << rho_[i][i] << " for i=" << i);
    }
 
    // if we salvage the matrix there is no point in checking for negative eigenvalues prior to that
    if (salvaging_ == SalvagingAlgorithm::None) {
        SymmetricSchurDecomposition ssd(rho_);
        for (Size i = 0; i < ssd.eigenvalues().size(); ++i) {
            QL_REQUIRE(ssd.eigenvalues()[i] >= 0.0,
                       "correlation matrix has negative eigenvalue at " << i << " (" << ssd.eigenvalues()[i] << ")");
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

idx()

Size idx	(	const AssetType	t,
		const Size	i
	)		const

index of component in the parametrization vector

Definition at line 206 of file crossassetmodel.cpp.

                                                               {
    QL_REQUIRE(idx_[(Size)t].size() > i,
               "CrossAssetModel::idx(): asset class " << t << ", component " << i << " not known.");
    return idx_[(Size)t][i];
}

Here is the caller graph for this function:

cIdx()

Size cIdx	(	const AssetType	t,
		const Size	i,
		const Size	offset = 0
	)		const

index of component in the correlation matrix, by offset

Definition at line 212 of file crossassetmodel.cpp.

                                                                                   {
    QL_REQUIRE(offset < brownians(t, i), "c-offset (" << offset << ") for asset class " << t << " and index " << i
                                                      << " must be in 0..." << brownians(t, i) - 1);
    QL_REQUIRE(cIdx_[(Size)t].size() > i,
               "CrossAssetModel::cIdx(): asset class " << t << ", component " << i << " not known.");
    return cIdx_[(Size)t][i] + offset;
}

Here is the call graph for this function:

Here is the caller graph for this function:

wIdx()

Size wIdx	(	const AssetType	t,
		const Size	i,
		const Size	offset = 0
	)		const

index of component in the Brownian vector (including aux brownians), by offset this is checked to be equal to cIdx for Euler discretization and pIdx for exact discretization as an internal assertion

Definition at line 220 of file crossassetmodel.cpp.

                                                                                   {
    QL_REQUIRE(offset < brownians(t, i) + auxBrownians(t, i), "c-offset (" << offset << ") for asset class " << t
                                                                           << " and index " << i << " must be in 0..."
                                                                           << brownians(t, i) + auxBrownians(t, i) - 1);
    QL_REQUIRE(wIdx_[(Size)t].size() > i,
               "CrossAssetModel::wIdx(): asset class " << t << ", component " << i << " not known.");
    return wIdx_[(Size)t][i] + offset;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pIdx()

Size pIdx	(	const AssetType	t,
		const Size	i,
		const Size	offset = 0
	)		const

index of component in the stochastic process array, by offset

Definition at line 229 of file crossassetmodel.cpp.

                                                                                   {
    QL_REQUIRE(offset < stateVariables(t, i), "p-offset (" << offset << ") for asset class " << t << " and index " << i
                                                           << " must be in 0..." << stateVariables(t, i) - 1);
    QL_REQUIRE(pIdx_[(Size)t].size() > i,
               "CrossAssetModel::pIdx(): asset class " << t << ", component " << i << " not known.");
    return pIdx_[(Size)t][i] + offset;
}

Here is the call graph for this function:

Here is the caller graph for this function:

correlation() [2/2]

Real correlation	(	const AssetType	s,
		const Size	i,
		const AssetType	t,
		const Size	j,
		const Size	iOffset = 0,
		const Size	jOffset = 0
	)		const

correlation between two components

Definition at line 245 of file crossassetmodel.cpp.

                                                            {
    return rho_(cIdx(s, i, iOffset), cIdx(t, j, jOffset));
}

Here is the call graph for this function:

setCorrelation()

void setCorrelation	(	const AssetType	s,
		const Size	i,
		const AssetType	t,
		const Size	j,
		const Real	value,
		const Size	iOffset = 0,
		const Size	jOffset = 0
	)

set correlation

Definition at line 250 of file crossassetmodel.cpp.

                                                                             {
    Size row = cIdx(s, i, iOffset);
    Size column = cIdx(t, j, jOffset);
    QL_REQUIRE(row != column || close_enough(value, 1.0), "correlation must be 1 at (" << row << "," << column << ")");
    QL_REQUIRE(value >= -1.0 && value <= 1.0, "correlation must be in [-1,1] at (" << row << "," << column << ")");
    // we can not check for non-negative eigenvalues, since we do not
    // know when the correlation matrix setup is finished, but this
    // is effectively one in the state process later on anyway and
    // the user can also use checkCorrelationMatrix() to verify this
    rho_(row, column) = rho_(column, row) = value;
    update();
}

Here is the call graph for this function:

discretization()

Discretization discretization

(

)

const

get discretization

Definition at line 264 of file crossassetmodel.hpp.

{ return discretization_; }

salvagingAlgorithm()

SalvagingAlgorithm::Type salvagingAlgorithm

(

)

const

get salvaging algorithm

Definition at line 267 of file crossassetmodel.hpp.

{ return salvaging_; }

setIntegrationPolicy()

void setIntegrationPolicy	(	const QuantLib::ext::shared_ptr< Integrator >	integrator,
		const bool	usePiecewiseIntegration = true
	)		const

analytical moments require numerical integration, which can be customized here

Definition at line 277 of file crossassetmodel.cpp.

                                                                                     {
 
    if (!usePiecewiseIntegration) {
        integrator_ = integrator;
        return;
    }
 
    // collect relevant times from parametrizations, we don't have to sort them or make them unique,
    // this is all done in PiecewiseIntegral for us
 
    std::vector<Time> allTimes;
    for (Size i = 0; i < p_.size(); ++i) {
        for (Size j = 0; j < getNumberOfParameters(i); ++j)
            allTimes.insert(allTimes.end(), p_[i]->parameterTimes(j).begin(), p_[i]->parameterTimes(j).end());
    }
 
    // use piecewise integrator avoiding the step points
    integrator_ = QuantLib::ext::make_shared<PiecewiseIntegral>(integrator, allTimes, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

integrator()

const QuantLib::ext::shared_ptr< Integrator > integrator

(

)

const

Definition at line 669 of file crossassetmodel.hpp.

{ return integrator_; }

Here is the caller graph for this function:

infdkV()

std::pair< Real, Real > infdkV	(	const Size	i,
		const Time	t,
		const Time	T
	)

return (V(t), V^tilde(t,T)) in the notation of the book

Definition at line 868 of file crossassetmodel.cpp.

                                                                                    {
    Size ccy = ccyIndex(infdk(i)->currency());
    cache_key k = {i, ccy, t, T};
    boost::unordered_map<cache_key, std::pair<Real, Real>>::const_iterator it = cache_infdkI_.find(k);
    Real V0, V_tilde;
 
    if (it == cache_infdkI_.end()) {
        V0 = infV(i, ccy, 0, t);
        V_tilde = infV(i, ccy, t, T) - infV(i, ccy, 0, T) + infV(i, ccy, 0, t);
        cache_infdkI_.insert(std::make_pair(k, std::make_pair(V0, V_tilde)));
    } else {
        // take V0 and V_tilde from cache
        V0 = it->second.first;
        V_tilde = it->second.second;
    }
    return std::make_pair(V0, V_tilde);
}

Here is the call graph for this function:

Here is the caller graph for this function:

infdkI()

std::pair< Real, Real > infdkI	(	const Size	i,
		const Time	t,
		const Time	T,
		const Real	z,
		const Real	y
	)

return (I(t), I^tilde(t,T)) in the notation of the book, note that I(0) is normalized to 1 here, i.e. you have to multiply the result with the index value (as of the base date of the inflation ts)

Definition at line 886 of file crossassetmodel.cpp.

                                                                                                                {
    QL_REQUIRE(t < T || close_enough(t, T), "infdkI: t (" << t << ") <= T (" << T << ") required");
    Real V0, V_tilde;
    std::pair<Real, Real> Vs = infdkV(i, t, T);
    V0 = Vs.first;
    V_tilde = Vs.second;
    Real Hyt = Hy(i).eval(*this, t);
    Real HyT = Hy(i).eval(*this, T);
 
    // TODO account for seasonality ...
    // compute final results depending on z and y
    const auto& zts = infdk(i)->termStructure();
    auto dc = irlgm1f(0)->termStructure()->dayCounter();
    bool indexIsInterpolated = true; // FIXME, though in line with the comment below
    Real growth_t = inflationGrowth(zts, t, dc, indexIsInterpolated);
    Real It = growth_t * std::exp(Hyt * z - y - V0);
    Real Itilde_t_T = inflationGrowth(zts, T, dc, indexIsInterpolated) / growth_t * std::exp((HyT - Hyt) * z + V_tilde);
    // concerning interpolation there is an inaccuracy here: if the index
    // is not interpolated, we still simulate the index value as of t
    // (and T), although we should go back to t, T which corresponds to
    // the last actual publication time of the index => is the approximation
    // here in this sense good enough that we can tolerate this?
    return std::make_pair(It, Itilde_t_T);
}

Here is the call graph for this function:

Here is the caller graph for this function:

infdkYY()

Real infdkYY	(	const Size	i,
		const Time	t,
		const Time	S,
		const Time	T,
		const Real	z,
		const Real	y,
		const Real	irz
	)

return YoYIIS(t) in the notation of the book, the year on year swaplet price from S to T, at time t

Definition at line 911 of file crossassetmodel.cpp.

                                              {
    Size ccy = ccyIndex(infdk(i)->currency());
 
    // Set Convexity adjustment set to 1.
    // TODO: Add calculation for DK convexity adjustment
    Real C_tilde = 1;
 
    Real I_tildeS = infdkI(i, t, S, z, y).second;
    Real I_tildeT = infdkI(i, t, T, z, y).second;
    Real Pn_t_T = lgm(ccy)->discountBond(t, T, irz);
 
    Real yySwaplet = (I_tildeT / I_tildeS) * Pn_t_T * C_tilde - Pn_t_T;
 
    return yySwaplet;
}

Here is the call graph for this function:

crlgm1fS()

std::pair< Real, Real > crlgm1fS	(	const Size	i,
		const Size	ccy,
		const Time	t,
		const Time	T,
		const Real	z,
		const Real	y
	)		const

returns (S(t), S^tilde(t,T)) in the notation of the book

Definition at line 928 of file crossassetmodel.cpp.

                                                                    {
    QL_REQUIRE(ccy < components(CrossAssetModel::AssetType::IR),
               "ccy index (" << ccy << ") must be in 0..." << (components(CrossAssetModel::AssetType::IR) - 1));
    QL_REQUIRE(t < T || close_enough(t, T), "crlgm1fS: t (" << t << ") <= T (" << T << ") required");
    QL_REQUIRE(modelType(CrossAssetModel::AssetType::CR, i) == CrossAssetModel::ModelType::LGM1F,
               "model at " << i << " is not CR-LGM1F");
    cache_key k = {i, ccy, t, T};
    boost::unordered_map<cache_key, std::pair<Real, Real>>::const_iterator it = cache_crlgm1fS_.find(k);
    Real V0, V_tilde;
    Real Hlt = Hl(i).eval(*this, t);
    Real HlT = Hl(i).eval(*this, T);
 
    if (it == cache_crlgm1fS_.end()) {
        // compute V0 and V_tilde
        if (ccy == 0) {
            // domestic credit
            Real Hzt = Hz(0).eval(*this, t);
            Real HzT = Hz(0).eval(*this, T);
            Real zetal0 = zetal(i).eval(*this, t);
            Real zetal1 = integral(*this, P(Hl(i), al(i), al(i)), 0.0, t);
            Real zetal2 = integral(*this, P(Hl(i), Hl(i), al(i), al(i)), 0.0, t);
            Real zetanl0 = integral(*this, P(rzl(0, i), az(0), al(i)), 0.0, t);
            Real zetanl1 = integral(*this, P(rzl(0, i), Hl(i), az(0), al(i)), 0.0, t);
            // opposite signs for last two terms in the book
            V0 = 0.5 * Hlt * Hlt * zetal0 - Hlt * zetal1 + 0.5 * zetal2 + Hzt * Hlt * zetanl0 - Hzt * zetanl1;
            V_tilde = -0.5 * (HlT * HlT - Hlt * Hlt) * zetal0 + (HlT - Hlt) * zetal1 -
                      (HzT * HlT - Hzt * Hlt) * zetanl0 + (HzT - Hzt) * zetanl1;
        } else {
            // foreign credit
            V0 = crV(i, ccy, 0, t);
            V_tilde = crV(i, ccy, t, T) - crV(i, ccy, 0, T) + crV(i, ccy, 0, t);
        }
        cache_crlgm1fS_.insert(std::make_pair(k, std::make_pair(V0, V_tilde)));
    } else {
        // take V0 and V_tilde from cache
        V0 = it->second.first;
        V_tilde = it->second.second;
    }
    // compute final results depending on z and y
    // opposite sign for V0 in the book
    Real St = crlgm1f(i)->termStructure()->survivalProbability(t) * std::exp(-Hlt * z + y - V0);
    Real Stilde_t_T = crlgm1f(i)->termStructure()->survivalProbability(T) /
                      crlgm1f(i)->termStructure()->survivalProbability(t) * std::exp(-(HlT - Hlt) * z + V_tilde);
    return std::make_pair(St, Stilde_t_T);
}

Here is the call graph for this function:

Here is the caller graph for this function:

crcirppS()

std::pair< Real, Real > crcirppS	(	const Size	i,
		const Time	t,
		const Time	T,
		const Real	y,
		const Real	s
	)		const

returns (S(t), S^tilde(t,T)) in the notation of the book

Definition at line 975 of file crossassetmodel.cpp.

                                                                    {
    QL_REQUIRE(modelType(CrossAssetModel::AssetType::CR, i) == CrossAssetModel::ModelType::CIRPP,
               "model at " << i << " is not CR-CIR");
    if (close_enough(t, T))
        return std::make_pair(s, 1.0);
    else
        return std::make_pair(s, crcirppModel_[i]->survivalProbability(t, T, y));
}

Here is the call graph for this function:

Here is the caller graph for this function:

crTs()

Handle< DefaultProbabilityTermStructure > crTs ( const Size  i ) const

virtual

tentative: more generic interface that is agnostic of the model type - so far only for CR

Definition at line 671 of file crossassetmodel.hpp.

                                                                                       {
    if (modelType(CrossAssetModel::AssetType::CR, i) == CrossAssetModel::ModelType::LGM1F)
        return crlgm1f(i)->termStructure();
    if (modelType(CrossAssetModel::AssetType::CR, i) == CrossAssetModel::ModelType::CIRPP)
        return crcirpp(i)->termStructure();
    QL_FAIL("model at " << i << " is not CR-*");
}

Here is the call graph for this function:

crS()

std::pair< Real, Real > crS ( const Size  i, const Size  ccy, const Time  t, const Time  T, const Real  z, const Real  y  ) const

virtual

Definition at line 679 of file crossassetmodel.hpp.

                                                                                    {
    if (modelType(CrossAssetModel::AssetType::CR, i) == CrossAssetModel::ModelType::LGM1F)
        return crlgm1fS(i, ccy, t, T, z, y);
    if (modelType(CrossAssetModel::AssetType::CR, i) == CrossAssetModel::ModelType::CIRPP) {
        QL_REQUIRE(ccy == 0, "CrossAssetModelPlus::crS() only implemented for ccy=0, got " << ccy);
        return crcirppS(i, t, T, z, y);
    }
    QL_FAIL("model at " << i << " is not CR-*");
}

Here is the call graph for this function:

calibrateIrLgm1fVolatilitiesIterative()

void calibrateIrLgm1fVolatilitiesIterative	(	const Size	ccy,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	helpers,
		OptimizationMethod &	method,
		const EndCriteria &	endCriteria,
		const Constraint &	constraint = Constraint(),
		const std::vector< Real > &	weights = std::vector<Real>()
	)

calibration procedures

calibrate irlgm1f volatilities to a sequence of ir options with expiry times equal to step times in the parametrization

Definition at line 725 of file crossassetmodel.cpp.

                                                                                                  {
    lgm(ccy)->calibrateVolatilitiesIterative(helpers, method, endCriteria, constraint, weights);
    update();
}

Here is the call graph for this function:

calibrateIrLgm1fReversionsIterative()

void calibrateIrLgm1fReversionsIterative	(	const Size	ccy,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	helpers,
		OptimizationMethod &	method,
		const EndCriteria &	endCriteria,
		const Constraint &	constraint = Constraint(),
		const std::vector< Real > &	weights = std::vector<Real>()
	)

calibrate irlgm1f reversion to a sequence of ir options with maturities equal to step times in the parametrization

Definition at line 732 of file crossassetmodel.cpp.

                                                                                                  {
    lgm(ccy)->calibrateReversionsIterative(helpers, method, endCriteria, constraint, weights);
    update();
}

Here is the call graph for this function:

calibrateIrLgm1fGlobal()

void calibrateIrLgm1fGlobal	(	const Size	ccy,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	helpers,
		OptimizationMethod &	method,
		const EndCriteria &	endCriteria,
		const Constraint &	constraint = Constraint(),
		const std::vector< Real > &	weights = std::vector<Real>()
	)

calibrate irlgm1f parameters for one ccy globally to a set of ir options

Definition at line 739 of file crossassetmodel.cpp.

                                                                                                           {
    lgm(ccy)->calibrate(helpers, method, endCriteria, constraint, weights);
    update();
}

Here is the call graph for this function:

calibrateBsVolatilitiesIterative()

void calibrateBsVolatilitiesIterative	(	const AssetType &	assetType,
		const Size	aIdx,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	helpers,
		OptimizationMethod &	method,
		const EndCriteria &	endCriteria,
		const Constraint &	constraint = Constraint(),
		const std::vector< Real > &	weights = std::vector<Real>()
	)

calibrate eq or fx volatilities to a sequence of options with expiry times equal to step times in the parametrization

Definition at line 747 of file crossassetmodel.cpp.

                                    {
    QL_REQUIRE(assetType == CrossAssetModel::AssetType::FX || assetType == CrossAssetModel::AssetType::EQ,
               "Unsupported AssetType for BS calibration");
    for (Size i = 0; i < helpers.size(); ++i) {
        std::vector<QuantLib::ext::shared_ptr<BlackCalibrationHelper>> h(1, helpers[i]);
        calibrate(h, method, endCriteria, constraint, weights, MoveParameter(assetType, 0, idx, i));
    }
    update();
}

Here is the call graph for this function:

calibrateBsVolatilitiesGlobal()

void calibrateBsVolatilitiesGlobal	(	const AssetType &	assetType,
		const Size	aIdx,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	helpers,
		OptimizationMethod &	method,
		const EndCriteria &	endCriteria,
		const Constraint &	constraint = Constraint(),
		const std::vector< Real > &	weights = std::vector<Real>()
	)

calibrate eq/fx/com volatilities globally to a set of eq/fx/com options

Definition at line 760 of file crossassetmodel.cpp.

                                    {
    QL_REQUIRE(assetType == CrossAssetModel::AssetType::FX || assetType == CrossAssetModel::AssetType::EQ,
               "Unsupported AssetType for BS calibration");
    calibrate(helpers, method, endCriteria, constraint, weights, MoveParameter(assetType, 0, aIdx, Null<Size>()));
    update();
}

Here is the call graph for this function:

calibrateInfDkVolatilitiesIterative()

void calibrateInfDkVolatilitiesIterative	(	const Size	index,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	helpers,
		OptimizationMethod &	method,
		const EndCriteria &	endCriteria,
		const Constraint &	constraint = Constraint(),
		const std::vector< Real > &	weights = std::vector<Real>()
	)

calibrate infdk volatilities to a sequence of cpi options with expiry times equal to step times in the parametrization

Definition at line 770 of file crossassetmodel.cpp.

                                                                                                  {
    for (Size i = 0; i < helpers.size(); ++i) {
        std::vector<QuantLib::ext::shared_ptr<BlackCalibrationHelper>> h(1, helpers[i]);
        calibrate(h, method, endCriteria, constraint, weights,
                  MoveParameter(CrossAssetModel::AssetType::INF, 0, index, i));
    }
    update();
}

Here is the call graph for this function:

calibrateInfDkReversionsIterative()

void calibrateInfDkReversionsIterative	(	const Size	index,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	helpers,
		OptimizationMethod &	method,
		const EndCriteria &	endCriteria,
		const Constraint &	constraint = Constraint(),
		const std::vector< Real > &	weights = std::vector<Real>()
	)

calibrate infdk reversions to a sequence of cpi options with maturity times equal to step times in the parametrization

Definition at line 781 of file crossassetmodel.cpp.

                                                                                                  {
    for (Size i = 0; i < helpers.size(); ++i) {
        std::vector<QuantLib::ext::shared_ptr<BlackCalibrationHelper>> h(1, helpers[i]);
        calibrate(h, method, endCriteria, constraint, weights,
                  MoveParameter(CrossAssetModel::AssetType::INF, 1, index, i));
    }
    update();
}

Here is the call graph for this function:

calibrateInfDkVolatilitiesGlobal()

void calibrateInfDkVolatilitiesGlobal	(	const Size	index,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	helpers,
		OptimizationMethod &	method,
		const EndCriteria &	endCriteria,
		const Constraint &	constraint = Constraint(),
		const std::vector< Real > &	weights = std::vector<Real>()
	)

calibrate infdk volatilities globally to a sequence of cpi cap/floors

Definition at line 792 of file crossassetmodel.cpp.

                                                                                                  {
    calibrate(helpers, method, endCriteria, constraint, weights,
              MoveParameter(CrossAssetModel::AssetType::INF, 0, index, Null<Size>()));
    update();
}

Here is the call graph for this function:

calibrateInfDkReversionsGlobal()

void calibrateInfDkReversionsGlobal	(	const Size	index,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	helpers,
		OptimizationMethod &	method,
		const EndCriteria &	endCriteria,
		const Constraint &	constraint = Constraint(),
		const std::vector< Real > &	weights = std::vector<Real>()
	)

calibrate infdk reversions globally to a sequence of cpi cap/floors

Definition at line 800 of file crossassetmodel.cpp.

                                                                                                  {
    calibrate(helpers, method, endCriteria, constraint, weights,
              MoveParameter(CrossAssetModel::AssetType::INF, 1, index, Null<Size>()));
    update();
}

Here is the call graph for this function:

calibrateInfJyGlobal()

void calibrateInfJyGlobal	(	QuantLib::Size	index,
		const std::vector< QuantLib::ext::shared_ptr< QuantLib::CalibrationHelper > > &	helpers,
		QuantLib::OptimizationMethod &	method,
		const QuantLib::EndCriteria &	endCriteria,
		const std::map< QuantLib::Size, bool > &	toCalibrate,
		const QuantLib::Constraint &	constraint = QuantLib::Constraint(),
		const std::vector< QuantLib::Real > &	weights = std::vector<QuantLib::Real>()
	)

Calibrate JY inflation parameters globally.

The parameter toCalibrate indicates which parameters of the JY inflation model that we want to calibrate. The map key should be in {0, 1, 2} where 0 indicates the real rate volatility, 1 indicates the real rate reversion and 2 indicates the inflation index volatility. The value is true if we wish to calibrate the parameter and false if we do not want to calibrate it.

Definition at line 808 of file crossassetmodel.cpp.

                                                                        {
 
    // Initialise the parameters to move first to get the size.
    vector<bool> fixedParams = MoveParameter(CrossAssetModel::AssetType::INF, 0, index, Null<Size>());
    std::fill(fixedParams.begin(), fixedParams.end(), true);
 
    // Update fixedParams with parameters that need to be calibrated.
    for (const auto& kv : toCalibrate) {
        if (kv.second) {
            vector<bool> tmp = MoveParameter(CrossAssetModel::AssetType::INF, kv.first, index, Null<Size>());
            std::transform(fixedParams.begin(), fixedParams.end(), tmp.begin(), fixedParams.begin(),
                           std::logical_and<bool>());
        }
    }
 
    // Perform the calibration
    calibrate(helpers, method, endCriteria, constraint, weights, fixedParams);
 
    update();
}

Here is the call graph for this function:

calibrateInfJyIterative()

void calibrateInfJyIterative	(	QuantLib::Size	inflationModelIndex,
		QuantLib::Size	parameterIndex,
		const std::vector< QuantLib::ext::shared_ptr< QuantLib::CalibrationHelper > > &	helpers,
		QuantLib::OptimizationMethod &	method,
		const QuantLib::EndCriteria &	endCriteria,
		const QuantLib::Constraint &	constraint = QuantLib::Constraint(),
		const std::vector< QuantLib::Real > &	weights = std::vector<QuantLib::Real>()
	)

Calibrate a single JY inflation parameter iteratively.

Calibrate one of real rate volatility, real rate reversion or inflation index volatility. The parameterIndex indicates the parameter that should be calibrated where 0 indicates the real rate volatility, 1 indicates the real rate reversion and 2 indicates the inflation index volatility.

Definition at line 832 of file crossassetmodel.cpp.

                                                                                                         {
 
    for (Size i = 0; i < helpers.size(); ++i) {
        vector<QuantLib::ext::shared_ptr<CalibrationHelper>> h(1, helpers[i]);
        calibrate(h, method, endCriteria, constraint, weights,
                  MoveParameter(CrossAssetModel::AssetType::INF, pIdx, mIdx, i));
    }
 
    update();
}

Here is the call graph for this function:

calibrateCrLgm1fVolatilitiesIterative()

void calibrateCrLgm1fVolatilitiesIterative	(	const Size	index,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	helpers,
		OptimizationMethod &	method,
		const EndCriteria &	endCriteria,
		const Constraint &	constraint = Constraint(),
		const std::vector< Real > &	weights = std::vector<Real>()
	)

calibrate crlgm1f volatilities to a sequence of cds options with expiry times equal to step times in the parametrization

Definition at line 846 of file crossassetmodel.cpp.

                                                                                                  {
    for (Size i = 0; i < helpers.size(); ++i) {
        std::vector<QuantLib::ext::shared_ptr<BlackCalibrationHelper>> h(1, helpers[i]);
        calibrate(h, method, endCriteria, constraint, weights,
                  MoveParameter(CrossAssetModel::AssetType::CR, 0, index, i));
    }
    update();
}

Here is the call graph for this function:

calibrateCrLgm1fReversionsIterative()

void calibrateCrLgm1fReversionsIterative	(	const Size	index,
		const std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > &	helpers,
		OptimizationMethod &	method,
		const EndCriteria &	endCriteria,
		const Constraint &	constraint = Constraint(),
		const std::vector< Real > &	weights = std::vector<Real>()
	)

calibrate crlgm1f reversions to a sequence of cds options with maturity times equal to step times in the parametrization

Definition at line 857 of file crossassetmodel.cpp.

                                                                                                  {
    for (Size i = 0; i < helpers.size(); ++i) {
        std::vector<QuantLib::ext::shared_ptr<BlackCalibrationHelper>> h(1, helpers[i]);
        calibrate(h, method, endCriteria, constraint, weights,
                  MoveParameter(CrossAssetModel::AssetType::CR, 1, index, i));
    }
    update();
}

Here is the call graph for this function:

MoveParameter()

std::vector< bool > MoveParameter	(	const AssetType	t,
		const Size	param,
		const Size	index,
		const Size	i
	)

Definition at line 1062 of file crossassetmodel.cpp.

                                                                                                                  {
    QL_REQUIRE(param == Null<Size>() || param < arguments(t, index), "parameter for " << t << " at " << index << " ("
                                                                                      << param << ") out of bounds 0..."
                                                                                      << arguments(t, index) - 1);
    std::vector<bool> res(0);
    appendToFixedParameterVector(CrossAssetModel::AssetType::IR, t, param, index, i, res);
    appendToFixedParameterVector(CrossAssetModel::AssetType::FX, t, param, index, i, res);
    appendToFixedParameterVector(CrossAssetModel::AssetType::INF, t, param, index, i, res);
    appendToFixedParameterVector(CrossAssetModel::AssetType::CR, t, param, index, i, res);
    appendToFixedParameterVector(CrossAssetModel::AssetType::EQ, t, param, index, i, res);
    appendToFixedParameterVector(CrossAssetModel::AssetType::COM, t, param, index, i, res);
    return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

arguments()

Size arguments ( const AssetType  t, const Size  i  ) const

protected

number of arguments for a component

Definition at line 194 of file crossassetmodel.cpp.

                                                                     {
    QL_REQUIRE(numArguments_[(Size)t].size() > i,
               "CrossAssetModel::arguments(): asset class " << t << ", component " << i << " not known.");
    return numArguments_[(Size)t][i];
}

Here is the caller graph for this function:

aIdx()

Size aIdx ( const AssetType  t, const Size  i, const Size  offset = 0  ) const

protected

index of component in the arguments vector, by offset

Definition at line 237 of file crossassetmodel.cpp.

                                                                                   {
    QL_REQUIRE(offset < arguments(t, i), "a-offset (" << offset << ") for asset class " << t << " and index " << i
                                                      << " must be in 0..." << arguments(t, i) - 1);
    QL_REQUIRE(aIdx_[(Size)t].size() > i,
               "CrossAssetModel::aIdx(): asset class " << t << ", component " << i << " not known.");
    return aIdx_[(Size)t][i];
}

Here is the call graph for this function:

Here is the caller graph for this function:

getComponentType()

std::pair< CrossAssetModel::AssetType, CrossAssetModel::ModelType > getComponentType ( const Size  i ) const

protectedvirtual

asset and model type for given parametrization

Definition at line 299 of file crossassetmodel.cpp.

                                                    {
    if (QuantLib::ext::dynamic_pointer_cast<IrHwParametrization>(p_[i]))
        return std::make_pair(CrossAssetModel::AssetType::IR, CrossAssetModel::ModelType::HW);
    if (QuantLib::ext::dynamic_pointer_cast<IrLgm1fParametrization>(p_[i]))
        return std::make_pair(CrossAssetModel::AssetType::IR, CrossAssetModel::ModelType::LGM1F);
    if (QuantLib::ext::dynamic_pointer_cast<FxBsParametrization>(p_[i]))
        return std::make_pair(CrossAssetModel::AssetType::FX, CrossAssetModel::ModelType::BS);
    if (QuantLib::ext::dynamic_pointer_cast<InfDkParametrization>(p_[i]))
        return std::make_pair(CrossAssetModel::AssetType::INF, CrossAssetModel::ModelType::DK);
    if (QuantLib::ext::dynamic_pointer_cast<InfJyParameterization>(p_[i]))
        return std::make_pair(CrossAssetModel::AssetType::INF, CrossAssetModel::ModelType::JY);
    if (QuantLib::ext::dynamic_pointer_cast<CrLgm1fParametrization>(p_[i]))
        return std::make_pair(CrossAssetModel::AssetType::CR, CrossAssetModel::ModelType::LGM1F);
    if (QuantLib::ext::dynamic_pointer_cast<CrCirppParametrization>(p_[i]))
        return std::make_pair(CrossAssetModel::AssetType::CR, CrossAssetModel::ModelType::CIRPP);
    if (QuantLib::ext::dynamic_pointer_cast<EqBsParametrization>(p_[i]))
        return std::make_pair(CrossAssetModel::AssetType::EQ, CrossAssetModel::ModelType::BS);
    if (QuantLib::ext::dynamic_pointer_cast<CommoditySchwartzParametrization>(p_[i]))
        return std::make_pair(CrossAssetModel::AssetType::COM, CrossAssetModel::ModelType::BS);
    if (QuantLib::ext::dynamic_pointer_cast<CrStateParametrization>(p_[i]))
        return std::make_pair(CrossAssetModel::AssetType::CrState, CrossAssetModel::ModelType::GENERIC);
    QL_FAIL("parametrization " << i << " has unknown type");
}

Here is the caller graph for this function:

getNumberOfParameters()

Size getNumberOfParameters ( const Size  i ) const

protectedvirtual

number of parameters for given parametrization

Definition at line 323 of file crossassetmodel.cpp.

{ return p_[i]->numberOfParameters(); }

Here is the caller graph for this function:

getNumberOfBrownians()

Size getNumberOfBrownians ( const Size  i ) const

protectedvirtual

number of brownians (excluding aux brownians) for given parametrization

Definition at line 325 of file crossassetmodel.cpp.

                                                             {
    if (auto p = QuantLib::ext::dynamic_pointer_cast<IrHwParametrization>(p_[i])) {
        return p->m();
    }
    if (QuantLib::ext::dynamic_pointer_cast<IrLgm1fParametrization>(p_[i])) {
        return 1;
    }
    if (QuantLib::ext::dynamic_pointer_cast<FxBsParametrization>(p_[i]))
        return 1;
    if (QuantLib::ext::dynamic_pointer_cast<InfDkParametrization>(p_[i]))
        return 1;
    if (QuantLib::ext::dynamic_pointer_cast<InfJyParameterization>(p_[i]))
        return 2;
    if (QuantLib::ext::dynamic_pointer_cast<CrLgm1fParametrization>(p_[i]))
        return 1;
    if (QuantLib::ext::dynamic_pointer_cast<CrCirppParametrization>(p_[i]))
        return 1;
    if (QuantLib::ext::dynamic_pointer_cast<EqBsParametrization>(p_[i]))
        return 1;
    if (QuantLib::ext::dynamic_pointer_cast<CommoditySchwartzParametrization>(p_[i]))
        return 1;
    if (QuantLib::ext::dynamic_pointer_cast<CrStateParametrization>(p_[i]))
        return 1;
    QL_FAIL("parametrization " << i << " has unknown type");
}

Here is the caller graph for this function:

getNumberOfAuxBrownians()

Size getNumberOfAuxBrownians ( const Size  i ) const

protectedvirtual

number of aux brownians for given parametrization

Definition at line 351 of file crossassetmodel.cpp.

                                                                {
    if (auto p = QuantLib::ext::dynamic_pointer_cast<IrHwParametrization>(p_[i])) {
        return HwModel(p, measure_, getHwDiscretization(discretization_), i == 0).m_aux();
    }
    if (auto p = QuantLib::ext::dynamic_pointer_cast<IrLgm1fParametrization>(p_[i])) {
        return LGM(p, measure_, getLgm1fDiscretization(discretization_), i == 0).m_aux();
    }
    if (QuantLib::ext::dynamic_pointer_cast<FxBsParametrization>(p_[i]))
        return 0;
    if (QuantLib::ext::dynamic_pointer_cast<InfDkParametrization>(p_[i]))
        return discretization_ == Discretization::Exact ? 1 : 0;
    if (QuantLib::ext::dynamic_pointer_cast<InfJyParameterization>(p_[i]))
        return 0;
    if (QuantLib::ext::dynamic_pointer_cast<CrLgm1fParametrization>(p_[i]))
        return discretization_ == Discretization::Exact ? 1 : 0;
    if (QuantLib::ext::dynamic_pointer_cast<CrCirppParametrization>(p_[i]))
        return 0;
    if (QuantLib::ext::dynamic_pointer_cast<EqBsParametrization>(p_[i]))
        return 0;
    if (QuantLib::ext::dynamic_pointer_cast<CommoditySchwartzParametrization>(p_[i]))
        return 0;
    if (QuantLib::ext::dynamic_pointer_cast<CrStateParametrization>(p_[i]))
        return 0;
    QL_FAIL("parametrization " << i << " has unknown type");
}

Here is the call graph for this function:

Here is the caller graph for this function:

getNumberOfStateVariables()

Size getNumberOfStateVariables ( const Size  i ) const

protectedvirtual

number of state variables for given parametrization

Definition at line 377 of file crossassetmodel.cpp.

                                                                  {
    if (auto p = QuantLib::ext::dynamic_pointer_cast<IrHwParametrization>(p_[i])) {
        HwModel m(p, measure_, getHwDiscretization(discretization_), i == 0);
        return m.n() + m.n_aux();
    }
    if (auto p = QuantLib::ext::dynamic_pointer_cast<IrLgm1fParametrization>(p_[i])) {
        LGM m(p, measure_, getLgm1fDiscretization(discretization_), i == 0);
        return m.n() + m.n_aux();
    }
    if (QuantLib::ext::dynamic_pointer_cast<FxBsParametrization>(p_[i]))
        return 1;
    if (QuantLib::ext::dynamic_pointer_cast<InfDkParametrization>(p_[i]))
        return 2;
    if (QuantLib::ext::dynamic_pointer_cast<InfJyParameterization>(p_[i]))
        return 2;
    if (QuantLib::ext::dynamic_pointer_cast<CrLgm1fParametrization>(p_[i]))
        return 2;
    if (QuantLib::ext::dynamic_pointer_cast<CrCirppParametrization>(p_[i]))
        return 2;
    if (QuantLib::ext::dynamic_pointer_cast<EqBsParametrization>(p_[i]))
        return 1;
    if (QuantLib::ext::dynamic_pointer_cast<CommoditySchwartzParametrization>(p_[i]))
        return 1;
    if (QuantLib::ext::dynamic_pointer_cast<CrStateParametrization>(p_[i]))
        return 1;
    QL_FAIL("parametrization " << i << " has unknown type");
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateIndices()

void updateIndices ( const AssetType &  t, const Size  i, const Size  cIdx, const Size  wIdx, const Size  pIdx, const Size  aIdx  )

protected

helper function to init component indices

Definition at line 405 of file crossassetmodel.cpp.

                                                     {
    idx_[(Size)t].push_back(i);
    modelType_[(Size)t].push_back(getComponentType(i).second);
    brownians_[(Size)t].push_back(getNumberOfBrownians(i));
    auxBrownians_[(Size)t].push_back(getNumberOfAuxBrownians(i));
    stateVariables_[(Size)t].push_back(getNumberOfStateVariables(i));
    numArguments_[(Size)t].push_back(getNumberOfParameters(i));
    cIdx_[(Size)t].push_back(cIdx);
    wIdx_[(Size)t].push_back(wIdx);
    pIdx_[(Size)t].push_back(pIdx);
    aIdx_[(Size)t].push_back(aIdx);
    if (discretization_ == Discretization::Euler) {
        QL_REQUIRE(wIdx_[(Size)t].back() == cIdx_[(Size)t].back(),
                   "CrossAssetModel::updateIndices(): assertion error, wIdx ("
                       << wIdx_[(Size)t].back() << ") != cIdx (" << cIdx_[(Size)t].back() << ") for asset type " << t
                       << " at index " << wIdx_[(Size)t].size() << " for Euler discretization");
    } else {
        QL_REQUIRE(wIdx_[(Size)t].back() == pIdx_[(Size)t].back(),
                   "CrossAssetModel::updateIndices(): assertion error, wIdx ("
                       << wIdx_[(Size)t].back() << ") != pIdx (" << pIdx_[(Size)t].back() << ") for asset type " << t
                       << " at index " << wIdx_[(Size)t].size() << " for Exact discretization");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

initialize()

void initialize ( )

protectedvirtual

Definition at line 264 of file crossassetmodel.cpp.

                                 {
    initializeParametrizations();
    initializeCorrelation();
    initializeArguments();
    finalizeArguments();
    checkModelConsistency();
    initDefaultIntegrator();
}

Here is the call graph for this function:

Here is the caller graph for this function:

initializeParametrizations()

void initializeParametrizations ( )

protectedvirtual

Definition at line 430 of file crossassetmodel.cpp.

                                                 {
 
    // count the parametrizations and check their order and their support
 
    Size i = 0, j;
    Size cIdxTmp = 0, wIdxTmp = 0, pIdxTmp = 0, aIdxTmp = 0;
    components_.resize(numberOfAssetTypes, 0);
    idx_.resize(numberOfAssetTypes);
    cIdx_.resize(numberOfAssetTypes);
    wIdx_.resize(numberOfAssetTypes);
    pIdx_.resize(numberOfAssetTypes);
    aIdx_.resize(numberOfAssetTypes);
    brownians_.resize(numberOfAssetTypes);
    auxBrownians_.resize(numberOfAssetTypes);
    stateVariables_.resize(numberOfAssetTypes);
    numArguments_.resize(numberOfAssetTypes);
    modelType_.resize(numberOfAssetTypes);
 
    // IR parametrizations
 
    bool genericCtor = irModels_.empty();
    j = 0;
    while (i < p_.size() && getComponentType(i).first == CrossAssetModel::AssetType::IR) {
        QL_REQUIRE(j == 0 || getComponentType(i).second == getComponentType(0).second,
                   "All IR models must be of the same type (HW, LGM can not be mixed)");
        // initialize ir model, if generic constructor was used
        // evaluate bank account for j = 0 (domestic process
        if (genericCtor) {
            if (getComponentType(i).second == ModelType::LGM1F) {
                irModels_.push_back(QuantLib::ext::make_shared<LinearGaussMarkovModel>(
                    QuantLib::ext::dynamic_pointer_cast<IrLgm1fParametrization>(p_[i]), measure_,
                    getLgm1fDiscretization(discretization_), j == 0));
            } else if (getComponentType(i).second == ModelType::HW) {
                irModels_.push_back(QuantLib::ext::make_shared<HwModel>(QuantLib::ext::dynamic_pointer_cast<IrHwParametrization>(p_[i]),
                                                                measure_, getHwDiscretization(discretization_),
                                                                j == 0));
            } else {
                irModels_.push_back(nullptr);
            }
        }
        updateIndices(CrossAssetModel::AssetType::IR, i, cIdxTmp, wIdxTmp, pIdxTmp, aIdxTmp);
        cIdxTmp += getNumberOfBrownians(i);
        wIdxTmp += getNumberOfBrownians(i) + getNumberOfAuxBrownians(i);
        pIdxTmp += getNumberOfStateVariables(i);
        aIdxTmp += getNumberOfParameters(i);
        ++j;
        ++i;
    }
    components_[(Size)CrossAssetModel::AssetType::IR] = j;
 
    // FX parametrizations
 
    j = 0;
    while (i < p_.size() && getComponentType(i).first == CrossAssetModel::AssetType::FX) {
        fxModels_.push_back(QuantLib::ext::make_shared<FxBsModel>(QuantLib::ext::dynamic_pointer_cast<FxBsParametrization>(p_[i])));
        updateIndices(CrossAssetModel::AssetType::FX, i, cIdxTmp, wIdxTmp, pIdxTmp, aIdxTmp);
        cIdxTmp += getNumberOfBrownians(i);
        wIdxTmp += getNumberOfBrownians(i) + getNumberOfAuxBrownians(i);
        pIdxTmp += getNumberOfStateVariables(i);
        aIdxTmp += getNumberOfParameters(i);
        ++j;
        ++i;
    }
    components_[(Size)CrossAssetModel::AssetType::FX] = j;
 
    QL_REQUIRE(components_[(Size)CrossAssetModel::AssetType::IR] > 0, "at least one ir parametrization must be given");
 
    QL_REQUIRE(components_[(Size)CrossAssetModel::AssetType::FX] ==
                   components_[(Size)CrossAssetModel::AssetType::IR] - 1,
               "there must be n-1 fx "
               "for n ir parametrizations, found "
                   << components_[(Size)CrossAssetModel::AssetType::IR] << " ir and "
                   << components_[(Size)CrossAssetModel::AssetType::FX] << " fx parametrizations");
 
    // check currencies
 
    // without an order or a hash function on Currency this seems hard
    // to do in a simpler way ...
    Size uniqueCurrencies = 0;
    std::vector<Currency> currencies;
    for (Size i = 0; i < components_[(Size)CrossAssetModel::AssetType::IR]; ++i) {
        Size tmp = 1;
        for (Size j = 0; j < i; ++j) {
            if (ir(i)->currency() == currencies[j])
                tmp = 0;
        }
        uniqueCurrencies += tmp;
        currencies.push_back(ir(i)->currency());
    }
    QL_REQUIRE(uniqueCurrencies == components_[(Size)CrossAssetModel::AssetType::IR], "there are duplicate currencies "
                                                                                      "in the set of ir "
                                                                                      "parametrizations");
    for (Size i = 0; i < components_[(Size)CrossAssetModel::AssetType::FX]; ++i) {
        QL_REQUIRE(fx(i)->currency() == ir(i + 1)->currency(),
                   "fx parametrization #" << i << " must be for currency of ir parametrization #" << (i + 1)
                                          << ", but they are " << fx(i)->currency() << " and " << ir(i + 1)->currency()
                                          << " respectively");
    }
 
    // Inf parametrizations
 
    j = 0;
    while (i < p_.size() && getComponentType(i).first == CrossAssetModel::AssetType::INF) {
        updateIndices(CrossAssetModel::AssetType::INF, i, cIdxTmp, wIdxTmp, pIdxTmp, aIdxTmp);
        cIdxTmp += getNumberOfBrownians(i);
        wIdxTmp += getNumberOfBrownians(i) + getNumberOfAuxBrownians(i);
        pIdxTmp += getNumberOfStateVariables(i);
        aIdxTmp += getNumberOfParameters(i);
        ++j;
        ++i;
        // we do not check the currency, if not present among the model's
        // currencies, it will throw below
    }
    components_[(Size)CrossAssetModel::AssetType::INF] = j;
 
    // Cr parametrizations
 
    j = 0;
    while (i < p_.size() && getComponentType(i).first == CrossAssetModel::AssetType::CR) {
 
        if (getComponentType(i).second == CrossAssetModel::ModelType::CIRPP) {
            auto tmp = QuantLib::ext::dynamic_pointer_cast<CrCirppParametrization>(p_[i]);
            QL_REQUIRE(tmp, "CrossAssetModelPlus::initializeParametrizations(): expected CrCirppParametrization");
            crcirppModel_.push_back(QuantLib::ext::make_shared<CrCirpp>(tmp));
        } else
            crcirppModel_.push_back(QuantLib::ext::shared_ptr<CrCirpp>());
 
        updateIndices(CrossAssetModel::AssetType::CR, i, cIdxTmp, wIdxTmp, pIdxTmp, aIdxTmp);
        cIdxTmp += getNumberOfBrownians(i);
        wIdxTmp += getNumberOfBrownians(i) + getNumberOfAuxBrownians(i);
        pIdxTmp += getNumberOfStateVariables(i);
        aIdxTmp += getNumberOfParameters(i);
        ++j;
        ++i;
        // we do not check the currency, if not present among the model's
        // currencies, it will throw below
    }
    components_[(Size)CrossAssetModel::AssetType::CR] = j;
 
    // Eq parametrizations
 
    j = 0;
    while (i < p_.size() && getComponentType(i).first == CrossAssetModel::AssetType::EQ) {
        updateIndices(CrossAssetModel::AssetType::EQ, i, cIdxTmp, wIdxTmp, pIdxTmp, aIdxTmp);
        cIdxTmp += getNumberOfBrownians(i);
        wIdxTmp += getNumberOfBrownians(i) + getNumberOfAuxBrownians(i);
        pIdxTmp += getNumberOfStateVariables(i);
        aIdxTmp += getNumberOfParameters(i);
        ++j;
        ++i;
    }
    components_[(Size)CrossAssetModel::AssetType::EQ] = j;
 
    // check the equity currencies to ensure they are covered by CrossAssetModel
    for (Size i = 0; i < components(CrossAssetModel::AssetType::EQ); ++i) {
        Currency eqCcy = eq(i)->currency();
        try {
            Size eqCcyIdx = ccyIndex(eqCcy);
            QL_REQUIRE(eqCcyIdx < components_[(Size)CrossAssetModel::AssetType::IR],
                       "Invalid currency for equity " << eqbs(i)->name());
        } catch (...) {
            QL_FAIL("Invalid currency (" << eqCcy.code() << ") for equity " << eqbs(i)->name());
        }
    }
 
    // COM parametrizations
 
    j = 0;
    while (i < p_.size() && getComponentType(i).first == CrossAssetModel::AssetType::COM) {
        QuantLib::ext::shared_ptr<CommoditySchwartzParametrization> csp =
            QuantLib::ext::dynamic_pointer_cast<CommoditySchwartzParametrization>(p_[i]);
        QuantLib::ext::shared_ptr<CommoditySchwartzModel> csm =
            csp ? QuantLib::ext::make_shared<CommoditySchwartzModel>(csp, getComSchwartzDiscretization(discretization_))
                : nullptr;
        comModels_.push_back(csm);
        updateIndices(CrossAssetModel::AssetType::COM, i, cIdxTmp, wIdxTmp, pIdxTmp, aIdxTmp);
        cIdxTmp += getNumberOfBrownians(i);
        wIdxTmp += getNumberOfBrownians(i) + getNumberOfAuxBrownians(i);
        pIdxTmp += getNumberOfStateVariables(i);
        aIdxTmp += getNumberOfParameters(i);
        ++j;
        ++i;
    }
    components_[(Size)CrossAssetModel::AssetType::COM] = j;
 
    // CrState parametrizations
 
    j = 0;
    while (i < p_.size() && getComponentType(i).first == CrossAssetModel::AssetType::CrState) {
        updateIndices(CrossAssetModel::AssetType::CrState, i, cIdxTmp, wIdxTmp, pIdxTmp, aIdxTmp);
        cIdxTmp += getNumberOfBrownians(i);
        wIdxTmp += getNumberOfBrownians(i) + getNumberOfAuxBrownians(i);
        pIdxTmp += getNumberOfStateVariables(i);
        aIdxTmp += getNumberOfParameters(i);
        ++j;
        ++i;
    }
    components_[(Size)CrossAssetModel::AssetType::CrState] = j;
 
    // check the equity currencies to ensure they are covered by CrossAssetModel
    for (Size i = 0; i < components(CrossAssetModel::AssetType::COM); ++i) {
        Currency comCcy = com(i)->currency();
        try {
            Size comCcyIdx = ccyIndex(comCcy);
            QL_REQUIRE(comCcyIdx < components_[(Size)CrossAssetModel::AssetType::IR],
                       "Invalid currency for commodity " << combs(i)->name());
        } catch (...) {
            QL_FAIL("Invalid currency (" << comCcy.code() << ") for commodity " << combs(i)->name());
        }
    }
 
    // Summary statistics
 
    totalDimension_ = pIdxTmp;
    totalNumberOfBrownians_ = cIdxTmp;
    totalNumberOfAuxBrownians_ = wIdxTmp - cIdxTmp;
 
} // initParametrizations

Here is the call graph for this function:

Here is the caller graph for this function:

initializeCorrelation()

void initializeCorrelation ( )

protectedvirtual

Definition at line 649 of file crossassetmodel.cpp.

                                            {
    Size n = brownians();
    if (rho_.empty()) {
        rho_ = Matrix(n, n, 0.0);
        for (Size i = 0; i < n; ++i)
            rho_(i, i) = 1.0;
        return;
    }
    QL_REQUIRE(rho_.rows() == n && rho_.columns() == n, "correlation matrix is " << rho_.rows() << " x "
                                                                                 << rho_.columns() << " but should be "
                                                                                 << n << " x " << n);
    checkCorrelationMatrix();
}

Here is the call graph for this function:

Here is the caller graph for this function:

initializeArguments()

void initializeArguments ( )

protectedvirtual

Definition at line 691 of file crossassetmodel.cpp.

                                          {
    for (Size i = 0; i < p_.size(); ++i) {
        for (Size k = 0; k < getNumberOfParameters(i); ++k) {
            arguments_.push_back(p_[i]->parameter(k));
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

finalizeArguments()

void finalizeArguments ( )

protectedvirtual

Definition at line 699 of file crossassetmodel.cpp.

                                        {
    totalNumberOfParameters_ = 0;
    for (Size i = 0; i < arguments_.size(); ++i) {
        QL_REQUIRE(arguments_[i] != NULL, "unexpected error: argument " << i << " is null");
        totalNumberOfParameters_ += arguments_[i]->size();
    }
}

Here is the caller graph for this function:

checkModelConsistency()

void checkModelConsistency ( ) const

protectedvirtual

Definition at line 707 of file crossassetmodel.cpp.

                                                  {
    QL_REQUIRE(components(CrossAssetModel::AssetType::IR) > 0, "at least one IR component must be given");
    QL_REQUIRE(
        components(CrossAssetModel::AssetType::IR) + components(CrossAssetModel::AssetType::FX) +
                components(CrossAssetModel::AssetType::INF) + components(CrossAssetModel::AssetType::CR) +
                components(CrossAssetModel::AssetType::EQ) + components(CrossAssetModel::AssetType::COM) +
                components(CrossAssetModel::AssetType::CrState) ==
            p_.size(),
        "the parametrizations must be given in the following order: ir, "
        "fx, inf, cr, eq, com, found "
            << components(CrossAssetModel::AssetType::IR) << " ir, " << components(CrossAssetModel::AssetType::FX)
            << " bs, " << components(CrossAssetModel::AssetType::INF) << " inf, "
            << components(CrossAssetModel::AssetType::CR) << " cr, " << components(CrossAssetModel::AssetType::EQ)
            << " eq, " << components(CrossAssetModel::AssetType::COM) << " com, "
            << components(CrossAssetModel::AssetType::CrState) << "but there are " << p_.size()
            << " parametrizations given in total");
}

Here is the call graph for this function:

Here is the caller graph for this function:

initDefaultIntegrator()

void initDefaultIntegrator ( )

protectedvirtual

Definition at line 273 of file crossassetmodel.cpp.

                                            {
    setIntegrationPolicy(QuantLib::ext::make_shared<SimpsonIntegral>(1.0E-8, 100), true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

infV()

Real infV ( const Size  idx, const Size  ccy, const Time  t, const Time  T  ) const

protected

Definition at line 985 of file crossassetmodel.cpp.

                                                                                         {
    Real HyT = Hy(i).eval(*this, T);
    Real HdT = irlgm1f(0)->H(T);
    Real rhody = correlation(CrossAssetModel::AssetType::IR, 0, CrossAssetModel::AssetType::INF, i, 0, 0);
    Real V;
    if (ccy == 0) {
        V = 0.5 * (HyT * HyT * (zetay(i).eval(*this, T) - zetay(i).eval(*this, t)) -
                   2.0 * HyT * integral(*this, P(Hy(i), ay(i), ay(i)), t, T) +
                   integral(*this, P(Hy(i), Hy(i), ay(i), ay(i)), t, T)) -
            rhody * HdT *
                (HyT * integral(*this, P(az(0), ay(i)), t, T) - integral(*this, P(az(0), Hy(i), ay(i)), t, T));
    } else {
        Real HfT = irlgm1f(ccy)->H(T);
        Real rhofy = correlation(CrossAssetModel::AssetType::IR, ccy, CrossAssetModel::AssetType::INF, i, 0, 0);
        Real rhoxy = correlation(CrossAssetModel::AssetType::FX, ccy - 1, CrossAssetModel::AssetType::INF, i, 0, 0);
        V = 0.5 * (HyT * HyT * (zetay(i).eval(*this, T) - zetay(i).eval(*this, t)) -
                   2.0 * HyT * integral(*this, P(Hy(i), ay(i), ay(i)), t, T) +
                   integral(*this, P(Hy(i), Hy(i), ay(i), ay(i)), t, T)) -
            rhody * (HyT * integral(*this, P(Hz(0), az(0), ay(i)), t, T) -
                     integral(*this, P(Hz(0), az(0), Hy(i), ay(i)), t, T)) -
            rhofy * (HfT * HyT * integral(*this, P(az(ccy), ay(i)), t, T) -
                     HfT * integral(*this, P(az(ccy), Hy(i), ay(i)), t, T) -
                     HyT * integral(*this, P(Hz(ccy), az(ccy), ay(i)), t, T) +
                     integral(*this, P(Hz(ccy), az(ccy), Hy(i), ay(i)), t, T)) +
            rhoxy * (HyT * integral(*this, P(sx(ccy - 1), ay(i)), t, T) -
                     integral(*this, P(sx(ccy - 1), Hy(i), ay(i)), t, T));
    }
    return V;
}

Here is the call graph for this function:

Here is the caller graph for this function:

crV()

Real crV ( const Size  idx, const Size  ccy, const Time  t, const Time  T  ) const

protected

Definition at line 1015 of file crossassetmodel.cpp.

                                                                                        {
    Real HlT = Hl(i).eval(*this, T);
    Real HfT = Hz(ccy).eval(*this, T);
    Real rhodl = correlation(CrossAssetModel::AssetType::IR, 0, CrossAssetModel::AssetType::CR, i, 0, 0);
    Real rhofl = correlation(CrossAssetModel::AssetType::IR, ccy, CrossAssetModel::AssetType::CR, i, 0, 0);
    Real rhoxl = correlation(CrossAssetModel::AssetType::FX, ccy - 1, CrossAssetModel::AssetType::CR, i, 0, 0);
    return 0.5 * (HlT * HlT * (zetal(i).eval(*this, T) - zetal(i).eval(*this, t)) -
                  2.0 * HlT * integral(*this, P(Hl(i), al(i), al(i)), t, T) +
                  integral(*this, P(Hl(i), Hl(i), al(i), al(i)), t, T)) +
           rhodl * (HlT * integral(*this, P(Hz(0), az(0), al(i)), t, T) -
                    integral(*this, P(Hz(0), az(0), Hl(i), al(i)), t, T)) +
           rhofl * (HfT * HlT * integral(*this, P(az(ccy), al(i)), t, T) -
                    HfT * integral(*this, P(az(ccy), Hl(i), al(i)), t, T) -
                    HlT * integral(*this, P(Hz(ccy), az(ccy), al(i)), t, T) +
                    integral(*this, P(Hz(ccy), az(ccy), Hl(i), al(i)), t, T)) -
           rhoxl * (HlT * integral(*this, P(sx(ccy - 1), al(i)), t, T) -
                    integral(*this, P(sx(ccy - 1), Hl(i), al(i)), t, T));
}

Here is the call graph for this function:

Here is the caller graph for this function:

appendToFixedParameterVector()

void appendToFixedParameterVector ( const AssetType  t, const AssetType  v, const Size  param, const Size  index, const Size  i, std::vector< bool > &  res  )

protected

Definition at line 1045 of file crossassetmodel.cpp.

                                                                                                         {
    for (Size j = 0; j < components(t); ++j) {
        for (Size k = 0; k < arguments(t, j); ++k) {
            std::vector<bool> tmp1(p_[idx(t, j)]->parameter(k)->size(), true);
            if ((param == Null<Size>() || k == param) && t == v && index == j) {
                for (Size ii = 0; ii < tmp1.size(); ++ii) {
                    if (i == Null<Size>() || i == ii) {
                        tmp1[ii] = false;
                    }
                }
            }
            res.insert(res.end(), tmp1.begin(), tmp1.end());
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

numberOfAssetTypes

constexpr Size numberOfAssetTypes = 7

staticconstexpr

Definition at line 64 of file crossassetmodel.hpp.

cache_crlgm1fS_

boost::unordered_map<cache_key, std::pair<Real, Real>, cache_hasher> cache_crlgm1fS_

mutableprotected

Definition at line 477 of file crossassetmodel.hpp.

cache_infdkI_

boost::unordered_map<cache_key, std::pair<Real, Real>, cache_hasher> cache_infdkI_

protected

Definition at line 477 of file crossassetmodel.hpp.

components_

std::vector<Size> components_

protected

Definition at line 482 of file crossassetmodel.hpp.

idx_

std::vector<std::vector<Size> > idx_

protected

Definition at line 484 of file crossassetmodel.hpp.

cIdx_

std::vector<std::vector<Size> > cIdx_

protected

Definition at line 484 of file crossassetmodel.hpp.

wIdx_

std::vector<std::vector<Size> > wIdx_

protected

Definition at line 484 of file crossassetmodel.hpp.

pIdx_

std::vector<std::vector<Size> > pIdx_

protected

Definition at line 484 of file crossassetmodel.hpp.

aIdx_

std::vector<std::vector<Size> > aIdx_

protected

Definition at line 484 of file crossassetmodel.hpp.

brownians_

std::vector<std::vector<Size> > brownians_

protected

Definition at line 484 of file crossassetmodel.hpp.

auxBrownians_

std::vector<std::vector<Size> > auxBrownians_

protected

Definition at line 484 of file crossassetmodel.hpp.

stateVariables_

std::vector<std::vector<Size> > stateVariables_

protected

Definition at line 484 of file crossassetmodel.hpp.

numArguments_

std::vector<std::vector<Size> > numArguments_

protected

Definition at line 485 of file crossassetmodel.hpp.

totalDimension_

Size totalDimension_

protected

Definition at line 487 of file crossassetmodel.hpp.

totalNumberOfBrownians_

Size totalNumberOfBrownians_

protected

Definition at line 487 of file crossassetmodel.hpp.

totalNumberOfAuxBrownians_

Size totalNumberOfAuxBrownians_

protected

Definition at line 487 of file crossassetmodel.hpp.

totalNumberOfParameters_

Size totalNumberOfParameters_

protected

Definition at line 487 of file crossassetmodel.hpp.

modelType_

std::vector<std::vector<ModelType> > modelType_

protected

Definition at line 489 of file crossassetmodel.hpp.

p_

std::vector<QuantLib::ext::shared_ptr<Parametrization> > p_

protected

Definition at line 491 of file crossassetmodel.hpp.

irModels_

std::vector<QuantLib::ext::shared_ptr<IrModel> > irModels_

protected

Definition at line 492 of file crossassetmodel.hpp.

fxModels_

std::vector<QuantLib::ext::shared_ptr<FxModel> > fxModels_

protected

Definition at line 493 of file crossassetmodel.hpp.

crcirppModel_

std::vector<QuantLib::ext::shared_ptr<CrCirpp> > crcirppModel_

protected

Definition at line 494 of file crossassetmodel.hpp.

comModels_

std::vector<QuantLib::ext::shared_ptr<CommodityModel> > comModels_

protected

Definition at line 495 of file crossassetmodel.hpp.

rho_

Matrix rho_

protected

Definition at line 496 of file crossassetmodel.hpp.

salvaging_

SalvagingAlgorithm::Type salvaging_

protected

Definition at line 497 of file crossassetmodel.hpp.

measure_

IrModel::Measure measure_

protected

Definition at line 498 of file crossassetmodel.hpp.

discretization_

Discretization discretization_

protected

Definition at line 499 of file crossassetmodel.hpp.

integrator_

QuantLib::ext::shared_ptr<Integrator> integrator_

mutableprotected

Definition at line 500 of file crossassetmodel.hpp.

stateProcess_

QuantLib::ext::shared_ptr<CrossAssetStateProcess> stateProcess_

mutableprotected

Definition at line 501 of file crossassetmodel.hpp.