JyImpliedYoYInflationTermStructure Class Reference

#include <qle/models/jyimpliedyoyinflationtermstructure.hpp>

Inheritance diagram for JyImpliedYoYInflationTermStructure:

Collaboration diagram for JyImpliedYoYInflationTermStructure:

Public Member Functions
	JyImpliedYoYInflationTermStructure (const QuantLib::ext::shared_ptr< CrossAssetModel > &model, QuantLib::Size index, bool indexIsInterpolated)
Public Member Functions inherited from YoYInflationModelTermStructure
	YoYInflationModelTermStructure (const QuantLib::ext::shared_ptr< CrossAssetModel > &model, QuantLib::Size index, bool indexIsInterpolated)
void	update () override
QuantLib::Date	maxDate () const override
QuantLib::Time	maxTime () const override
const QuantLib::Date &	referenceDate () const override
QuantLib::Date	baseDate () const override
virtual void	referenceDate (const QuantLib::Date &d)
	Set the reference date. More...
void	state (const QuantLib::Array &s)
	Set the current state variables. More...
void	move (const QuantLib::Date &d, const QuantLib::Array &s)
	Set the current state and move the reference date to date d. More...
QuantLib::Real	yoyRate (const QuantLib::Date &d, const QuantLib::Period &obsLag=-1 *QuantLib::Days, bool forceLinearInterpolation=false, bool extrapolate=false) const

YoYInflationModelTermStructure interface
std::map< QuantLib::Date, QuantLib::Real >	yoyRates (const std::vector< QuantLib::Date > &dates, const QuantLib::Period &obsLag=-1 *QuantLib::Days) const override
QuantLib::Real	yoySwaplet (QuantLib::Time S, QuantLib::Time T) const
	Year on year swaplet price for the period from S to T. More...
void	checkState () const override

Additional Inherited Members
Protected Member Functions inherited from YoYInflationModelTermStructure
QuantLib::Real	yoyRateImpl (QuantLib::Time t) const override
	This cannot be called. The implementation is set to throw an exception. More...
Protected Attributes inherited from YoYInflationModelTermStructure
QuantLib::ext::shared_ptr< CrossAssetModel >	model_
QuantLib::Size	index_
bool	indexIsInterpolated_
QuantLib::Date	referenceDate_
QuantLib::Time	relativeTime_
QuantLib::Array	state_

Detailed Description

Jarrow Yildrim (JY) implied year on year inflation term structure

Definition at line 35 of file jyimpliedyoyinflationtermstructure.hpp.

Constructor & Destructor Documentation

JyImpliedYoYInflationTermStructure()

JyImpliedYoYInflationTermStructure	(	const QuantLib::ext::shared_ptr< CrossAssetModel > &	model,
		QuantLib::Size	index,
		bool	indexIsInterpolated
	)

Constructor taking the cross asset model, model, and the index of the relevant inflation component within the model, index.

Definition at line 45 of file jyimpliedyoyinflationtermstructure.cpp.

    : YoYInflationModelTermStructure(model, index, indexIsInterpolated) {}

Member Function Documentation

yoyRates()

map< Date, Real > yoyRates ( const std::vector< QuantLib::Date > &  dates, const QuantLib::Period &  obsLag = -1 *QuantLib::Days  ) const

overridevirtual

Return the year-on-year rates for the maturities associated with dates. If an obsLag is explicitly provided and not set to -1 * QuantLib::Days, it is used as the observation lag. Otherwise, the term structure's observation lag is used.

Implements YoYInflationModelTermStructure.

