Analytic cc lgm fx option engine. More...

#include <qle/pricingengines/analyticcclgmfxoptionengine.hpp>

Inheritance diagram for AnalyticCcLgmFxOptionEngine:

Collaboration diagram for AnalyticCcLgmFxOptionEngine:

Public Member Functions
	AnalyticCcLgmFxOptionEngine (const QuantLib::ext::shared_ptr< CrossAssetModel > &model, const Size foreignCurrency)

void	calculate () const override

void	cache (bool enable=true)

Real	value (const Time t0, const Time t, const QuantLib::ext::shared_ptr< StrikedTypePayoff > payoff, const Real domesticDiscount, const Real fxForward) const

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

const Size	foreignCurrency_

bool	cacheEnabled_

bool	cacheDirty_

Real	cachedIntegrals_

Real	cachedT0_

Real	cachedT_

Detailed Description

Analytic cc lgm fx option engine.

Definition at line 36 of file analyticcclgmfxoptionengine.hpp.

Constructor & Destructor Documentation

◆ AnalyticCcLgmFxOptionEngine()

AnalyticCcLgmFxOptionEngine	(	const QuantLib::ext::shared_ptr< CrossAssetModel > &	model,
		const Size	foreignCurrency
	)

Definition at line 28 of file analyticcclgmfxoptionengine.cpp.

30 : model_(model), foreignCurrency_(foreignCurrency), cacheEnabled_(false), cacheDirty_(true) {}

QuantExt::AnalyticCcLgmFxOptionEngine::cacheDirty_

bool cacheDirty_

Definition: analyticcclgmfxoptionengine.hpp:57

QuantExt::AnalyticCcLgmFxOptionEngine::model_

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

Definition: analyticcclgmfxoptionengine.hpp:54

QuantExt::AnalyticCcLgmFxOptionEngine::foreignCurrency_

const Size foreignCurrency_

Definition: analyticcclgmfxoptionengine.hpp:55

QuantExt::AnalyticCcLgmFxOptionEngine::cacheEnabled_

bool cacheEnabled_

Definition: analyticcclgmfxoptionengine.hpp:56

Member Function Documentation

◆ calculate()

void calculate ( ) const

override

Definition at line 75 of file analyticcclgmfxoptionengine.cpp.

                                                  {
 
    QL_REQUIRE(arguments_.exercise->type() == Exercise::European, "only European options are allowed");
 
    QuantLib::ext::shared_ptr<StrikedTypePayoff> payoff = QuantLib::ext::dynamic_pointer_cast<StrikedTypePayoff>(arguments_.payoff);
    QL_REQUIRE(payoff != NULL, "only striked payoff is allowed");
 
    Date expiry = arguments_.exercise->lastDate();
    Time t = model_->irlgm1f(0)->termStructure()->timeFromReference(expiry);
 
    if (t <= 0.0) {
        // option is expired, we do not value any possibly non settled
        // flows, i.e. set the npv to zero in this case
        results_.value = 0.0;
        return;
    }
 
    Real foreignDiscount = model_->irlgm1f(foreignCurrency_ + 1)->termStructure()->discount(expiry);
    Real domesticDiscount = model_->irlgm1f(0)->termStructure()->discount(expiry);
 
    Real fxForward = model_->fxbs(foreignCurrency_)->fxSpotToday()->value() * foreignDiscount / domesticDiscount;
 
    results_.value = value(0.0, t, payoff, domesticDiscount, fxForward);
 
} // calculate()

Here is the call graph for this function:

◆ cache()

void cache ( bool enable = true )

if cache is enabled, the integrals independent of fx volatility are cached, which can speed up calibration; remember to flush the cache when the ir parameters change, this can be done by another call to cache

Definition at line 63 of file analyticcclgmfxoptionengine.hpp.

                                                          {
    cacheEnabled_ = enable;
    cacheDirty_ = true;
}

◆ value()

Real value	(	const Time	t0,
		const Time	t,
		const QuantLib::ext::shared_ptr< StrikedTypePayoff >	payoff,
		const Real	domesticDiscount,
		const Real	fxForward
	)		const

the actual option price calculation, exposed to public, since it is useful to directly use the core computation sometimes

Definition at line 32 of file analyticcclgmfxoptionengine.cpp.

                                                                                                 {
    Real H0 = Hz(0).eval(*model_, t);
    Real Hi = Hz(foreignCurrency_ + 1).eval(*model_, t);
 
    // just a shortcut
    const Size& i = foreignCurrency_;
 
    if (cacheDirty_ || !cacheEnabled_ || !(close_enough(cachedT0_, t0) && close_enough(cachedT_, t))) {
        cachedIntegrals_ =
            // first term
            H0 * H0 * (zetaz(0).eval(*model_, t) - zetaz(0).eval(*model_, t0)) -
            2.0 * H0 * integral(*model_, P(Hz(0), az(0), az(0)), t0, t) +
            integral(*model_, P(Hz(0), Hz(0), az(0), az(0)), t0, t) +
            // second term
            Hi * Hi * (zetaz(i + 1).eval(*model_, t) - zetaz(i + 1).eval(*model_, t0)) -
            2.0 * Hi * integral(*model_, P(Hz(i + 1), az(i + 1), az(i + 1)), t0, t) +
            integral(*model_, P(Hz(i + 1), Hz(i + 1), az(i + 1), az(i + 1)), t0, t) -
            // third term
            2.0 * (H0 * Hi * integral(*model_, P(az(0), az(i + 1), rzz(0, i + 1)), t0, t) -
                   H0 * integral(*model_, P(Hz(i + 1), az(i + 1), az(0), rzz(i + 1, 0)), t0, t) -
                   Hi * integral(*model_, P(Hz(0), az(0), az(i + 1), rzz(0, i + 1)), t0, t) +
                   integral(*model_, P(Hz(0), Hz(i + 1), az(0), az(i + 1), rzz(0, i + 1)), t0, t));
        cacheDirty_ = false;
        cachedT0_ = t0;
        cachedT_ = t;
    }
 
    Real variance = cachedIntegrals_ +
                    // term two three/fourth
                    (vx(i).eval(*model_, t) - vx(i).eval(*model_, t0)) +
                    // forth term
                    2.0 * (H0 * integral(*model_, P(az(0), sx(i), rzx(0, i)), t0, t) -
                           integral(*model_, P(Hz(0), az(0), sx(i), rzx(0, i)), t0, t)) -
                    // fifth term
                    2.0 * (Hi * integral(*model_, P(az(i + 1), sx(i), rzx(i + 1, i)), t0, t) -
                           integral(*model_, P(Hz(i + 1), az(i + 1), sx(i), rzx(i + 1, i)), t0, t));
 
    BlackCalculator black(payoff, fxForward, std::sqrt(variance), domesticDiscount);
 
    return black.value();
}