#include <qle/termstructures/optionletstripper2.hpp>

Inheritance diagram for OptionletStripper2:

Collaboration diagram for OptionletStripper2:

Classes
class	ObjectiveFunction

Public Member Functions
	OptionletStripper2 (const QuantLib::ext::shared_ptr< QuantExt::OptionletStripper > &optionletStripper, const Handle< QuantLib::CapFloorTermVolCurve > &atmCapFloorTermVolCurve, const Handle< YieldTermStructure > &discount=Handle< YieldTermStructure >(), const VolatilityType type=ShiftedLognormal, const Real displacement=0.0)

vector< Rate >	atmCapFloorStrikes () const

vector< Real >	atmCapFloorPrices () const

vector< Volatility >	spreadsVol () const

Public Member Functions inherited from OptionletStripper
const std::vector< Rate > &	optionletStrikes (Size i) const override

const std::vector< Volatility > &	optionletVolatilities (Size i) const override

const std::vector< Date > &	optionletFixingDates () const override

const std::vector< Time > &	optionletFixingTimes () const override

Size	optionletMaturities () const override

const std::vector< Rate > &	atmOptionletRates () const override

DayCounter	dayCounter () const override

Calendar	calendar () const override

Natural	settlementDays () const override

BusinessDayConvention	businessDayConvention () const override

const std::vector< Period > &	optionletFixingTenors () const

const std::vector< Date > &	optionletPaymentDates () const

const std::vector< Time > &	optionletAccrualPeriods () const

ext::shared_ptr< CapFloorTermVolSurface >	termVolSurface () const

ext::shared_ptr< IborIndex >	index () const

Real	displacement () const override

VolatilityType	volatilityType () const override

const Period &	rateComputationPeriod () const

LazyObject interface
const QuantLib::ext::shared_ptr< QuantExt::OptionletStripper >	stripper_

const Handle< QuantLib::CapFloorTermVolCurve >	atmCapFloorTermVolCurve_

DayCounter	dc_

Size	nOptionExpiries_

vector< Rate >	atmCapFloorStrikes_

vector< Real >	atmCapFloorPrices_

vector< Volatility >	spreadsVolImplied_

vector< QuantLib::ext::shared_ptr< QuantLib::CapFloor > >	caps_

Size	maxEvaluations_

Real	accuracy_

const VolatilityType	inputVolatilityType_

const Real	inputDisplacement_

void	performCalculations () const override

vector< Volatility >	spreadsVolImplied (const Handle< YieldTermStructure > &discount) const

Additional Inherited Members
Protected Member Functions inherited from OptionletStripper
	OptionletStripper (const ext::shared_ptr< QuantExt::CapFloorTermVolSurface > &, const ext::shared_ptr< IborIndex > &index, const Handle< YieldTermStructure > &discount=Handle< YieldTermStructure >(), const VolatilityType type=ShiftedLognormal, const Real displacement=0.0, const Period &rateComputationPeriod=0 *Days, const Size onCapSettlementDays=0)

virtual void	populateDates () const
	Method to populate the dates, times and accruals that can be overridden in derived classes. More...

Protected Attributes inherited from OptionletStripper
ext::shared_ptr< CapFloorTermVolSurface >	termVolSurface_

ext::shared_ptr< IborIndex >	index_

Handle< YieldTermStructure >	discount_

Size	nStrikes_

Size	nOptionletTenors_

std::vector< std::vector< Rate > >	optionletStrikes_

std::vector< std::vector< Volatility > >	optionletVolatilities_

std::vector< Time >	optionletTimes_

std::vector< Date >	optionletDates_

std::vector< Period >	optionletTenors_

std::vector< Rate >	atmOptionletRate_

std::vector< Date >	optionletPaymentDates_

std::vector< Time >	optionletAccrualPeriods_

std::vector< Period >	capFloorLengths_

const VolatilityType	volatilityType_

const Real	displacement_

const Period	rateComputationPeriod_

const Size	onCapSettlementDays_

Detailed Description

Helper class to extend a QuantExt::OptionletStripper object stripping additional optionlet (i.e. caplet/floorlet) volatilities (a.k.a. forward-forward volatilities) from the (cap/floor) At-The-Money term volatilities of a CapFloorTermVolCurve.

Definition at line 41 of file optionletstripper2.hpp.

Constructor & Destructor Documentation

◆ OptionletStripper2()

OptionletStripper2	(	const QuantLib::ext::shared_ptr< QuantExt::OptionletStripper > &	optionletStripper,
		const Handle< QuantLib::CapFloorTermVolCurve > &	atmCapFloorTermVolCurve,
		const Handle< YieldTermStructure > &	discount = `Handle<YieldTermStructure>()`,
		const VolatilityType	type = `ShiftedLognormal`,
		const Real	displacement = `0.0`
	)