Definition at line 49 of file jyimpliedyoyinflationtermstructure.cpp.

                                                                                                                {
 
    // First step is to calculate the YoY swap rate for each maturity date in dts and store in yyiisRates.
    map<Date, Real> yoySwaplets;
    map<Date, Real> discounts;
    map<Date, Real> yyiisRates;
    auto irIdx = model_->ccyIndex(model_->infjy(index_)->currency());
 
    // Will need a YoY index below in the helpers.
    QuantLib::ext::shared_ptr<YoYInflationIndex> index =
        QuantLib::ext::make_shared<YoYInflationIndexWrapper>(model_->infjy(index_)->inflationIndex(), indexIsInterpolated());
 
    for (const auto& maturity : dts) {
 
        // Schedule for the YoY swap with maturity date equal to `maturity`
        Schedule schedule = MakeSchedule()
                                .from(referenceDate_)
                                .to(maturity)
                                .withTenor(1 * Years)
                                .withConvention(Unadjusted)
                                .withCalendar(calendar())
                                .backwards();
 
        // Store the value of the model implied YoY leg and the value of the fixed leg annuity.
        Real yoyLegValue = 0.0;
        Real fixedLegAnnuity = 0.0;
 
        for (Size i = 1; i < schedule.dates().size(); ++i) {
 
            // Start and end of the current YoY swaplet period.
            const auto& start = schedule.dates()[i - 1];
            const auto& end = schedule.dates()[i];
 
            // If we have already calculated the YoY swaplet price for this period, use it.
            // We should always have a discount factor in this case also.
            auto it = yoySwaplets.find(end);
            if (it != yoySwaplets.end()) {
                yoyLegValue += it->second;
                fixedLegAnnuity += discounts.at(end);
                continue;
            }
 
            // Need to calculate the YoY swaplet value over the period [start, end]
            Real swaplet;
            auto T = relativeTime_ + dayCounter().yearFraction(referenceDate_, end);
            auto discount = model_->discountBond(irIdx, relativeTime_, T, state_[2]);
            if (i == 1) {
                // The first YoY swaplet is a zero coupon swaplet because I_{start} is known.
                auto growth =
                    inflationGrowth(model_, index_, relativeTime_, T, state_[2], state_[0], indexIsInterpolated_);
                swaplet = discount * (growth - 1.0);
            } else {
                auto S = relativeTime_ + dayCounter().yearFraction(referenceDate_, start);
                swaplet = yoySwaplet(S, T);
            }
 
            // Cache the swaplet value and the discount factor related to this swaplet end date.
            yoySwaplets[end] = swaplet;
            discounts[end] = discount;
 
            // Update the YoY leg value and the fixed leg annuity
            yoyLegValue += swaplet;
            fixedLegAnnuity += discount;
        }
 
        // The model implied YoY inflation swap rate
        yyiisRates[maturity] = yoyLegValue / fixedLegAnnuity;
    }
 
    QL_REQUIRE(!yyiisRates.empty(), "JyImpliedYoYInflationTermStructure: yoyRates did not create any YoY swap rates.");
 
    // Will need a discount term structure in the bootstrap below so create it here from the discounts map.
    vector<Date> dfDates;
    vector<Real> dfValues;
 
    if (discounts.count(referenceDate_) == 0) {
        dfDates.push_back(referenceDate_);
        dfValues.push_back(1.0);
    }
 
    for (const auto& kv : discounts) {
        dfDates.push_back(kv.first);
        dfValues.push_back(kv.second);
    }
 
    auto irTs = model_->irlgm1f(irIdx)->termStructure();
    Handle<YieldTermStructure> yts(
        QuantLib::ext::make_shared<InterpolatedDiscountCurve<LogLinear>>(dfDates, dfValues, irTs->dayCounter(), LogLinear()));
 
    // Create the YoY swap helpers from the YoY swap rates calculated above.
    // Using the curve's day counter as the helper's day counter for now.
    using YoYHelper = BootstrapHelper<YoYInflationTermStructure>;
    vector<QuantLib::ext::shared_ptr<YoYHelper>> helpers;
    for (const auto& kv : yyiisRates) {
        Handle<Quote> yyiisQuote(QuantLib::ext::make_shared<SimpleQuote>(kv.second));
        helpers.push_back(QuantLib::ext::make_shared<YearOnYearInflationSwapHelper>(
            yyiisQuote, observationLag(), kv.first, calendar(), Unadjusted, dayCounter(), index, yts));
    }
 
    // Create a YoY curve from the helpers
    // Use Linear here in line with what is in scenariosimmarket and todaysmarket but should probably be more generic.
    auto lag = obsLag == -1 * Days ? observationLag() : obsLag;
    auto baseRate = helpers.front()->quote()->value();
    auto yoyCurve = QuantLib::ext::make_shared<PiecewiseYoYInflationCurve<Linear>>(
        referenceDate_, calendar(), dayCounter(), lag, frequency(), indexIsInterpolated(), baseRate, helpers, 1e-12);
 
    // Read the necessary YoY rates from the bootstrapped YoY inflation curve
    map<Date, Real> result;
    for (const auto& maturity : dts) {
        result[maturity] = yoyCurve->yoyRate(maturity);
    }
 
    return result;
}

