#include <qle/termstructures/optionletstripperwithatm.hpp>

Inheritance diagram for OptionletStripperWithAtm< TimeInterpolator, SmileInterpolator >:

Collaboration diagram for OptionletStripperWithAtm< TimeInterpolator, SmileInterpolator >:

Classes
class	ObjectiveFunction
	Class that is used to imply the spreads at each tenor such that the ATM cap floor volatilities are retrieved. More...

class	ObjectiveFunctionOIS

Public Member Functions
	OptionletStripperWithAtm (const QuantLib::ext::shared_ptr< QuantExt::OptionletStripper > &osBase, const QuantLib::Handle< CapFloorTermVolCurve > &atmCurve, const QuantLib::Handle< QuantLib::YieldTermStructure > &discount=QuantLib::Handle< QuantLib::YieldTermStructure >(), const QuantLib::VolatilityType atmVolatilityType=QuantLib::ShiftedLognormal, QuantLib::Real atmDisplacement=0.0, QuantLib::Size maxEvaluations=10000, QuantLib::Real accuracy=1.0e-12, const TimeInterpolator &ti=TimeInterpolator(), const SmileInterpolator &si=SmileInterpolator())
	Constructor. More...

Inspectors
std::vector< QuantLib::Rate >	atmStrikes () const

std::vector< QuantLib::Real >	atmPrices () const

std::vector< QuantLib::Volatility >	volSpreads () 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
QuantLib::ext::shared_ptr< QuantExt::OptionletStripper >	osBase_
	Base optionlet stripper. More...

QuantLib::Handle< CapFloorTermVolCurve >	atmCurve_
	ATM volatility curve. More...

QuantLib::VolatilityType	atmVolatilityType_
	ATM volatility type. More...

QuantLib::Real	atmDisplacement_
	ATM volatility shift if the ATM volatility type is ShiftedLognormal. More...

QuantLib::Size	maxEvaluations_
	Maximum number of evaluations when searching for spread to match ATM volatilities. More...

QuantLib::Real	accuracy_
	Required accuracy when searching for spread to match ATM volatilities. More...

TimeInterpolator	ti_
	The interpolation object in the time direction. More...

SmileInterpolator	si_
	The interpolation object in the strike direction. More...

DayCounter	dayCounter_
	The day counter for atmCurve_ and osBase_. More...

Size	nAtmExpiries_
	The number of ATM instruments in the ATM curve, atmCurve_. More...

std::vector< QuantLib::Rate >	atmStrikes_

std::vector< QuantLib::Real >	atmPrices_

std::vector< QuantLib::Volatility >	volSpreads_

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

std::vector< QuantLib::Leg >	capsOIS_

void	performCalculations () const override

std::vector< QuantLib::Volatility >	volSpreads (const QuantLib::Handle< QuantLib::YieldTermStructure > &discount, const QuantLib::Handle< QuantLib::OptionletVolatilityStructure > &ovs, const bool isOis) const
	Return the implied optionlet spreads to retrieve the ATM cap floor term volatilities. More...

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

template<class TimeInterpolator, class SmileInterpolator>
class QuantExt::OptionletStripperWithAtm< TimeInterpolator, SmileInterpolator >

Optionlet stripper that amends existing stripped optionlets to incorporate ATM cap floor term volatilities

Definition at line 50 of file optionletstripperwithatm.hpp.

Constructor & Destructor Documentation

◆ OptionletStripperWithAtm()

OptionletStripperWithAtm	(	const QuantLib::ext::shared_ptr< QuantExt::OptionletStripper > &	osBase,
		const QuantLib::Handle< CapFloorTermVolCurve > &	atmCurve,
		const QuantLib::Handle< QuantLib::YieldTermStructure > &	discount = `QuantLib::Handle<QuantLib::YieldTermStructure>()`,
		const QuantLib::VolatilityType	atmVolatilityType = `QuantLib::ShiftedLognormal`,
		QuantLib::Real	atmDisplacement = `0.0`,
		QuantLib::Size	maxEvaluations = `10000`,
		QuantLib::Real	accuracy = `1.0e-12`,
		const TimeInterpolator &	ti = `TimeInterpolator()`,
		const SmileInterpolator &	si = `SmileInterpolator()`
	)

Constructor.

