#include <qle/termstructures/optionletstripper1.hpp>

Inheritance diagram for OptionletStripper1:

Collaboration diagram for OptionletStripper1:

Public Member Functions
	OptionletStripper1 (const QuantLib::ext::shared_ptr< QuantExt::CapFloorTermVolSurface > &, const QuantLib::ext::shared_ptr< IborIndex > &index, Rate switchStrikes=Null< Rate >(), Real accuracy=1.0e-6, Natural maxIter=100, const Handle< YieldTermStructure > &discount=Handle< YieldTermStructure >(), const VolatilityType type=ShiftedLognormal, const Real displacement=0.0, const optional< VolatilityType > targetVolatilityType=boost::none, const optional< Real > targetDisplacement=boost::none)

const Matrix &	capFloorPrices () const

const Matrix &	capletVols () const

const Matrix &	capFloorVolatilities () const

const Matrix &	optionletPrices () const

Rate	switchStrike () const

const Handle< YieldTermStructure > &	discountCurve () 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
Matrix	capFloorPrices_

Matrix	optionletPrices_

Matrix	capFloorVols_

Matrix	optionletStDevs_

Matrix	capletVols_

CapFloorMatrix	capFloors_

std::vector< std::vector< QuantLib::ext::shared_ptr< SimpleQuote > > >	volQuotes_

std::vector< std::vector< QuantLib::ext::shared_ptr< PricingEngine > > >	capFloorEngines_

bool	floatingSwitchStrike_

bool	capFlooMatrixNotInitialized_

Rate	switchStrike_

Real	accuracy_

Natural	maxIter_

const VolatilityType	inputVolatilityType_

const Real	inputDisplacement_

void	performCalculations () const override

bool	stripOptionlets (std::vector< Real > &, CapFloor::Type, Size, const Handle< YieldTermStructure > &, Real) 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 strip optionlet (i.e. caplet/floorlet) volatilities (a.k.a. forward-forward volatilities) from the (cap/floor) term volatilities of a CapFloorTermVolSurface.

Definition at line 44 of file optionletstripper1.hpp.

Constructor & Destructor Documentation

◆ OptionletStripper1()

OptionletStripper1	(	const QuantLib::ext::shared_ptr< QuantExt::CapFloorTermVolSurface > &	,
		const QuantLib::ext::shared_ptr< IborIndex > &	index,
		Rate	switchStrikes = `Null<Rate>()`,
		Real	accuracy = `1.0e-6`,
		Natural	maxIter = `100`,
		const Handle< YieldTermStructure > &	discount = `Handle<YieldTermStructure>()`,
		const VolatilityType	type = `ShiftedLognormal`,
		const Real	displacement = `0.0`,
		const optional< VolatilityType >	targetVolatilityType = `boost::none`,
		const optional< Real >	targetDisplacement = `boost::none`
	)

Definition at line 33 of file optionletstripper1.cpp.

    : OptionletStripper(termVolSurface, index, discount, targetVolatilityType ? *targetVolatilityType : type,
                        targetDisplacement ? *targetDisplacement : displacement),
      volQuotes_(nOptionletTenors_, std::vector<shared_ptr<SimpleQuote> >(nStrikes_)),
      floatingSwitchStrike_(switchStrike == Null<Rate>() ? true : false), capFlooMatrixNotInitialized_(true),
      switchStrike_(switchStrike), accuracy_(accuracy), maxIter_(maxIter), inputVolatilityType_(type),
      inputDisplacement_(displacement) {
 
    capFloorPrices_ = Matrix(nOptionletTenors_, nStrikes_);
    optionletPrices_ = Matrix(nOptionletTenors_, nStrikes_);
    capletVols_ = Matrix(nOptionletTenors_, nStrikes_);
    capFloorVols_ = Matrix(nOptionletTenors_, nStrikes_);
 
    Real firstGuess = 0.14; // guess is only used for shifted lognormal vols
    optionletStDevs_ = Matrix(nOptionletTenors_, nStrikes_, firstGuess);
 
    capFloors_ = CapFloorMatrix(nOptionletTenors_);
    capFloorEngines_ = std::vector<std::vector<QuantLib::ext::shared_ptr<PricingEngine> > >(nOptionletTenors_);
}

Member Function Documentation

◆ capFloorPrices()

const Matrix & capFloorPrices ( ) const

Definition at line 189 of file optionletstripper1.cpp.

                                                       {
    calculate();
    return capFloorPrices_;
}

◆ capletVols()

const Matrix & capletVols ( ) const

Definition at line 184 of file optionletstripper1.cpp.

                                                   {
    calculate();
    return capletVols_;
}

◆ capFloorVolatilities()

const Matrix & capFloorVolatilities ( ) const

Definition at line 194 of file optionletstripper1.cpp.

                                                             {
    calculate();
    return capFloorVols_;
}

◆ optionletPrices()

const Matrix & optionletPrices ( ) const

Definition at line 199 of file optionletstripper1.cpp.

                                                        {
    calculate();
    return optionletPrices_;
}

