Cross Asset Model State Process. More...

#include <qle/processes/crossassetstateprocess.hpp>

Inheritance diagram for CrossAssetStateProcess:

Collaboration diagram for CrossAssetStateProcess:

Classes
class	ExactDiscretization

Public Member Functions
	CrossAssetStateProcess (QuantLib::ext::shared_ptr< const CrossAssetModel > model)

Size	size () const override

Size	factors () const override

Array	initialValues () const override

Array	drift (Time t, const Array &x) const override

Matrix	diffusion (Time t, const Array &x) const override

Array	evolve (Time t0, const Array &x0, Time dt, const Array &dw) const override

void	resetCache (const Size timeSteps) const

Protected Member Functions
virtual Matrix	diffusionOnCorrelatedBrownians (Time t, const Array &x) const

virtual Matrix	diffusionOnCorrelatedBrowniansImpl (Time t, const Array &x) const

void	updateSqrtCorrelation () const

Protected Attributes
QuantLib::ext::shared_ptr< const CrossAssetModel >	model_

std::vector< QuantLib::ext::shared_ptr< StochasticProcess > >	crCirpp_

Size	cirppCount_

Matrix	sqrtCorrelation_

bool	cacheNotReady_m_ = true

bool	cacheNotReady_d_ = true

Size	timeStepsToCache_m_ = 0

Size	timeStepCache_m_ = 0

Size	timeStepsToCache_d_ = 0

Size	timeStepCache_d_ = 0

std::vector< Array >	cache_m_

std::vector< Matrix >	cache_d_

Detailed Description

Cross Asset Model State Process.

Definition at line 42 of file crossassetstateprocess.hpp.

Constructor & Destructor Documentation

◆ CrossAssetStateProcess()

CrossAssetStateProcess ( QuantLib::ext::shared_ptr< const CrossAssetModel > model )

Definition at line 55 of file crossassetstateprocess.cpp.

    : StochasticProcess(), model_(std::move(model)), cirppCount_(0) {
 
    if (model_->discretization() == CrossAssetModel::Discretization::Euler) {
        discretization_ = QuantLib::ext::make_shared<EulerDiscretization>();
    } else {
        discretization_ =
            QuantLib::ext::make_shared<CrossAssetStateProcess::ExactDiscretization>(model_, model_->salvagingAlgorithm());
    }
 
    updateSqrtCorrelation();
 
    // set up CR CIR++ processes, defer the euler discretisation check to evolve()
    for (Size i = 0; i < model_->components(CrossAssetModel::AssetType::CR); ++i) {
        if (model_->modelType(CrossAssetModel::AssetType::CR, i) == CrossAssetModel::ModelType::CIRPP) {
            crCirpp_.push_back(model_->crcirppModel(i)->stateProcess());
            cirppCount_++;
        } else {
            crCirpp_.push_back(QuantLib::ext::shared_ptr<CrCirppStateProcess>());
        }
    }
}

Here is the call graph for this function:

Member Function Documentation

◆ size()

Size size ( ) const

override

StochasticProcess interface

Definition at line 78 of file crossassetstateprocess.cpp.

78{ return model_->dimension(); }

◆ factors()

Size factors ( ) const

override

Definition at line 80 of file crossassetstateprocess.cpp.

80{ return model_->brownians() + model_->auxBrownians(); }

◆ initialValues()

Array initialValues ( ) const

override