Optionlet stripper that modifies the stripped optionlets from optionletStripper by adding optionlet volatilities stripped from an ATM volatility curve atmCapFloorTermVolCurve

Definition at line 32 of file optionletstripper2.cpp.

    : OptionletStripper(optionletStripper->termVolSurface(), optionletStripper->index(), discount,
                        optionletStripper->volatilityType(), optionletStripper->displacement()),
      stripper_(optionletStripper), atmCapFloorTermVolCurve_(atmCapFloorTermVolCurve),
      dc_(stripper_->termVolSurface()->dayCounter()), nOptionExpiries_(atmCapFloorTermVolCurve->optionTenors().size()),
      atmCapFloorStrikes_(nOptionExpiries_), atmCapFloorPrices_(nOptionExpiries_), spreadsVolImplied_(nOptionExpiries_),
      caps_(nOptionExpiries_), maxEvaluations_(10000), accuracy_(1.e-6), inputVolatilityType_(type),
      inputDisplacement_(displacement) {
 
    registerWith(stripper_);
    registerWith(atmCapFloorTermVolCurve_);
 
    QL_REQUIRE(dc_ == atmCapFloorTermVolCurve->dayCounter(), "different day counters provided");
}

Member Function Documentation

◆ atmCapFloorStrikes()

vector< Rate > atmCapFloorStrikes ( ) const

Definition at line 142 of file optionletstripper2.cpp.

                                                          {
    calculate();
    return atmCapFloorStrikes_;
}

◆ atmCapFloorPrices()

vector< Real > atmCapFloorPrices ( ) const

Definition at line 147 of file optionletstripper2.cpp.

                                                         {
    calculate();
    return atmCapFloorPrices_;
}

◆ spreadsVol()

vector< Volatility > spreadsVol ( ) const

Definition at line 137 of file optionletstripper2.cpp.

                                                        {
    calculate();
    return spreadsVolImplied_;
}

◆ performCalculations()

void performCalculations ( ) const

override

Definition at line 50 of file optionletstripper2.cpp.

                                                   {
 
    // optionletStripper data
    optionletDates_ = stripper_->optionletFixingDates();
    optionletPaymentDates_ = stripper_->optionletPaymentDates();
    optionletAccrualPeriods_ = stripper_->optionletAccrualPeriods();
    optionletTimes_ = stripper_->optionletFixingTimes();
    atmOptionletRate_ = stripper_->atmOptionletRates();
    for (Size i = 0; i < optionletTimes_.size(); ++i) {
        optionletStrikes_[i] = stripper_->optionletStrikes(i);
        optionletVolatilities_[i] = stripper_->optionletVolatilities(i);
    }
 
    // atmCapFloorTermVolCurve data
    const vector<Period>& optionExpiriesTenors = atmCapFloorTermVolCurve_->optionTenors();
    const vector<Time>& optionExpiriesTimes = atmCapFloorTermVolCurve_->optionTimes();
 
    // discount curve
    const Handle<YieldTermStructure>& discountCurve =
        discount_.empty() ? index_->forwardingTermStructure() : discount_;
 
    for (Size j = 0; j < nOptionExpiries_; ++j) {
        // Dummy strike, doesn't get used for ATM curve
        Volatility atmOptionVol = atmCapFloorTermVolCurve_->volatility(optionExpiriesTimes[j], 33.3333);
 
        // Create a cap for each pillar point on ATM curve and attach relevant pricing engine i.e. Black if
        // quotes are shifted lognormal and Bachelier if quotes are normal
        QuantLib::ext::shared_ptr<PricingEngine> engine;
        if (inputVolatilityType_ == ShiftedLognormal) {
            engine = QuantLib::ext::make_shared<BlackCapFloorEngine>(discountCurve, atmOptionVol, dc_, inputDisplacement_);
        } else if (inputVolatilityType_ == Normal) {
            engine = QuantLib::ext::make_shared<BachelierCapFloorEngine>(discountCurve, atmOptionVol, dc_);
        } else {
            QL_FAIL("unknown volatility type: " << volatilityType_);
        }
 
        // Using Null<Rate>() as strike => strike will be set to ATM rate. However, to calculate ATM rate, QL requires
        // a BlackCapFloorEngine to be set (not a BachelierCapFloorEngine)! So, need a temp BlackCapFloorEngine with a
        // dummy vol to calculate ATM rate. Needs to be fixed in QL.
        QuantLib::ext::shared_ptr<PricingEngine> tempEngine = QuantLib::ext::make_shared<BlackCapFloorEngine>(discountCurve, 0.01);
        caps_[j] = MakeCapFloor(CapFloor::Cap, optionExpiriesTenors[j], index_, Null<Rate>(), 0 * Days)
                       .withPricingEngine(tempEngine);
 
        // Now set correct engine and get the ATM rate and the price
        caps_[j]->setPricingEngine(engine);
        atmCapFloorStrikes_[j] = caps_[j]->atmRate(**discountCurve);
        atmCapFloorPrices_[j] = caps_[j]->NPV();
    }
 
    spreadsVolImplied_ = spreadsVolImplied(discountCurve);
 
    StrippedOptionletAdapter adapter(stripper_);
    adapter.enableExtrapolation();
 
    Volatility unadjustedVol, adjustedVol;
    for (Size j = 0; j < nOptionExpiries_; ++j) {
        for (Size i = 0; i < optionletVolatilities_.size(); ++i) {
            if (i <= caps_[j]->floatingLeg().size()) {
                unadjustedVol = adapter.volatility(optionletTimes_[i], atmCapFloorStrikes_[j]);
                adjustedVol = unadjustedVol + spreadsVolImplied_[j];
 
                // insert adjusted volatility
                vector<Rate>::const_iterator previous =
                    lower_bound(optionletStrikes_[i].begin(), optionletStrikes_[i].end(), atmCapFloorStrikes_[j]);
                Size insertIndex = previous - optionletStrikes_[i].begin();
 
                optionletStrikes_[i].insert(optionletStrikes_[i].begin() + insertIndex, atmCapFloorStrikes_[j]);
                optionletVolatilities_[i].insert(optionletVolatilities_[i].begin() + insertIndex, adjustedVol);
            }
        }
    }
}

