#include <qle/termstructures/yoyinflationoptionletvolstripper.hpp>

Collaboration diagram for YoYInflationOptionletVolStripper:

Public Member Functions
	YoYInflationOptionletVolStripper (const QuantLib::ext::shared_ptr< QuantLib::CapFloorTermVolSurface > &volSurface, const QuantLib::ext::shared_ptr< YoYInflationIndex > &index, const Handle< YieldTermStructure > &nominalTs, VolatilityType type=ShiftedLognormal, Real displacement=0.0)

const QuantLib::ext::shared_ptr< QuantExt::YoYOptionletVolatilitySurface >	yoyInflationCapFloorVolSurface () const

LazyObject interface
QuantLib::ext::shared_ptr< QuantExt::YoYOptionletVolatilitySurface >	yoyOptionletVolSurface_

QuantLib::ext::shared_ptr< QuantLib::CapFloorTermVolSurface >	volSurface_

QuantLib::ext::shared_ptr< YoYInflationIndex >	yoyIndex_

Handle< YieldTermStructure >	nominalTs_

VolatilityType	type_

Real	displacement_

void	performCalculations ()

Detailed Description

Helper class to strip yoy inflation optionlet (i.e. caplet/floorlet) volatilities from the (cap/floor) term volatilities of a CapFloorTermVolSurface.

Definition at line 39 of file yoyinflationoptionletvolstripper.hpp.

Constructor & Destructor Documentation

◆ YoYInflationOptionletVolStripper()

YoYInflationOptionletVolStripper	(	const QuantLib::ext::shared_ptr< QuantLib::CapFloorTermVolSurface > &	volSurface,
		const QuantLib::ext::shared_ptr< YoYInflationIndex > &	index,
		const Handle< YieldTermStructure > &	nominalTs,
		VolatilityType	type = `ShiftedLognormal`,
		Real	displacement = `0.0`
	)

Definition at line 35 of file yoyinflationoptionletvolstripper.cpp.

    : volSurface_(volSurface), yoyIndex_(index), nominalTs_(nominalTs), type_(type), displacement_(displacement) {
 
    performCalculations();
}

Here is the call graph for this function:

Member Function Documentation

◆ yoyInflationCapFloorVolSurface()

const QuantLib::ext::shared_ptr< QuantExt::YoYOptionletVolatilitySurface > yoyInflationCapFloorVolSurface ( ) const

Definition at line 46 of file yoyinflationoptionletvolstripper.hpp.

                                                                                                              {
        return yoyOptionletVolSurface_;
    }

◆ performCalculations()

void performCalculations ( )