◆ switchStrike()

Rate switchStrike ( ) const

Definition at line 204 of file optionletstripper1.cpp.

                                            {
    if (floatingSwitchStrike_)
        calculate();
    return switchStrike_;
}

◆ discountCurve()

const Handle< YieldTermStructure > & discountCurve ( ) const

Definition at line 60 of file optionletstripper1.hpp.

60{ return discount_; }

QuantExt::OptionletStripper::discount_

Handle< YieldTermStructure > discount_

Definition: optionletstripper.hpp:82

Here is the caller graph for this function:

◆ performCalculations()

void performCalculations ( ) const

override

Definition at line 58 of file optionletstripper1.cpp.

                                                   {
 
    // update dates
    populateDates();
 
    if (floatingSwitchStrike_) {
        Rate averageAtmOptionletRate = 0.0;
        for (Size i = 0; i < nOptionletTenors_; ++i) {
            averageAtmOptionletRate += atmOptionletRate_[i];
        }
        switchStrike_ = averageAtmOptionletRate / nOptionletTenors_;
    }
 
    const Handle<YieldTermStructure>& discountCurve =
        discount_.empty() ? index_->forwardingTermStructure() : discount_;
 
    const std::vector<Rate>& strikes = termVolSurface_->strikes();
    DayCounter dc = termVolSurface_->dayCounter();
    // initialize CapFloorMatrix
    if (capFlooMatrixNotInitialized_) {
        for (Size i = 0; i < nOptionletTenors_; ++i) {
            capFloors_[i].resize(nStrikes_);
            capFloorEngines_[i].resize(nStrikes_);
        }
        // construction might go here
        for (Size j = 0; j < nStrikes_; ++j) {
            for (Size i = 0; i < nOptionletTenors_; ++i) {
                volQuotes_[i][j] = shared_ptr<SimpleQuote>(new SimpleQuote());
                if (inputVolatilityType_ == ShiftedLognormal) {
                    capFloorEngines_[i][j] = QuantLib::ext::make_shared<BlackCapFloorEngine>(
                        discountCurve, Handle<Quote>(volQuotes_[i][j]), dc, inputDisplacement_);
                } else if (inputVolatilityType_ == Normal) {
                    capFloorEngines_[i][j] =
                        QuantLib::ext::make_shared<BachelierCapFloorEngine>(discountCurve, Handle<Quote>(volQuotes_[i][j]), dc);
                } else {
                    QL_FAIL("unknown volatility type: " << volatilityType_);
                }
            }
        }
        capFlooMatrixNotInitialized_ = false;
    }
 
    for (Size j = 0; j < nStrikes_; ++j) {
        // using out-of-the-money options - but these are not always out of the money, for different tenors we may need
        // to switch
        CapFloor::Type capFloorType = strikes[j] < switchStrike_ ? CapFloor::Floor : CapFloor::Cap;
 
        // we do this with the above to keep the variables capFloors_ etc consistent, but really its the
        // optionletStdDevs_ below that we want.
        Real previousCapFloorPrice = 0.0;
        for (Size i = 0; i < nOptionletTenors_; ++i) {
 
            capFloorVols_[i][j] = termVolSurface_->volatility(capFloorLengths_[i], strikes[j], true);
            volQuotes_[i][j]->setValue(capFloorVols_[i][j]);
            capFloors_[i][j] = MakeCapFloor(capFloorType, capFloorLengths_[i], index_, strikes[j], -0 * Days)
                                   .withPricingEngine(capFloorEngines_[i][j]);
            capFloorPrices_[i][j] = capFloors_[i][j]->NPV();
            optionletPrices_[i][j] = capFloorPrices_[i][j] - previousCapFloorPrice;
            previousCapFloorPrice = capFloorPrices_[i][j];
        }
 
        // now try to strip
        std::vector<Real> optionletStrip(nOptionletTenors_);
        Real firstGuess = optionletStDevs_[0][j]; // assumes we have a constant first guess here (as we do)
        bool ok = stripOptionlets(optionletStrip, capFloorType, j, discountCurve, firstGuess);
        if (!ok) {
            // try the reverse
            capFloorType = capFloorType == CapFloor::Cap ? CapFloor::Floor : CapFloor::Cap;
            ok = stripOptionlets(optionletStrip, capFloorType, j, discountCurve, firstGuess);
            QL_REQUIRE(ok, "Failed to strip Caplet vols");
        }
        // now copy
        for (Size i = 0; i < nOptionletTenors_; ++i) {
            optionletStDevs_[i][j] = optionletStrip[i];
            optionletVolatilities_[i][j] = optionletStDevs_[i][j] / std::sqrt(optionletTimes_[i]);
        }
    }
}

Here is the call graph for this function:

◆ stripOptionlets()

bool stripOptionlets	(	std::vector< Real > &	out,
		CapFloor::Type	capFloorType,
		Size	j,
		const Handle< YieldTermStructure > &	discountCurve,
		Real	firstGuess
	)		const

private