Here is the call graph for this function:

yoySwaplet()

Real yoySwaplet ( QuantLib::Time  S, QuantLib::Time  T  ) const

protected

Year on year swaplet price for the period from S to T.

Definition at line 164 of file jyimpliedyoyinflationtermstructure.cpp.

                                                                        {
 
    // The JY implied swap rate at time t for the period from S to T is:
    // N \tau(S, T) \left\{ P_n(t,S) \frac{P_r(t,T)}{P_r(t,S)} e^{C(t,S,T)} - P_n(t,T) \right\}
    // where N is the nominal, \tau(S, T) is the daycount which we assume equals 1 here.
    // e^{C(t,S,T)} is the correction term which we deal with below.
 
    // Get P_n(t,S) and P_n(t,T).
    auto irIdx = model_->ccyIndex(model_->infjy(index_)->currency());
    auto irTs = model_->irlgm1f(irIdx)->termStructure();
    auto p_n_t_S = model_->discountBond(irIdx, relativeTime_, S, state_[2]);
    auto p_n_t_T = model_->discountBond(irIdx, relativeTime_, T, state_[2]);
 
    // Get the rrRatio := P_r(t,T)}{P_r(t,S)}.
    auto rrParam = model_->infjy(index_)->realRate();
    auto H_r_S = rrParam->H(S);
    auto H_r_T = rrParam->H(T);
    auto zeta_r_t = rrParam->zeta(relativeTime_);
    auto rrRatio = exp(-(H_r_T - H_r_S) * state_[0] - 0.5 * (H_r_T * H_r_T - H_r_S * H_r_S) * zeta_r_t);
 
    const auto& zts = model_->infjy(index_)->realRate()->termStructure();
    rrRatio *= (irTs->discount(T) * inflationGrowth(zts, T, indexIsInterpolated_)) /
               (irTs->discount(S) * inflationGrowth(zts, S, indexIsInterpolated_));
 
    // Calculate the correction term C(t,S,T)
    using CrossAssetAnalytics::ay;
    using CrossAssetAnalytics::az;
    using CrossAssetAnalytics::Hy;
    using CrossAssetAnalytics::Hz;
    using CrossAssetAnalytics::integral;
    using CrossAssetAnalytics::LC;
    using CrossAssetAnalytics::P;
    using CrossAssetAnalytics::ryy;
    using CrossAssetAnalytics::rzy;
    using CrossAssetAnalytics::sy;
 
    auto H_n_S = model_->irlgm1f(irIdx)->H(S);
    auto zeta_r_S = rrParam->zeta(S);
 
    auto c = H_r_S * (zeta_r_S - zeta_r_t);
    c -= H_n_S * integral(*model_, P(rzy(irIdx, index_, 0), az(irIdx), ay(index_)), relativeTime_, S);
    c += integral(*model_,
                  LC(0.0, -1.0, P(ay(index_), ay(index_), Hy(index_)), 1.0,
                     P(rzy(irIdx, index_, 0), az(irIdx), ay(index_), Hz(irIdx)), -1.0,
                     P(ryy(index_, index_, 0, 1), ay(index_), sy(index_))),
                  relativeTime_, S);
    c *= (H_r_S - H_r_T);
 
    return p_n_t_S * rrRatio * exp(c) - p_n_t_T;
}

Here is the call graph for this function:

Here is the caller graph for this function:

checkState()

void checkState ( ) const

overrideprotectedvirtual

Override this method to perform checks on the state variable array when the state and move methods are called.

Reimplemented from YoYInflationModelTermStructure.

Definition at line 215 of file jyimpliedyoyinflationtermstructure.cpp.

                                                          {
    // For JY YoY, expect the state to be three variables i.e. z_I and c_I and z_{ir}.
    QL_REQUIRE(state_.size() == 3, "JyImpliedYoYInflationTermStructure: expected state to have "
                                       << "three elements but got " << state_.size());
}