Definition at line 43 of file yoyinflationoptionletvolstripper.cpp.

                                                           {
 
    Calendar cal = yoyIndex_->yoyInflationTermStructure()->calendar();
    Period obsLag = yoyIndex_->yoyInflationTermStructure()->observationLag();
    Size settDays = volSurface_->settlementDays();
    DayCounter dc = yoyIndex_->yoyInflationTermStructure()->dayCounter();
    BusinessDayConvention bdc = volSurface_->businessDayConvention();
 
    Frequency frequency = yoyIndex_->frequency();
 
    std::vector<Rate> strikes = volSurface_->strikes();
    std::vector<Period> terms = volSurface_->optionTenors();
    std::vector<Time> times = volSurface_->optionTimes();
 
    std::vector<Period> optionletTerms;
    optionletTerms.push_back(terms.front());
    while (optionletTerms.back() != terms.back()) {
        optionletTerms.push_back(optionletTerms.back() + Period(1, Years));
    }
 
    Matrix cPrice(strikes.size(), strikes.size() == 0 ? 0 : optionletTerms.size(), Null<Real>()),
        fPrice(strikes.size(), strikes.size() == 0 ? 0 : optionletTerms.size(), Null<Real>());
 
    // populate cPrice
    for (Size i = 0; i < optionletTerms.size(); i++) {
        for (Size j = 0; j < strikes.size(); j++) {
            Time t = volSurface_->timeFromReference(volSurface_->optionDateFromTenor(optionletTerms[i]));
 
            Real vol = volSurface_->volatility(t, strikes[j]);
            QuantLib::ext::shared_ptr<ConstantYoYOptionletVolatility> ovs(
                new ConstantYoYOptionletVolatility(vol, settDays, cal, bdc, dc, obsLag, frequency, false, -1.0, 3.0));
            QuantLib::ext::shared_ptr<PricingEngine> pe;
            Handle<QuantLib::YoYOptionletVolatilitySurface> hovs(ovs);
            if (type_ == ShiftedLognormal) {
                if (displacement_ == 0.0) {
                    pe = QuantLib::ext::make_shared<YoYInflationBlackCapFloorEngine>(yoyIndex_, hovs, nominalTs_);
                } else {
                    pe = QuantLib::ext::make_shared<YoYInflationUnitDisplacedBlackCapFloorEngine>(yoyIndex_, hovs, nominalTs_);
                }
            } else if (type_ == Normal) {
                pe = QuantLib::ext::make_shared<YoYInflationBachelierCapFloorEngine>(yoyIndex_, hovs, nominalTs_);
            } else {
                QL_FAIL("unknown volatility type: " << type_);
            }
            // calculate the cap price
            YoYInflationCapFloor cap = YoYInflationCapFloor(
                MakeYoYInflationCapFloor(YoYInflationCapFloor::Cap, yoyIndex_, optionletTerms[i].length(), cal, obsLag)
                    .withStrike(strikes[j])
                    .withPricingEngine(pe)
                    .withNominal(10000));
            cPrice[j][i] = cap.NPV();
            // floor price
            YoYInflationCapFloor floor =
                YoYInflationCapFloor(MakeYoYInflationCapFloor(YoYInflationCapFloor::Floor, yoyIndex_,
                                                              optionletTerms[i].length(), cal, obsLag)
                                         .withStrike(strikes[j])
                                         .withPricingEngine(pe)
                                         .withNominal(10000));
            fPrice[j][i] = floor.NPV();
        }
    }
 
    // switch between floors and caps using the last option maturity, but keep one floor and one cap strike at least
    // this is the best we can do to use OTM instruments with the original QL yoy vol bootstrapper
    int jCritical = 0;
    while (jCritical < static_cast<int>(strikes.size()) &&
           fPrice[jCritical][optionletTerms.size() - 1] < cPrice[jCritical][optionletTerms.size() - 1])
        ++jCritical;
    int numberOfFloors = std::max(1, jCritical - 1);
    int numberOfCaps = std::max(1, static_cast<int>(strikes.size()) - jCritical + 1);
    Matrix cPriceFinal(numberOfCaps, strikes.size() == 0 ? 0 : optionletTerms.size());
    Matrix fPriceFinal(numberOfFloors, strikes.size() == 0 ? 0 : optionletTerms.size());
    std::vector<Real> fStrikes, cStrikes;
    for (int j = 0; j < numberOfCaps; ++j) {
        for (int i = 0; i < static_cast<int>(optionletTerms.size()); ++i) {
            cPriceFinal(j, i) = cPrice[strikes.size() - numberOfCaps + j][i];
        }
        cStrikes.push_back(strikes[strikes.size() - numberOfCaps + j]);
    }
    for (int j = 0; j < numberOfFloors; ++j) {
        for (int i = 0; i < static_cast<int>(optionletTerms.size()); ++i) {
            fPriceFinal(j, i) = fPrice[j][i];
        }
        fStrikes.push_back(strikes[j]);
    }
 
    Rate baseRate = yoyIndex_->yoyInflationTermStructure()->baseRate();
    QuantExt::InterpolatedYoYCapFloorTermPriceSurface<Bilinear, Linear> ys(settDays, obsLag, yoyIndex_, baseRate,
                                                                           nominalTs_, dc, cal, bdc, cStrikes, fStrikes,
                                                                           optionletTerms, cPriceFinal, fPriceFinal);
 
    QuantLib::ext::shared_ptr<QuantExt::InterpolatedYoYCapFloorTermPriceSurface<Bilinear, Linear>> yoySurface =
        QuantLib::ext::make_shared<QuantExt::InterpolatedYoYCapFloorTermPriceSurface<Bilinear, Linear>>(ys);
    yoySurface->enableExtrapolation();
 
    QuantLib::ext::shared_ptr<InterpolatedYoYOptionletStripper<Linear>> yoyStripper =
        QuantLib::ext::make_shared<InterpolatedYoYOptionletStripper<Linear>>();
 
    // Create an empty volatility surface to pass to the engine
    QuantLib::ext::shared_ptr<QuantLib::YoYOptionletVolatilitySurface> ovs =
        QuantLib::ext::dynamic_pointer_cast<QuantLib::YoYOptionletVolatilitySurface>(
            QuantLib::ext::make_shared<QuantLib::ConstantYoYOptionletVolatility>(0.0, settDays, cal, bdc, dc, obsLag, frequency,
                                                                         yoySurface->indexIsInterpolated()));
    Handle<QuantLib::YoYOptionletVolatilitySurface> hovs(ovs);
 
    QuantLib::ext::shared_ptr<YoYInflationBachelierCapFloorEngine> cfEngine =
        QuantLib::ext::make_shared<YoYInflationBachelierCapFloorEngine>(yoyIndex_, hovs, nominalTs_);
 
    yoyOptionletVolSurface_ = QuantLib::ext::make_shared<QuantExt::KInterpolatedYoYOptionletVolatilitySurface<Linear>>(
        settDays, cal, bdc, dc, obsLag, yoySurface, cfEngine, yoyStripper, 0, Linear(), type_, displacement_);
    yoyOptionletVolSurface_->enableExtrapolation();
}