Definition at line 99 of file crossassetstateprocess.cpp.

                                                  {
    Array res(model_->dimension(), 0.0);
    /* irlgm1f / irhw processes have initial value 0 */
    for (Size i = 0; i < model_->components(CrossAssetModel::AssetType::FX); ++i) {
        /* fxbs processes are in log spot */
        res[model_->pIdx(CrossAssetModel::AssetType::FX, i, 0)] = std::log(model_->fxbs(i)->fxSpotToday()->value());
    }
    for (Size i = 0; i < model_->components(CrossAssetModel::AssetType::EQ); ++i) {
        /* eqbs processes are in log spot */
        res[model_->pIdx(CrossAssetModel::AssetType::EQ, i, 0)] = std::log(model_->eqbs(i)->eqSpotToday()->value());
    }
    // CR CIR++ components
    for (Size i = 0; i < model_->components(CrossAssetModel::AssetType::CR); ++i) {
        if (model_->modelType(CrossAssetModel::AssetType::CR, i) != CrossAssetModel::ModelType::CIRPP)
            continue;
        QL_REQUIRE(crCirpp_[i], "crcirpp is null!");
        Array r = crCirpp_[i]->initialValues();
        res[model_->pIdx(CrossAssetModel::AssetType::CR, i, 0)] = r[0]; // y0
        res[model_->pIdx(CrossAssetModel::AssetType::CR, i, 1)] = r[1]; // S(0,0) = 1
    }
 
    for (Size i = 0; i < model_->components(CrossAssetModel::AssetType::INF); ++i) {
        // Second component of JY model is the inflation index process.
        if (model_->modelType(CrossAssetModel::AssetType::INF, i) == CrossAssetModel::ModelType::JY) {
            res[model_->pIdx(CrossAssetModel::AssetType::INF, i, 1)] =
                std::log(model_->infjy(i)->index()->fxSpotToday()->value());
        }
    }
    /* infdk, crlgm1f, commodity, crstate processes have initial value 0 */
    return res;
}

◆ drift()

Array drift	(	Time	t,
		const Array &	x
	)		const

override