Definition at line 137 of file optionletstripper1.cpp.

                                                                                                                 {
 
    Real strike = termVolSurface_->strikes()[j];
 
    // floor is put, cap is call
    Option::Type optionletType = capFloorType == CapFloor::Floor ? Option::Put : Option::Call;
 
    Real previousCapFloorPrice = 0.0;
    for (Size i = 0; i < nOptionletTenors_; ++i) {
 
        // we have capFloorVols_[i][j] & volQuotes_[i][j]
        CapFloor capFloor = MakeCapFloor(capFloorType, capFloorLengths_[i], index_, strike, -0 * Days)
                                .withPricingEngine(capFloorEngines_[i][j]);
        Real capFloorPrice = capFloor.NPV();
        Real optionletPrice = std::max(0.0, capFloorPrice - previousCapFloorPrice);
        previousCapFloorPrice = capFloorPrice;
 
        DiscountFactor d = discountCurve->discount(optionletPaymentDates_[i]);
        DiscountFactor optionletAnnuity = optionletAccrualPeriods_[i] * d;
        try {
            if (volatilityType_ == ShiftedLognormal) {
                out[i] = blackFormulaImpliedStdDev(optionletType, strike, atmOptionletRate_[i], optionletPrice,
                                                   optionletAnnuity, displacement_, firstGuess, accuracy_, maxIter_);
            } else if (volatilityType_ == Normal) {
                out[i] = std::sqrt(optionletTimes_[i]) *
                         bachelierBlackFormulaImpliedVol(optionletType, strike, atmOptionletRate_[i],
                                                         optionletTimes_[i], optionletPrice, optionletAnnuity);
            } else {
                QL_FAIL("Unknown target volatility type: " << volatilityType_);
            }
        } catch (std::exception& /*e*/) {
            /*
            QL_FAIL("could not bootstrap optionlet:"
                << "\n type:    " << optionletType
                << "\n strike:  " << io::rate(strike)
                << "\n atm:     " << io::rate(atmOptionletRate_[i])
                << "\n price:   " << optionletPrice << "\n annuity: " << optionletAnnuity
                << "\n expiry:  " << optionletDates_[i] << "\n error:   " << e.what());
            */
            // No need to wipe the output (?)
            return false;
        }
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ capFloorPrices_

Matrix capFloorPrices_

mutableprivate

Definition at line 69 of file optionletstripper1.hpp.

◆ optionletPrices_

Matrix optionletPrices_

private

Definition at line 69 of file optionletstripper1.hpp.

◆ capFloorVols_

Matrix capFloorVols_

mutableprivate

Definition at line 70 of file optionletstripper1.hpp.

◆ optionletStDevs_

Matrix optionletStDevs_

mutableprivate

Definition at line 71 of file optionletstripper1.hpp.

◆ capletVols_

Matrix capletVols_

private

Definition at line 71 of file optionletstripper1.hpp.

◆ capFloors_

CapFloorMatrix capFloors_

mutableprivate

Definition at line 73 of file optionletstripper1.hpp.

◆ volQuotes_

std::vector<std::vector<QuantLib::ext::shared_ptr<SimpleQuote> > > volQuotes_

mutableprivate

Definition at line 74 of file optionletstripper1.hpp.

◆ capFloorEngines_

std::vector<std::vector<QuantLib::ext::shared_ptr<PricingEngine> > > capFloorEngines_

mutableprivate

Definition at line 75 of file optionletstripper1.hpp.

◆ floatingSwitchStrike_

bool floatingSwitchStrike_

private

Definition at line 76 of file optionletstripper1.hpp.

◆ capFlooMatrixNotInitialized_

bool capFlooMatrixNotInitialized_

mutableprivate

Definition at line 77 of file optionletstripper1.hpp.

◆ switchStrike_

Rate switchStrike_

mutableprivate

Definition at line 78 of file optionletstripper1.hpp.

◆ accuracy_

Real accuracy_

private

Definition at line 79 of file optionletstripper1.hpp.

◆ maxIter_

Natural maxIter_

private

Definition at line 80 of file optionletstripper1.hpp.

◆ inputVolatilityType_

const VolatilityType inputVolatilityType_

private

Definition at line 81 of file optionletstripper1.hpp.

◆ inputDisplacement_

const Real inputDisplacement_

private

Definition at line 82 of file optionletstripper1.hpp.

Public Member Functions

LazyObject interface

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ OptionletStripper1()

Member Function Documentation

◆ capFloorPrices()

◆ capletVols()

◆ capFloorVolatilities()

◆ optionletPrices()

◆ switchStrike()

◆ discountCurve()

◆ performCalculations()

◆ stripOptionlets()

Member Data Documentation

◆ capFloorPrices_

◆ optionletPrices_

◆ capFloorVols_

◆ optionletStDevs_

◆ capletVols_

◆ capFloors_

◆ volQuotes_

◆ capFloorEngines_

◆ floatingSwitchStrike_

◆ capFlooMatrixNotInitialized_

◆ switchStrike_

◆ accuracy_

◆ maxIter_

◆ inputVolatilityType_

◆ inputDisplacement_