Analytic cross-asset lgm equity option engine. More...

#include <qle/pricingengines/analyticxassetlgmeqoptionengine.hpp>

Inheritance diagram for AnalyticXAssetLgmEquityOptionEngine:

Collaboration diagram for AnalyticXAssetLgmEquityOptionEngine:

Public Member Functions
	AnalyticXAssetLgmEquityOptionEngine (const QuantLib::ext::shared_ptr< CrossAssetModel > &model, const Size equityIdx, const Size ccyIdx)

void	calculate () const override

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

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

const Size	eqIdx_

const Size	ccyIdx_

Detailed Description

Analytic cross-asset lgm equity option engine.

This class prices an equity option analytically using the dynamics of a CrossAssetModel. The formula is black-like, with the variance of the underlying equity being dependent upon the dynamics of related interest and FX rates within the CrossAssetModel universe. See the book "Modern Derivatives Pricing and Credit Exposure Analysis" by Lichters, Stamm and Gallagher.

Definition at line 43 of file analyticxassetlgmeqoptionengine.hpp.

Constructor & Destructor Documentation

◆ AnalyticXAssetLgmEquityOptionEngine()

AnalyticXAssetLgmEquityOptionEngine	(	const QuantLib::ext::shared_ptr< CrossAssetModel > &	model,
		const Size	equityIdx,
		const Size	ccyIdx
	)

Definition at line 28 of file analyticxassetlgmeqoptionengine.cpp.

30 : model_(model), eqIdx_(eqName), ccyIdx_(EqCcy) {}

QuantExt::AnalyticXAssetLgmEquityOptionEngine::eqIdx_

const Size eqIdx_

Definition: analyticxassetlgmeqoptionengine.hpp:57

QuantExt::AnalyticXAssetLgmEquityOptionEngine::ccyIdx_

const Size ccyIdx_

Definition: analyticxassetlgmeqoptionengine.hpp:57

QuantExt::AnalyticXAssetLgmEquityOptionEngine::model_

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

Definition: analyticxassetlgmeqoptionengine.hpp:56

Member Function Documentation

◆ calculate()

void calculate ( ) const

override

Definition at line 58 of file analyticxassetlgmeqoptionengine.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 divDiscount = model_->eqbs(eqIdx_)->equityDivYieldCurveToday()->discount(expiry);
    Real eqIrDiscount = model_->eqbs(eqIdx_)->equityIrCurveToday()->discount(expiry);
    Real cashflowsDiscount = model_->irlgm1f(ccyIdx_)->termStructure()->discount(expiry);
 
    Real eqForward = model_->eqbs(eqIdx_)->eqSpotToday()->value() * divDiscount / eqIrDiscount;
 
    results_.value = value(0.0, t, payoff, cashflowsDiscount, eqForward);
 
} // calculate()

Here is the call graph for this function:

◆ value()

Real value	(	const Time	t0,
		const Time	t,
		const QuantLib::ext::shared_ptr< StrikedTypePayoff >	payoff,
		const Real	domesticDiscount,
		const Real	eqForward
	)		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 analyticxassetlgmeqoptionengine.cpp.

                                                                            {
 
    const Size& k = eqIdx_;
    const Size& i = ccyIdx_;
 
    Real Hi_t = Hz(i).eval(*model_, t);
 
    // calculate the full variance. This is the equity analogy to eqn: 12.18 in Lichters,Stamm,Gallagher
    Real variance = 0;
    variance += (vs(k).eval(*model_, t) - vs(k).eval(*model_, t0));
 
    variance += Hi_t * Hi_t * (zetaz(i).eval(*model_, t) - zetaz(i).eval(*model_, t0));
    variance -= 2.0 * Hi_t * integral(*model_, P(Hz(i), az(i), az(i)), t0, t);
    variance += integral(*model_, P(Hz(i), Hz(i), az(i), az(i)), t0, t);
 
    variance += 2.0 * Hi_t * integral(*model_, P(rzs(i, k), ss(k), az(i)), t0, t);
    variance -= 2.0 * integral(*model_, P(Hz(i), rzs(i, k), ss(k), az(i)), t0, t);
 
    Real stdev = sqrt(variance);
    BlackCalculator black(payoff, eqForward, stdev, discount);
 
    return black.value();
}