Here is the call graph for this function:

◆ spreadsVolImplied()

vector< Volatility > spreadsVolImplied ( const Handle< YieldTermStructure > & discount ) const

private

Definition at line 123 of file optionletstripper2.cpp.

                                                                                                         {
 
    Brent solver;
    vector<Volatility> result(nOptionExpiries_);
    Volatility guess = 0.0001, minSpread = -0.1, maxSpread = 0.1;
    for (Size j = 0; j < nOptionExpiries_; ++j) {
        ObjectiveFunction f(stripper_, caps_[j], atmCapFloorPrices_[j], discount);
        solver.setMaxEvaluations(maxEvaluations_);
        Volatility root = solver.solve(f, accuracy_, guess, minSpread, maxSpread);
        result[j] = root;
    }
    return result;
}

Here is the caller graph for this function:

Member Data Documentation

◆ stripper_

const QuantLib::ext::shared_ptr<QuantExt::OptionletStripper> stripper_

private

Definition at line 76 of file optionletstripper2.hpp.

◆ atmCapFloorTermVolCurve_

const Handle<QuantLib::CapFloorTermVolCurve> atmCapFloorTermVolCurve_

private

Definition at line 77 of file optionletstripper2.hpp.

◆ dc_

DayCounter dc_

private

Definition at line 78 of file optionletstripper2.hpp.

◆ nOptionExpiries_

Size nOptionExpiries_

private

Definition at line 79 of file optionletstripper2.hpp.

◆ atmCapFloorStrikes_

vector<Rate> atmCapFloorStrikes_

mutableprivate

Definition at line 80 of file optionletstripper2.hpp.

◆ atmCapFloorPrices_

vector<Real> atmCapFloorPrices_

mutableprivate

Definition at line 81 of file optionletstripper2.hpp.

◆ spreadsVolImplied_

vector<Volatility> spreadsVolImplied_

mutableprivate

Definition at line 82 of file optionletstripper2.hpp.

◆ caps_

vector<QuantLib::ext::shared_ptr<QuantLib::CapFloor> > caps_

mutableprivate

Definition at line 83 of file optionletstripper2.hpp.

◆ maxEvaluations_

Size maxEvaluations_

private

Definition at line 84 of file optionletstripper2.hpp.

◆ accuracy_

Real accuracy_

private

Definition at line 85 of file optionletstripper2.hpp.

◆ inputVolatilityType_

const VolatilityType inputVolatilityType_

private

Definition at line 86 of file optionletstripper2.hpp.

◆ inputDisplacement_

const Real inputDisplacement_

private

Definition at line 87 of file optionletstripper2.hpp.

Classes

Public Member Functions

LazyObject interface

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ OptionletStripper2()

Member Function Documentation

◆ atmCapFloorStrikes()

◆ atmCapFloorPrices()

◆ spreadsVol()

◆ performCalculations()

◆ spreadsVolImplied()

Member Data Documentation

◆ stripper_

◆ atmCapFloorTermVolCurve_

◆ dc_

◆ nOptionExpiries_

◆ atmCapFloorStrikes_

◆ atmCapFloorPrices_

◆ spreadsVolImplied_

◆ caps_

◆ maxEvaluations_

◆ accuracy_

◆ inputVolatilityType_

◆ inputDisplacement_