Definition at line 131 of file crossassetstateprocess.cpp.

                                                                {
    Array res(model_->dimension(), 0.0);
    Size n = model_->components(CrossAssetModel::AssetType::IR);
    Size n_eq = model_->components(CrossAssetModel::AssetType::EQ);
    Real H0 = model_->irlgm1f(0)->H(t);
    Real Hprime0 = model_->irlgm1f(0)->Hprime(t);
    Real alpha0 = model_->irlgm1f(0)->alpha(t);
    Real zeta0 = model_->irlgm1f(0)->zeta(t);
    if (cacheNotReady_m_) {
        /* z0 has drift 0 in the LGM measure but non-zero drift in the bank account measure, so start loop at i = 0 */
        for (Size i = 0; i < n; ++i) {
            Real Hi = model_->irlgm1f(i)->H(t);
            Real alphai = model_->irlgm1f(i)->alpha(t);
            if (i == 0 && model_->measure() == IrModel::Measure::BA) {
                // ADD z0 drift in the BA measure
                res[model_->pIdx(CrossAssetModel::AssetType::IR, i, 0)] = -Hi * alphai * alphai;
                // the auxiliary state variable is drift-free
                res[model_->pIdx(CrossAssetModel::AssetType::IR, i, 1)] = 0.0;
            }
            if (i > 0) {
                Real sigmai = model_->fxbs(i - 1)->sigma(t);
                // ir-ir
                Real rhozz0i =
                    model_->correlation(CrossAssetModel::AssetType::IR, 0, CrossAssetModel::AssetType::IR, i);
                // ir-fx
                Real rhozx0i =
                    model_->correlation(CrossAssetModel::AssetType::IR, 0, CrossAssetModel::AssetType::FX, i - 1);
                Real rhozxii =
                    model_->correlation(CrossAssetModel::AssetType::IR, i, CrossAssetModel::AssetType::FX, i - 1);
                // ir drifts
                res[model_->pIdx(CrossAssetModel::AssetType::IR, i, 0)] =
                    -Hi * alphai * alphai + H0 * alpha0 * alphai * rhozz0i - sigmai * alphai * rhozxii;
                // log spot fx drifts (z0, zi independent parts)
                res[model_->pIdx(CrossAssetModel::AssetType::FX, i - 1, 0)] =
                    H0 * alpha0 * sigmai * rhozx0i +
                    model_->irlgm1f(0)->termStructure()->forwardRate(t, t, Continuous) -
                    model_->irlgm1f(i)->termStructure()->forwardRate(t, t, Continuous) - 0.5 * sigmai * sigmai;
                if (model_->measure() == IrModel::Measure::BA) {
                    // REMOVE the LGM measure drift contributions above
                    res[model_->pIdx(CrossAssetModel::AssetType::IR, i, 0)] -= H0 * alpha0 * alphai * rhozz0i;
                    res[model_->pIdx(CrossAssetModel::AssetType::FX, i - 1, 0)] -= H0 * alpha0 * sigmai * rhozx0i;
                }
            }
        }
        /* log equity spot drifts (the cache-able parts) */
        for (Size k = 0; k < n_eq; ++k) {
            Size i = model_->ccyIndex(model_->eqbs(k)->currency());
            // ir params (for equity currency)
            Real eps_ccy = (i == 0) ? 0.0 : 1.0;
            // Real Hi = model_->irlgm1f(i)->H(t);
            // Real alphai = model_->irlgm1f(i)->alpha(t);
            // eq vol
            Real sigmask = model_->eqbs(k)->sigma(t);
            // fx vol (eq ccy / base ccy)
            Real sigmaxi = (i == 0) ? 0.0 : model_->fxbs(i - 1)->sigma(t);
            // ir-eq corr
            // Real rhozsik = model_->correlation(EQ, k, CrossAssetModel::AssetType::IR, i); // eq cur
            Real rhozs0k =
                model_->correlation(CrossAssetModel::AssetType::EQ, k, CrossAssetModel::AssetType::IR, 0); // base cur
            // fx-eq corr
            Real rhoxsik =
                (i == 0) ? 0.0 : // no fx process for base-ccy
                    model_->correlation(CrossAssetModel::AssetType::FX, i - 1, CrossAssetModel::AssetType::EQ, k);
            // ir instantaneous forward rate (from curve used for eq forward projection)
            Real fr_i = model_->eqbs(k)->equityIrCurveToday()->forwardRate(t, t, Continuous);
            // div yield instantaneous forward rate
            Real fq_k = model_->eqbs(k)->equityDivYieldCurveToday()->forwardRate(t, t, Continuous);
            res[model_->pIdx(CrossAssetModel::AssetType::EQ, k, 0)] = fr_i - fq_k + (rhozs0k * H0 * alpha0 * sigmask) -
                                                                      (eps_ccy * rhoxsik * sigmaxi * sigmask) -
                                                                      (0.5 * sigmask * sigmask);
        }
 
        // State independent pieces of JY inflation model, if there is a CAM JY component.
        for (Size j = 0; j < model_->components(CrossAssetModel::AssetType::INF); ++j) {
 
            if (model_->modelType(CrossAssetModel::AssetType::INF, j) == CrossAssetModel::ModelType::JY) {
 
                auto p = model_->infjy(j);
                Size i_j = model_->ccyIndex(p->currency());
 
                // JY inflation parameter values.
                Real H_y_j = p->realRate()->H(t);
                Real Hp_y_j = p->realRate()->Hprime(t);
                Real zeta_y_j = p->realRate()->zeta(t);
                Real alpha_y_j = p->realRate()->alpha(t);
                Real sigma_c_j = p->index()->sigma(t);
 
                // Inflation nominal currency parameter values
                Real H_i_j = model_->irlgm1f(i_j)->H(t);
                Real Hp_i_j = model_->irlgm1f(i_j)->Hprime(t);
                Real zeta_i_j = model_->irlgm1f(i_j)->zeta(t);
 
                // Correlations
                Real rho_zy_0j =
                    model_->correlation(CrossAssetModel::AssetType::IR, 0, CrossAssetModel::AssetType::INF, j, 0, 0);
                Real rho_yc_ij =
                    model_->correlation(CrossAssetModel::AssetType::INF, j, CrossAssetModel::AssetType::INF, j, 0, 1);
                Real rho_zc_0j =
                    model_->correlation(CrossAssetModel::AssetType::IR, 0, CrossAssetModel::AssetType::INF, j, 0, 1);
 
                // JY real rate drift. It is state independent
                auto rrDrift = -alpha_y_j * alpha_y_j * H_y_j + rho_zy_0j * alpha0 * alpha_y_j * H_y_j -
                               rho_yc_ij * alpha_y_j * sigma_c_j;
 
                if (i_j > 0) {
                    Real sigma_x_i_j = model_->fxbs(i_j - 1)->sigma(t);
                    Real rho_yx_j_i_j = model_->correlation(CrossAssetModel::AssetType::INF, j,
                                                            CrossAssetModel::AssetType::FX, i_j - 1, 0, 0);
                    rrDrift -= rho_yx_j_i_j * alpha_y_j * sigma_x_i_j;
                }
 
                res[model_->pIdx(CrossAssetModel::AssetType::INF, j, 0)] = rrDrift;
 
                // JY log inflation index drift (state independent piece).
                auto indexDrift = rho_zc_0j * alpha0 * sigma_c_j * H0 - 0.5 * sigma_c_j * sigma_c_j +
                                  zeta_i_j * Hp_i_j * H_i_j - zeta_y_j * Hp_y_j * H_y_j;
 
                // Add on the f_n(0, t) - f_r(0, t) piece using the initial zero inflation term structure.
                // Use the same dt below that is used in yield forward rate calculations.
                auto ts = p->realRate()->termStructure();
                Time dt = 0.0001;
                Time t1 = std::max(t - dt / 2.0, 0.0);
                Time t2 = t1 + dt;
                auto z_t = ts->zeroRate(t);
                auto z_t1 = ts->zeroRate(t1);
                auto z_t2 = ts->zeroRate(t2);
                indexDrift += std::log(1 + z_t) + (t / (1 + z_t)) * ((z_t2 - z_t1) / dt);
 
                if (i_j > 0) {
                    Real sigma_x_i_j = model_->fxbs(i_j - 1)->sigma(t);
                    Real rho_cx_j_i_j = model_->correlation(CrossAssetModel::AssetType::INF, j,
                                                            CrossAssetModel::AssetType::FX, i_j - 1, 1, 0);
                    indexDrift -= rho_cx_j_i_j * sigma_c_j * sigma_x_i_j;
                }
 
                res[model_->pIdx(CrossAssetModel::AssetType::INF, j, 1)] = indexDrift;
            }
        }
 
        if (timeStepsToCache_m_ > 0) {
            cache_m_.push_back(res);
            if (cache_m_.size() == timeStepsToCache_m_)
                cacheNotReady_m_ = false;
        }
    } else {
        res = cache_m_[timeStepCache_m_++];
        if (timeStepCache_m_ == timeStepsToCache_m_)
            timeStepCache_m_ = 0;
    }
    // non-cacheable sections of drifts
    for (Size i = 1; i < n; ++i) {
        // log spot fx drifts (z0, zi dependent parts)
        Real Hi = model_->irlgm1f(i)->H(t);
        Real Hprimei = model_->irlgm1f(i)->Hprime(t);
        Real zetai = model_->irlgm1f(i)->zeta(t);
        res[model_->pIdx(CrossAssetModel::AssetType::FX, i - 1, 0)] +=
            x[model_->pIdx(CrossAssetModel::AssetType::IR, 0, 0)] * Hprime0 + zeta0 * Hprime0 * H0 -
            x[model_->pIdx(CrossAssetModel::AssetType::IR, i, 0)] * Hprimei - zetai * Hprimei * Hi;
    }
    for (Size k = 0; k < n_eq; ++k) {
        // log equity spot drifts (path-dependent parts)
        // notice the assumption in below that dividend yield curve is static
        Size i = model_->ccyIndex(model_->eqbs(k)->currency());
        // ir params (for equity currency)
        Real Hi = model_->irlgm1f(i)->H(t);
        Real Hprimei = model_->irlgm1f(i)->Hprime(t);
        Real zetai = model_->irlgm1f(i)->zeta(t);
        res[model_->pIdx(CrossAssetModel::AssetType::EQ, k, 0)] +=
            (x[model_->pIdx(CrossAssetModel::AssetType::IR, i, 0)] * Hprimei) + (zetai * Hprimei * Hi);
    }
 
    // Non-cacheable portion of inflation JY drift, if there is a CAM JY component.
    for (Size j = 0; j < model_->components(CrossAssetModel::AssetType::INF); ++j) {
        if (model_->modelType(CrossAssetModel::AssetType::INF, j) == CrossAssetModel::ModelType::JY) {
 
            auto p = model_->infjy(j);
            Size i_j = model_->ccyIndex(p->currency());
 
            // JY inflation parameter values.
            Real Hp_y_j = p->realRate()->Hprime(t);
 
            // Inflation nominal currency parameter values
            Real Hp_i_j = model_->irlgm1f(i_j)->Hprime(t);
 
            res[model_->pIdx(CrossAssetModel::AssetType::INF, j, 1)] +=
                x[model_->pIdx(CrossAssetModel::AssetType::IR, i_j, 0)] * Hp_i_j -
                x[model_->pIdx(CrossAssetModel::AssetType::INF, j, 0)] * Hp_y_j;
        }
    }
 
    // COM drift
    Size n_com = model_->components(CrossAssetModel::AssetType::COM);
    for (Size k = 0; k < n_com; ++k) {
        auto cm = QuantLib::ext::dynamic_pointer_cast<CommoditySchwartzModel>(model_->comModel(k));
        QL_REQUIRE(cm, "CommoditySchwartzModel not set");
        if (!cm->parametrization()->driftFreeState()) {
            // Ornstein-Uhlenbeck drift
            Real kap = cm->parametrization()->kappaParameter();
            res[model_->pIdx(CrossAssetModel::AssetType::COM, k, 0)] -=
                kap * x[model_->pIdx(CrossAssetModel::AssetType::COM, k, 0)];
        } else {
            // zero drift
        }
    }
 
    /* no drift for infdk, crlgm1f, crstate components */
    return res;
}