Definition at line 149 of file optionletstripperwithatm.hpp.

    : QuantExt::OptionletStripper(osBase->termVolSurface(), osBase->index(), discount, osBase->volatilityType(),
                                  osBase->displacement(), osBase->rateComputationPeriod()),
      osBase_(osBase), atmCurve_(atmCurve), atmVolatilityType_(atmVolatilityType), atmDisplacement_(atmDisplacement),
      maxEvaluations_(maxEvaluations), accuracy_(accuracy), dayCounter_(osBase_->termVolSurface()->dayCounter()),
      nAtmExpiries_(atmCurve_->optionTenors().size()), atmStrikes_(nAtmExpiries_), atmPrices_(nAtmExpiries_),
      volSpreads_(nAtmExpiries_), caps_(nAtmExpiries_), capsOIS_(nAtmExpiries_) {
 
    registerWith(osBase_);
    registerWith(atmCurve_);
 
    QL_REQUIRE(dayCounter_ == atmCurve_->dayCounter(),
               "The ATM curve day counter should equal that of the underlying base optionlet stripper");
}

Member Function Documentation

◆ atmStrikes()

std::vector< QuantLib::Rate > atmStrikes

Definition at line 170 of file optionletstripperwithatm.hpp.

                                                                                                               {
    calculate();
    return atmStrikes_;
}

◆ atmPrices()

std::vector< QuantLib::Real > atmPrices

Definition at line 176 of file optionletstripperwithatm.hpp.

                                                                                                              {
    calculate();
    return atmPrices_;
}

◆ volSpreads() [1/2]

std::vector< QuantLib::Volatility > volSpreads

Definition at line 183 of file optionletstripperwithatm.hpp.

                                                                                {
    calculate();
    return volSpreads_;
}

◆ performCalculations()

void performCalculations

override

