AnalyticJyCpiCapFloorEngine Class Reference

#include <qle/pricingengines/analyticjycpicapfloorengine.hpp>

Inheritance diagram for AnalyticJyCpiCapFloorEngine:

Collaboration diagram for AnalyticJyCpiCapFloorEngine:

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

PricingEngine interface
const QuantLib::ext::shared_ptr< CrossAssetModel >	model_
QuantLib::Size	index_
void	calculate () const override

Detailed Description

Analytic Jarrow Yildrim (JY) CPI cap floor engine

Definition at line 35 of file analyticjycpicapfloorengine.hpp.

Constructor & Destructor Documentation

AnalyticJyCpiCapFloorEngine()

AnalyticJyCpiCapFloorEngine	(	const QuantLib::ext::shared_ptr< CrossAssetModel > &	model,
		QuantLib::Size	index
	)

Constructor

Parameters

model	the cross asset model to be used in the valuation.
index	the index of the inflation component to use within the cross asset model.

Definition at line 35 of file analyticjycpicapfloorengine.cpp.

    : model_(model), index_(index) {}

Member Function Documentation

calculate()

void calculate ( ) const

override

Definition at line 38 of file analyticjycpicapfloorengine.cpp.

                                                  {
 
    // If the pay date has occurred, nothing to do.
    SimpleCashFlow cf(0.0, arguments_.payDate);
    if (cf.hasOccurred()) {
        results_.value = 0.0;
        return;
    }
 
    // Discount factor to pay date will be needed below.
    Size irIdx = model_->ccyIndex(model_->infjy(index_)->currency());
    DiscountFactor df = model_->irlgm1f(irIdx)->termStructure()->discount(arguments_.payDate);
 
    QL_DEPRECATED_DISABLE_WARNING
    bool interpolate = arguments_.observationInterpolation == CPI::Linear ||
                       (arguments_.observationInterpolation == CPI::AsIndex && arguments_.index->interpolated());
    QL_DEPRECATED_ENABLE_WARNING
    // Get the time to expiry. This determines if we use the JY model or look for an inflation index fixing.
    auto zts = model_->infjy(index_)->realRate()->termStructure();
    Real t = inflationYearFraction(arguments_.index->frequency(), interpolate, zts->dayCounter(), zts->baseDate(),
                                   arguments_.fixDate);
 
    // If time to expiry is non-positive, we return the discounted value of the settled amount.
    // CPICapFloor should really have its own day counter for going from strike rate to k. We use t here.
    Real k = pow(1.0 + arguments_.strike, t);
    if (t <= 0.0) {
        auto cpiAtExpiry = arguments_.index->fixing(arguments_.fixDate);
        if (arguments_.type == Option::Call) {
            results_.value = max(cpiAtExpiry / arguments_.baseCPI - k, 0.0);
        } else {
            results_.value = max(k - cpiAtExpiry / arguments_.baseCPI, 0.0);
        }
        results_.value *= arguments_.nominal * df;
        return;
    }
 
    // Section 13, Book. ZCII Cap. Note that there is a difference between the base CPI value associated with the
    // inflation term structures and used as a starting point in the CAM evolution vs. the contractual base CPI in
    // the CPICapFloor instrument. The former is curveBaseCpi below and the latter is arguments_.baseCPI.
 
    // Calculate the variance, \Sigma^2_I in the book.
    Real H_n_t = Hz(irIdx).eval(*model_, t);
    Real H_r_t = Hy(index_).eval(*model_, t);
    Real v = integral(*model_, P(LC(H_n_t, -1.0, Hz(irIdx)), LC(H_n_t, -1.0, Hz(irIdx)), az(irIdx), az(irIdx)), 0.0, t);
    v += integral(*model_, P(LC(H_r_t, -1.0, Hy(index_)), LC(H_r_t, -1.0, Hy(index_)), ay(index_), ay(index_)), 0.0, t);
    v += integral(*model_, P(sy(index_), sy(index_)), 0.0, t);
    v -= 2 *
         integral(*model_,
                  P(rzy(irIdx, index_), LC(H_r_t, -1.0, Hy(index_)), LC(H_n_t, -1.0, Hz(irIdx)), ay(index_), az(irIdx)),
                  0.0, t);
    v += 2 * integral(*model_, P(rzy(irIdx, index_, 1), LC(H_n_t, -1.0, Hz(irIdx)), az(irIdx), sy(index_)), 0.0, t);
    v -= 2 *
         integral(*model_, P(ryy(index_, index_, 0, 1), LC(H_r_t, -1.0, Hy(index_)), ay(index_), sy(index_)), 0.0, t);
 
    // Calculate the forward CPI, F_I(0,T) in the book.
    Real fwd = arguments_.index->fixing(arguments_.fixDate);
 
    // Get adjusted nominal and strike, \tilde{N} and \tilde{K} from the book.
    Real adjNominal = arguments_.nominal / arguments_.baseCPI;
    Real adjStrike = k * arguments_.baseCPI;
 
    results_.value = adjNominal * blackFormula(arguments_.type, adjStrike, fwd, sqrt(v), df);
}

Here is the call graph for this function:

Member Data Documentation

model_

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

private

Definition at line 50 of file analyticjycpicapfloorengine.hpp.

index_

QuantLib::Size index_

private

Definition at line 51 of file analyticjycpicapfloorengine.hpp.