◆ diffusion()

Matrix diffusion	(	Time	t,
		const Array &	x
	)		const

override

Definition at line 340 of file crossassetstateprocess.cpp.

                                                                     {
    return diffusionOnCorrelatedBrownians(t, x) * sqrtCorrelation_;
}

Here is the call graph for this function:

◆ evolve()

Array evolve	(	Time	t0,
		const Array &	x0,
		Time	dt,
		const Array &	dw
	)		const

override

Definition at line 472 of file crossassetstateprocess.cpp.

                                                                                             {
 
    Array res;
 
    // handle HW based model
 
    if (model_->modelType(CrossAssetModel::AssetType::IR, 0) == CrossAssetModel::ModelType::HW) {
 
        QL_REQUIRE(model_->discretization() == CrossAssetModel::Discretization::Euler,
                   "CrossAssetStateProcess::evolve(): hw-based model only supports Euler discretization.");
 
        const Array dz = sqrtCorrelation_ * dw;
 
        res = Array(model_->dimension());
 
        // eolve ir processes and store current short rates which are needed to evolve the fx components below
 
        Array shortRates(model_->components(CrossAssetModel::AssetType::IR));
        for (Size i = 0; i < model_->components(CrossAssetModel::AssetType::IR); ++i) {
            auto p = model_->irModel(i)->stateProcess();
            auto r = p->evolve(t0,
                               getProjectedArray(x0, model_->pIdx(CrossAssetModel::AssetType::IR, i, 0),
                                                 model_->irModel(i)->n() + model_->irModel(i)->n_aux()),
                               dt,
                               getProjectedArray(dz, model_->wIdx(CrossAssetModel::AssetType::IR, i, 0),
                                                 model_->irModel(i)->m() + model_->irModel(i)->m_aux()));
            std::copy(r.begin(), r.end(), std::next(res.begin(), model_->pIdx(CrossAssetModel::AssetType::IR, i, 0)));
            shortRates[i] = model_->irModel(i)->shortRate(
                t0, getProjectedArray(x0, model_->pIdx(CrossAssetModel::AssetType::IR, i, 0), model_->irModel(i)->n()));
        }
 
        // apply drift adjustment to ir processes in non-domestic currency
 
        for (Size i = 1; i < model_->components(CrossAssetModel::AssetType::IR); ++i) {
            applyFxDriftAdjustment(res, model_, i, t0, dt);
        }
 
        // eolve fx processes
 
        for (Size i = 0; i < model_->components(CrossAssetModel::AssetType::FX); ++i) {
            auto r = model_->fxModel(i)->eulerStep(
                t0, getProjectedArray(x0, model_->pIdx(CrossAssetModel::AssetType::FX, i, 0), model_->fxModel(i)->n()),
                dt, getProjectedArray(dz, model_->wIdx(CrossAssetModel::AssetType::FX, i, 0), model_->fxModel(i)->m()),
                shortRates[0], shortRates[i + 1]);
            std::copy(r.begin(), r.end(), std::next(res.begin(), model_->pIdx(CrossAssetModel::AssetType::FX, i, 0)));
        }
 
        // evolve com processes
 
        for (Size i = 0; i < model_->components(CrossAssetModel::AssetType::COM); ++i) {
            auto p = model_->comModel(i)->stateProcess();
            auto r = p->evolve(
                t0,
                getProjectedArray(x0, model_->pIdx(CrossAssetModel::AssetType::COM, i, 0), model_->comModel(i)->n()),
                dt,
                getProjectedArray(dz, model_->wIdx(CrossAssetModel::AssetType::COM, i, 0), model_->comModel(i)->m()));
            std::copy(r.begin(), r.end(), std::next(res.begin(), model_->pIdx(CrossAssetModel::AssetType::COM, i, 0)));
        }
 
        // TODO other components ...
        QL_REQUIRE(model_->components(CrossAssetModel::AssetType::IR) +
                           model_->components(CrossAssetModel::AssetType::FX) +
                           model_->components(CrossAssetModel::AssetType::COM) ==
                       model_->parametrizations().size(),
                   "CrossAssetStateProcess::evolve(): currently only IR, FX, COM supported.");
 
        return res;
    }
 
    // handle LGM1F based model
 
    if (model_->discretization() == CrossAssetModel::Discretization::Euler) {
        const Array dz = sqrtCorrelation_ * dw;
        const Matrix df = diffusionOnCorrelatedBrownians(t0, x0);
        res = apply(expectation(t0, x0, dt), df * dz * std::sqrt(dt));
 
        // CR CIRPP components
        if (cirppCount_ > 0) {
            for (Size i = 0; i < model_->components(CrossAssetModel::AssetType::CR); ++i) {
                if (!crCirpp_[i])
                    continue; // ignore non-cir cr model
                Size idx1 = model_->pIdx(CrossAssetModel::AssetType::CR, i, 0);
                Size idx2 = model_->pIdx(CrossAssetModel::AssetType::CR, i, 1);
                Size idxw = model_->wIdx(CrossAssetModel::AssetType::CR, i, 0);
                Array x0Tmp(2), dwTmp(2);
                x0Tmp[0] = x0[idx1];
                x0Tmp[1] = x0[idx2];
                dwTmp[0] = dz[idxw];
                dwTmp[1] = 0.0; // not used
                // evolve original process
                auto r = crCirpp_[i]->evolve(t0, x0Tmp, dt, dwTmp);
 
                // set result
                res[idx1] = r[0]; // y
                res[idx2] = r[1]; // S(0,T)
            }
        }
    } else {
        QL_REQUIRE(cirppCount_ == 0, "only euler discretization is supported for CIR++");
        res = StochasticProcess::evolve(t0, x0, dt, dw);
    }
 
    return res;
}

