Base YoY inflation cap/floor engine. More...

#include <qle/pricingengines/inflationcapfloorengines.hpp>

Inheritance diagram for YoYInflationCapFloorEngine:

Collaboration diagram for YoYInflationCapFloorEngine:

Public Member Functions
	YoYInflationCapFloorEngine (const ext::shared_ptr< QuantLib::YoYInflationIndex > &, const Handle< QuantLib::YoYOptionletVolatilitySurface > &vol, const Handle< YieldTermStructure > &discountCurve)

ext::shared_ptr< QuantLib::YoYInflationIndex >	index () const

Handle< QuantLib::YoYOptionletVolatilitySurface >	volatility () const

void	setVolatility (const Handle< QuantLib::YoYOptionletVolatilitySurface > &vol)

void	calculate () const override

Protected Member Functions
virtual Real	optionletImpl (Option::Type type, Rate strike, Rate forward, Real stdDev, Real d) const =0
	descendents only need to implement this More...

virtual Real	optionletVegaImpl (Option::Type type, Rate strike, Rate forward, Real stdDev, Real sqrtTime, Real d) const =0

Protected Attributes
ext::shared_ptr< QuantLib::YoYInflationIndex >	index_

Handle< QuantLib::YoYOptionletVolatilitySurface >	volatility_

Handle< YieldTermStructure >	discountCurve_

Detailed Description

Base YoY inflation cap/floor engine.

This class doesn't know yet what sort of vol it is. The inflation index must be linked to a yoy inflation term structure. This provides the curves, hence the call uses a shared_ptr<> not a handle<> to the index.

Definition at line 47 of file inflationcapfloorengines.hpp.

Constructor & Destructor Documentation

◆ YoYInflationCapFloorEngine()

YoYInflationCapFloorEngine	(	const ext::shared_ptr< QuantLib::YoYInflationIndex > &	index,
		const Handle< QuantLib::YoYOptionletVolatilitySurface > &	vol,
		const Handle< YieldTermStructure > &	discountCurve
	)

Definition at line 26 of file inflationcapfloorengines.cpp.

    : index_(index), volatility_(volatility), discountCurve_(discountCurve) {
    registerWith(index_);
    registerWith(volatility_);
    registerWith(discountCurve_);
}

Member Function Documentation

◆ index()

ext::shared_ptr< QuantLib::YoYInflationIndex > index ( ) const

Definition at line 53 of file inflationcapfloorengines.hpp.

53{ return index_; }

Here is the caller graph for this function:

◆ volatility()

Handle< QuantLib::YoYOptionletVolatilitySurface > volatility ( ) const

Definition at line 54 of file inflationcapfloorengines.hpp.

54{ return volatility_; }

◆ setVolatility()

void setVolatility ( const Handle< QuantLib::YoYOptionletVolatilitySurface > & vol )

Definition at line 35 of file inflationcapfloorengines.cpp.

                                                                                                     {
    if (!volatility_.empty())
        unregisterWith(volatility_);
    volatility_ = v;
    registerWith(volatility_);
    update();
}

◆ calculate()

void calculate ( ) const

override

Definition at line 43 of file inflationcapfloorengines.cpp.

                                                 {
 
    // copy black version then adapt to others
 
    Real value = 0.0, vega = 0.0;
    Size optionlets = arguments_.startDates.size();
    std::vector<Real> values(optionlets, 0.0);
    std::vector<Real> stdDevs(optionlets, 0.0);
    std::vector<Real> forwards(optionlets, 0.0);
    YoYInflationCapFloor::Type type = arguments_.type;
 
    Handle<YoYInflationTermStructure> yoyTS = index()->yoyInflationTermStructure();
    Handle<YieldTermStructure> discountTS = discountCurve_;
    QL_REQUIRE(!discountTS.empty(), "YoYInflationCapFloorEngine: No discount curve given.");
    Date settlement = discountTS->referenceDate();
 
    for (Size i = 0; i < optionlets; ++i) {
        Date paymentDate = arguments_.payDates[i];
        if (paymentDate > settlement) { // discard expired caplets
            DiscountFactor d = arguments_.nominals[i] * arguments_.gearings[i] * discountTS->discount(paymentDate) *
                               arguments_.accrualTimes[i];
 
            // We explicitly have the index and assume that
            // the fixing is natural, i.e. no convexity adjustment.
            // If that was required then we would also need
            // nominal vols in the pricing engine, i.e. a different engine.
            // This also means that we do not need the coupon to have
            // a pricing engine to return the swaplet rate and then
            // the adjusted fixing in the instrument.
            forwards[i] = yoyTS->yoyRate(arguments_.fixingDates[i], Period(0, Days));
            Rate forward = forwards[i];
 
            Date fixingDate = arguments_.fixingDates[i];
            Time sqrtTime = 0.0;
            if (fixingDate > volatility_->baseDate()) {
                sqrtTime = std::sqrt(volatility_->timeFromBase(fixingDate));
            }
 
            if (type == YoYInflationCapFloor::Cap || type == YoYInflationCapFloor::Collar) {
                Rate strike = arguments_.capRates[i];
                if (sqrtTime > 0.0) {
                    stdDevs[i] = std::sqrt(volatility_->totalVariance(fixingDate, strike, Period(0, Days)));
                }
 
                // sttDev=0 for already-fixed dates so everything on forward
                values[i] = optionletImpl(Option::Call, strike, forward, stdDevs[i], d);
                vega += optionletVegaImpl(Option::Call, strike, forward, stdDevs[i], sqrtTime, d);
            }
            if (type == YoYInflationCapFloor::Floor || type == YoYInflationCapFloor::Collar) {
                Rate strike = arguments_.floorRates[i];
                if (sqrtTime > 0.0) {
                    stdDevs[i] = std::sqrt(volatility_->totalVariance(fixingDate, strike, Period(0, Days)));
                }
                Real floorlet = optionletImpl(Option::Put, strike, forward, stdDevs[i], d);
                Real floorletVega = optionletVegaImpl(Option::Call, strike, forward, stdDevs[i], sqrtTime, d);
                if (type == YoYInflationCapFloor::Floor) {
                    values[i] = floorlet;
                    vega -= floorletVega;
                } else {
                    // a collar is long a cap and short a floor
                    values[i] -= floorlet;
                    vega -= optionletVegaImpl(Option::Call, strike, forward, stdDevs[i], sqrtTime, d);
                }
            }
            value += values[i];
        }
    }
    results_.value = value;
 
    results_.additionalResults["vega"] = vega;
    results_.additionalResults["optionletsPrice"] = values;
    results_.additionalResults["optionletsAtmForward"] = forwards;
    if (type != YoYInflationCapFloor::Collar)
        results_.additionalResults["optionletsStdDev"] = stdDevs;
}