Definition at line 189 of file optionletstripperwithatm.hpp.

                                                                                              {
 
    // Some localised typedefs and using declarations to make the code more readable
    using QuantLib::BachelierCapFloorEngine;
    using QuantLib::BlackCapFloorEngine;
    using QuantLib::Handle;
    using QuantLib::MakeCapFloor;
    using QuantLib::OptionletVolatilityStructure;
    using QuantLib::Period;
    using QuantLib::Size;
    using QuantLib::Time;
    using QuantLib::Volatility;
    using QuantLib::YieldTermStructure;
    using std::vector;
 
    bool isOis = QuantLib::ext::dynamic_pointer_cast<OvernightIndex>(index_) != nullptr;
 
    // Possible update based on underlying optionlet stripper data
    optionletDates_ = osBase_->optionletFixingDates();
    optionletPaymentDates_ = osBase_->optionletPaymentDates();
    optionletAccrualPeriods_ = osBase_->optionletAccrualPeriods();
    optionletTimes_ = osBase_->optionletFixingTimes();
    atmOptionletRate_ = osBase_->atmOptionletRates();
    for (Size i = 0; i < optionletTimes_.size(); ++i) {
        optionletStrikes_[i] = osBase_->optionletStrikes(i);
        optionletVolatilities_[i] = osBase_->optionletVolatilities(i);
    }
 
    // ATM curve tenors
    const vector<Period>& atmTenors = atmCurve_->optionTenors();
    vector<Time> atmTimes(atmTenors.size());
    for (Size i = 0; i < atmTenors.size(); ++i) {
        Date d = atmCurve_->optionDateFromTenor(atmTenors[i]);
        atmTimes[i] = atmCurve_->timeFromReference(d);
    }
 
    // discount curve
    const Handle<YieldTermStructure>& discountCurve = discount_.empty() ? index_->forwardingTermStructure() : discount_;
 
    // Populate ATM strikes and prices
    for (Size j = 0; j < nAtmExpiries_; ++j) {
 
        if (isOis) {
 
            Volatility atmVol = atmCurve_->volatility(atmTimes[j], 0.01);
            auto pricer = QuantLib::ext::make_shared<BlackOvernightIndexedCouponPricer>(
                Handle<OptionletVolatilityStructure>(QuantLib::ext::make_shared<ConstantOptionletVolatility>(
                    0, NullCalendar(), Unadjusted, atmVol, Actual365Fixed(), volatilityType(), false)));
            capsOIS_[j] =
                MakeOISCapFloor(CapFloor::Cap, atmTenors[j], QuantLib::ext::dynamic_pointer_cast<OvernightIndex>(index_),
                                osBase_->rateComputationPeriod(), Null<Real>(), discountCurve)
                .withCouponPricer(pricer);
            QL_REQUIRE(!capsOIS_[j].empty(),
                       "OptionletStripperWithAtm: internal error: empty cap for expiry " << atmTenors[j]);
            atmStrikes_[j] = getOisCapFloorStrikes(capsOIS_[j]).front().first;
            atmPrices_[j] = QuantLib::CashFlows::npv(capsOIS_[j], **discountCurve, false);
 
        } else {
 
            // Create a cap for each pillar point on ATM curve and attach relevant pricing engine
            Volatility atmVol = atmCurve_->volatility(atmTimes[j], 0.01);
            QuantLib::ext::shared_ptr<PricingEngine> engine;
            if (atmVolatilityType_ == ShiftedLognormal) {
                engine = QuantLib::ext::make_shared<BlackCapFloorEngine>(discountCurve, atmVol, dayCounter_, atmDisplacement_);
            } else if (atmVolatilityType_ == Normal) {
                engine = QuantLib::ext::make_shared<BachelierCapFloorEngine>(discountCurve, atmVol, dayCounter_);
            } else {
                QL_FAIL("Unknown volatility type: " << atmVolatilityType_);
            }
 
            // 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, atmTenors[j], index_, Null<Rate>(), 0 * Days).withPricingEngine(tempEngine);
 
            // Now set correct engine and get the ATM rate and the price
            caps_[j]->setPricingEngine(engine);
            atmStrikes_[j] = caps_[j]->atmRate(**discountCurve);
            atmPrices_[j] = caps_[j]->NPV();
        }
    }
 
    // Create an optionlet volatility structure from the underlying stripped optionlet surface
    QuantLib::ext::shared_ptr<OptionletVolatilityStructure> ovs =
        QuantLib::ext::make_shared<QuantExt::StrippedOptionletAdapter<TimeInterpolator, SmileInterpolator> >(
            atmCurve_->referenceDate(), osBase_);
    ovs->enableExtrapolation();
 
    // Imply the volatility spreads that match the ATM prices
    volSpreads_ = volSpreads(discountCurve, Handle<OptionletVolatilityStructure>(ovs), isOis);
 
    // This stripped optionlet surface is the underlying stripped optionlet surface modified by the implied spreads
    for (Size j = 0; j < nAtmExpiries_; ++j) {
        for (Size i = 0; i < optionletTimes_.size(); ++i) {
            if (i < (isOis ? capsOIS_[j].size() : caps_[j]->floatingLeg().size())) {
 
                Volatility unadjustedVol = ovs->volatility(optionletTimes_[i], atmStrikes_[j]);
                Volatility adjustedVol = unadjustedVol + volSpreads_[j];
 
                // insert ATM strike and adjusted volatility
                vector<Rate>::const_iterator previous =
                    lower_bound(optionletStrikes_[i].begin(), optionletStrikes_[i].end(), atmStrikes_[j]);
                Size insertIndex = previous - optionletStrikes_[i].begin();
                optionletStrikes_[i].insert(optionletStrikes_[i].begin() + insertIndex, atmStrikes_[j]);
                optionletVolatilities_[i].insert(optionletVolatilities_[i].begin() + insertIndex, adjustedVol);
            }
        }
    }
}

Here is the call graph for this function:

◆ volSpreads() [2/2]

std::vector< QuantLib::Volatility > volSpreads	(	const QuantLib::Handle< QuantLib::YieldTermStructure > &	discount,
		const QuantLib::Handle< QuantLib::OptionletVolatilityStructure > &	ovs,
		const bool	isOis
	)		const

private

Return the implied optionlet spreads to retrieve the ATM cap floor term volatilities.

Definition at line 302 of file optionletstripperwithatm.hpp.

                                                                                             {
 
    // Some localised typedefs and using declarations to make the code more readable
    using QuantLib::Size;
    using QuantLib::Volatility;
    using std::vector;
 
    QuantLib::Brent solver;
    vector<Volatility> result(nAtmExpiries_);
    Volatility guess = 0.0001;
    Volatility minSpread = -0.1;
    Volatility maxSpread = 0.1;
    solver.setMaxEvaluations(maxEvaluations_);
 
    for (Size j = 0; j < nAtmExpiries_; ++j) {
        if (isOis) {
            ObjectiveFunctionOIS f(ovs, capsOIS_[j], atmPrices_[j], discount);
            result[j] = solver.solve(f, accuracy_, guess, minSpread, maxSpread);
        } else {
            ObjectiveFunction f(ovs, caps_[j], atmPrices_[j], discount);
            result[j] = solver.solve(f, accuracy_, guess, minSpread, maxSpread);
        }
    }
 
    return result;
}