Here is the call graph for this function:

◆ resetCache()

void resetCache ( const Size timeSteps ) const

Definition at line 82 of file crossassetstateprocess.cpp.

                                                                  {
    cacheNotReady_m_ = cacheNotReady_d_ = true;
    timeStepsToCache_m_ = timeStepsToCache_d_ = timeSteps;
    timeStepCache_m_ = timeStepCache_d_ = 0;
    cache_m_.clear();
    cache_d_.clear();
    if (auto tmp = QuantLib::ext::dynamic_pointer_cast<CrossAssetStateProcess::ExactDiscretization>(discretization_))
        tmp->resetCache(timeSteps);
    updateSqrtCorrelation();
}

Here is the call graph for this function:

◆ diffusionOnCorrelatedBrownians()

Matrix diffusionOnCorrelatedBrownians	(	Time	t,
		const Array &	x
	)		const

protectedvirtual

Definition at line 344 of file crossassetstateprocess.cpp.

                                                                                          {
    if (cacheNotReady_d_) {
        Matrix tmp = diffusionOnCorrelatedBrowniansImpl(t, x);
        if (timeStepsToCache_d_ > 0) {
            cache_d_.push_back(tmp);
            if (cache_d_.size() == timeStepsToCache_d_)
                cacheNotReady_d_ = false;
        }
        return tmp;
    } else {
        Matrix tmp = cache_d_[timeStepCache_d_++];
        if (timeStepCache_d_ == timeStepsToCache_d_)
            timeStepCache_d_ = 0;
        return tmp;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ diffusionOnCorrelatedBrowniansImpl()

Matrix diffusionOnCorrelatedBrowniansImpl	(	Time	t,
		const Array &	x
	)		const

protectedvirtual

Definition at line 361 of file crossassetstateprocess.cpp.

                                                                                            {
    Matrix res(model_->dimension(), model_->brownians(), 0.0);
    Size n = model_->components(CrossAssetModel::AssetType::IR);
    Size m = model_->components(CrossAssetModel::AssetType::FX);
    Size d = model_->components(CrossAssetModel::AssetType::INF);
    Size c = model_->components(CrossAssetModel::AssetType::CR);
    Size e = model_->components(CrossAssetModel::AssetType::EQ);
    Size com = model_->components(CrossAssetModel::AssetType::COM);
    Size crstates = model_->components(CrossAssetModel::AssetType::CrState);
    // ir-ir
    for (Size i = 0; i < n; ++i) {
        Real alphai = model_->irlgm1f(i)->alpha(t);
        setValue2(res, alphai, model_, CrossAssetModel::AssetType::IR, i, CrossAssetModel::AssetType::IR, i, 0, 0);
    }
    // fx-fx
    for (Size i = 0; i < m; ++i) {
        Real sigmai = model_->fxbs(i)->sigma(t);
        setValue2(res, sigmai, model_, CrossAssetModel::AssetType::FX, i, CrossAssetModel::AssetType::FX, i, 0, 0);
    }
    // inf-inf
    for (Size i = 0; i < d; ++i) {
        if (model_->modelType(CrossAssetModel::AssetType::INF, i) == CrossAssetModel::ModelType::DK) {
            Real alphai = model_->infdk(i)->alpha(t);
            Real Hi = model_->infdk(i)->H(t);
            // DK z diffusion coefficient
            setValue2(res, alphai, model_, CrossAssetModel::AssetType::INF, i, CrossAssetModel::AssetType::INF, i, 0,
                      0);
            // DK y diffusion coefficient
            setValue2(res, alphai * Hi, model_, CrossAssetModel::AssetType::INF, i, CrossAssetModel::AssetType::INF, i,
                      1, 0);
        } else {
            auto p = model_->infjy(i);
            // JY z diffusion coefficient
            setValue2(res, p->realRate()->alpha(t), model_, CrossAssetModel::AssetType::INF, i,
                      CrossAssetModel::AssetType::INF, i, 0, 0);
            // JY I diffusion coefficient
            setValue2(res, p->index()->sigma(t), model_, CrossAssetModel::AssetType::INF, i,
                      CrossAssetModel::AssetType::INF, i, 1, 1);
        }
    }
    for (Size i = 0; i < c; ++i) {
        // Skip CR components that are not LGM
        if (model_->modelType(CrossAssetModel::AssetType::CR, i) != CrossAssetModel::ModelType::LGM1F)
            continue;
        Real alphai = model_->crlgm1f(i)->alpha(t);
        Real Hi = model_->crlgm1f(i)->H(t);
        // crz-crz
        setValue2(res, alphai, model_, CrossAssetModel::AssetType::CR, i, CrossAssetModel::AssetType::CR, i, 0, 0);
        // cry-cry
        setValue2(res, alphai * Hi, model_, CrossAssetModel::AssetType::CR, i, CrossAssetModel::AssetType::CR, i, 1, 0);
    }
    // eq-eq
    for (Size i = 0; i < e; ++i) {
        Real sigmai = model_->eqbs(i)->sigma(t);
        setValue2(res, sigmai, model_, CrossAssetModel::AssetType::EQ, i, CrossAssetModel::AssetType::EQ, i, 0, 0);
    }
    // com-com
    for (Size i = 0; i < com; ++i) {
        Real sigmai = model_->combs(i)->sigma(t);
        setValue2(res, sigmai, model_, CrossAssetModel::AssetType::COM, i, CrossAssetModel::AssetType::COM, i, 0, 0);
    }
    // creditstate-creditstate
    for (Size i = 0; i < crstates; ++i) {
        setValue2(res, 1.0, model_, CrossAssetModel::AssetType::CrState, i, CrossAssetModel::AssetType::CrState, i, 0,
                  0);
    }
 
    if (model_->measure() == IrModel::Measure::BA) {
        // aux-aux
        Real H0 = model_->irlgm1f(0)->H(t);
        Real alpha0 = model_->irlgm1f(0)->alpha(t);
        setValue2(res, alpha0 * H0, model_, CrossAssetModel::AssetType::IR, 0, CrossAssetModel::AssetType::IR, 0, 1, 0);
    }
 
    return res;
}

Here is the caller graph for this function:

◆ updateSqrtCorrelation()

void updateSqrtCorrelation ( ) const

protected

Definition at line 93 of file crossassetstateprocess.cpp.

                                                         {
    if (model_->discretization() != CrossAssetModel::Discretization::Euler)
        return;
    sqrtCorrelation_ = pseudoSqrt(model_->correlation(), model_->salvagingAlgorithm());
}

Here is the caller graph for this function:

Member Data Documentation

◆ model_

QuantLib::ext::shared_ptr<const CrossAssetModel> model_

protected

Definition at line 62 of file crossassetstateprocess.hpp.

◆ crCirpp_

std::vector<QuantLib::ext::shared_ptr<StochasticProcess> > crCirpp_

protected

Definition at line 64 of file crossassetstateprocess.hpp.

◆ cirppCount_

Size cirppCount_

protected

Definition at line 65 of file crossassetstateprocess.hpp.

◆ sqrtCorrelation_

Matrix sqrtCorrelation_

mutableprotected

Definition at line 67 of file crossassetstateprocess.hpp.

◆ cacheNotReady_m_

bool cacheNotReady_m_ = true

mutableprotected

Definition at line 99 of file crossassetstateprocess.hpp.

◆ cacheNotReady_d_

bool cacheNotReady_d_ = true

mutableprotected

Definition at line 100 of file crossassetstateprocess.hpp.

◆ timeStepsToCache_m_

Size timeStepsToCache_m_ = 0

mutableprotected

Definition at line 101 of file crossassetstateprocess.hpp.

◆ timeStepCache_m_

Size timeStepCache_m_ = 0

mutableprotected

Definition at line 102 of file crossassetstateprocess.hpp.

◆ timeStepsToCache_d_

Size timeStepsToCache_d_ = 0

mutableprotected

Definition at line 103 of file crossassetstateprocess.hpp.

◆ timeStepCache_d_

Size timeStepCache_d_ = 0

mutableprotected

Definition at line 104 of file crossassetstateprocess.hpp.

◆ cache_m_

std::vector<Array> cache_m_

mutableprotected

Definition at line 105 of file crossassetstateprocess.hpp.

◆ cache_d_

std::vector<Matrix> cache_d_

mutableprotected

Definition at line 106 of file crossassetstateprocess.hpp.

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CrossAssetStateProcess()

Member Function Documentation

◆ size()

◆ factors()

◆ initialValues()

◆ drift()

◆ diffusion()

◆ evolve()

◆ resetCache()

◆ diffusionOnCorrelatedBrownians()

◆ diffusionOnCorrelatedBrowniansImpl()

◆ updateSqrtCorrelation()

Member Data Documentation

◆ model_

◆ crCirpp_

◆ cirppCount_

◆ sqrtCorrelation_

◆ cacheNotReady_m_

◆ cacheNotReady_d_

◆ timeStepsToCache_m_

◆ timeStepCache_m_

◆ timeStepsToCache_d_

◆ timeStepCache_d_

◆ cache_m_

◆ cache_d_