DkImpliedYoYInflationTermStructure Class Reference

#include <qle/models/dkimpliedyoyinflationtermstructure.hpp>

Inheritance diagram for DkImpliedYoYInflationTermStructure:

Collaboration diagram for DkImpliedYoYInflationTermStructure:

Public Member Functions
	DkImpliedYoYInflationTermStructure (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	yoySwapletRate (QuantLib::Time S, QuantLib::Time T) const
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

Dodgson Kainth (DK) implied year on year inflation term structure

Definition at line 35 of file dkimpliedyoyinflationtermstructure.hpp.

Constructor & Destructor Documentation

DkImpliedYoYInflationTermStructure()

DkImpliedYoYInflationTermStructure	(	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 33 of file dkimpliedyoyinflationtermstructure.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 37 of file dkimpliedyoyinflationtermstructure.cpp.

                                                                                                                {
    
    map<Date, Real> yoys;
    map<Date, Real> yoyswaplet;
    map<Date, Real> yoydiscount;
    Period useLag = obsLag == -1 * Days ? observationLag() : obsLag;
    Calendar cal = model_->infdk(index_)->termStructure()->calendar();
    DayCounter dc = model_->infdk(index_)->termStructure()->dayCounter();
    Date maturity;
 
    for (Size j = 0; j < dts.size(); j++) {
        
        if (indexIsInterpolated_) {
            maturity = dts[j] - useLag;
        } else {
            maturity = inflationPeriod(dts[j] - useLag, frequency()).first;
        }
 
        Schedule schedule = MakeSchedule()
            .from(baseDate())
            .to(maturity)
            .withTenor(1 * Years)
            .withConvention(Unadjusted)
            .withCalendar(cal)
            .backwards();
 
        Real yoyLegRate = 0.0;
        Real fixedDiscounts = 0.0;
        for (Size i = 1; i < schedule.dates().size(); i++) {
            map<Date, Real>::const_iterator it = yoyswaplet.find(schedule.dates()[i]);
            Real swapletPrice, discount;
            if (it == yoyswaplet.end()) {
                if (schedule.dates()[i - 1] < baseDate()) {
                    // for the first YoY swaplet, I(T_i-1) is known, obtained from a fixing. I(T_i) comes from the model
                    // directly - I(t) * Itilde(t,T).
                    Time t1 = dayCounter().yearFraction(model_->infdk(index_)->termStructure()->baseDate(),
                        schedule.dates()[i - 1]);
                    Real I1 = model_->infdkI(index_, t1, t1, state_[0], state_[1]).first;
                    Time t2 = dc.yearFraction(baseDate(), schedule.dates()[i]);
                    std::pair<Real, Real> II2 =
                        model_->infdkI(index_, relativeTime_, relativeTime_ + t2, state_[0], state_[1]);
                    Real I2 = II2.first * II2.second;
                    discount = model_->discountBond(model_->ccyIndex(model_->infdk(index_)->currency()), relativeTime_,
                        relativeTime_ + t2, state_[2]);
                    swapletPrice = discount * ((I2 / I1) - 1);
                } else {
                    Time t1 = dc.yearFraction(baseDate(), schedule.dates()[i - 1]);
                    Time t2 = dc.yearFraction(baseDate(), schedule.dates()[i]);
                    discount = model_->discountBond(model_->ccyIndex(model_->infdk(index_)->currency()), relativeTime_,
                        relativeTime_ + t2, state_[2]);
                    swapletPrice = yoySwapletRate(t1, t2);
                }
                yoyswaplet[schedule.dates()[i]] = swapletPrice;
                yoydiscount[schedule.dates()[i]] = discount;
            } else {
                swapletPrice = yoyswaplet[schedule.dates()[i]];
                discount = yoydiscount[schedule.dates()[i]];
            }
            yoyLegRate += swapletPrice;
            fixedDiscounts += discount;
        }
        Real yoyRate = (yoyLegRate / fixedDiscounts);
 
        if (hasSeasonality()) {
            yoyRate = seasonality()->correctYoYRate(dts[j] - useLag, yoyRate, *this);
        }
        yoys[dts[j]] = yoyRate;
    }
 
    return yoys;
}

Here is the call graph for this function:

yoySwapletRate()

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

protected

Definition at line 109 of file dkimpliedyoyinflationtermstructure.cpp.

                                                                            {
    return model_->infdkYY(index_, relativeTime_, relativeTime_ + S,
        relativeTime_ + T, state_[0], state_[1], state_[2]);
}

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 114 of file dkimpliedyoyinflationtermstructure.cpp.

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