Stripped zero inflation volatility structure. More...

#include <qle/termstructures/strippedcpivolatilitystructure.hpp>

Inheritance diagram for StrippedCPIVolatilitySurface< Interpolator2D >:

Collaboration diagram for StrippedCPIVolatilitySurface< Interpolator2D >:

Classes
class	ObjectiveFunction

Public Member Functions
QL_DEPRECATED	StrippedCPIVolatilitySurface (PriceQuotePreference type, const QuantLib::Handle< QuantLib::CPICapFloorTermPriceSurface > &priceSurface, const QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex > &zeroIndex, const QuantLib::ext::shared_ptr< QuantExt::CPICapFloorEngine > &engine, const QuantLib::Date &capFloorStartDate=Date(), const QuantLib::Real &upperVolBound=StrippedCPIVolSurfaceDefaultValues::upperVolBound, const QuantLib::Real &lowerVolBound=StrippedCPIVolSurfaceDefaultValues::lowerVolBound, const QuantLib::Real &solverTolerance=StrippedCPIVolSurfaceDefaultValues::solverTolerance, const Interpolator2D &interpolator2d=Interpolator2D(), const QuantLib::VolatilityType &volType=QuantLib::ShiftedLognormal, const double displacement=0.0)

	StrippedCPIVolatilitySurface (PriceQuotePreference type, const QuantLib::Handle< QuantLib::CPICapFloorTermPriceSurface > &priceSurface, const QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex > &zeroIndex, const bool quotedPricesUseInterpolatedCPIFixings, const QuantLib::ext::shared_ptr< QuantExt::CPICapFloorEngine > &engine, const QuantLib::Date &capFloorStartDate=Date(), const QuantLib::Real &upperVolBound=StrippedCPIVolSurfaceDefaultValues::upperVolBound, const QuantLib::Real &lowerVolBound=StrippedCPIVolSurfaceDefaultValues::lowerVolBound, const QuantLib::Real &solverTolerance=StrippedCPIVolSurfaceDefaultValues::solverTolerance, const Interpolator2D &interpolator2d=Interpolator2D(), const QuantLib::VolatilityType &volType=QuantLib::ShiftedLognormal, const double displacement=0.0)

LazyObject interface
void	performCalculations () const

Limits
QuantLib::Real	minStrike () const override
	the minimum strike for which the term structure can return vols More...

QuantLib::Real	maxStrike () const override
	the maximum strike for which the term structure can return vols More...

QuantLib::Date	maxDate () const override
	maximum date for which the term structure can return vols More...

Public Member Functions inherited from CPIVolatilitySurface
	CPIVolatilitySurface (QuantLib::Natural settlementDays, const QuantLib::Calendar &, QuantLib::BusinessDayConvention bdc, const QuantLib::DayCounter &dc, const QuantLib::Period &observationLag, QuantLib::Frequency frequency, bool indexIsInterpolated, const QuantLib::Date &capFloorStartDate=QuantLib::Date(), QuantLib::VolatilityType volType=QuantLib::ShiftedLognormal, double displacement=0.0)

QuantLib::Date	optionDateFromTenor (const QuantLib::Period &tenor) const override
	Computes the expiry date from the capFloorStartDate() More...

QuantLib::Date	baseDate () const override
	base date will be in the past More...

QuantLib::VolatilityType	volatilityType () const
	Returns the volatility type. More...

double	displacement () const
	Returns the displacement for lognormal volatilities. More...

bool	isLogNormal () const

QuantLib::Volatility	volatility (const QuantLib::Date &maturityDate, QuantLib::Rate strike, const QuantLib::Period &obsLag=QuantLib::Period(-1, QuantLib::Days), bool extrapolate=false) const override

virtual QuantLib::Real	atmStrike (const QuantLib::Date &maturity, const QuantLib::Period &obsLag=QuantLib::Period(-1, QuantLib::Days)) const =0

QuantLib::Date	capFloorStartDate () const

Inspectors
PriceQuotePreference	preference_

QuantLib::Handle< QuantLib::CPICapFloorTermPriceSurface >	priceSurface_

QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex >	index_

QuantLib::ext::shared_ptr< QuantExt::CPICapFloorEngine >	engine_

QuantLib::Real	upperVolBound_

QuantLib::Real	lowerVolBound_

QuantLib::Real	solverTolerance_

std::vector< QuantLib::Rate >	strikes_

std::vector< QuantLib::Period >	maturities_

std::vector< QuantLib::Time >	maturityTimes_

QuantLib::Matrix	volData_

Interpolator2D	interpolator2d_

QuantLib::Interpolation2D	vols_

bool	computeTimeToExpiryFromLastAvailableFixingDate_

const std::vector< QuantLib::Real > &	strikes ()

const std::vector< QuantLib::Period > &	maturities ()

const QuantLib::Matrix &	volData ()

QuantLib::Real	atmStrike (const QuantLib::Date &maturity, const QuantLib::Period &obsLag=QuantLib::Period(-1, QuantLib::Days)) const override

QuantLib::Volatility	volatilityImpl (QuantLib::Time length, QuantLib::Rate strike) const override

bool	chooseFloor (QuantLib::Real strike, QuantLib::Real atmRate) const

Additional Inherited Members
Protected Member Functions inherited from CPIVolatilitySurface
virtual double	fixingTime (const QuantLib::Date &maturityDate) const
	Computes the expiry time from the capFloorStartDate() More...

Protected Attributes inherited from CPIVolatilitySurface
QuantLib::VolatilityType	volType_

double	displacement_

Detailed Description

template<class Interpolator2D>
class QuantExt::StrippedCPIVolatilitySurface< Interpolator2D >

Stripped zero inflation volatility structure.

The surface provides implied CPI Black volatilities for the union of strikes that occur in the underlying cap and floor price surface.

The type argument determines which kind of price quotes are used with priority when there is an overlap, i.e. strikes for which we have both cap and floor quotes: If type is Cap: Use cap quotes where available, floor quotes otherwise If type is Floor: Use floor quotes where available, cap quotes otherwise If type is CapFloor: In case of overlap, use floor quotes up to the ATM strike, cap quotes for strikes beyond ATM

Definition at line 60 of file strippedcpivolatilitystructure.hpp.

Constructor & Destructor Documentation

◆ StrippedCPIVolatilitySurface() [1/2]

QL_DEPRECATED_DISABLE_WARNING StrippedCPIVolatilitySurface	(	PriceQuotePreference	type,
		const QuantLib::Handle< QuantLib::CPICapFloorTermPriceSurface > &	priceSurface,
		const QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex > &	zeroIndex,
		const QuantLib::ext::shared_ptr< QuantExt::CPICapFloorEngine > &	engine,
		const QuantLib::Date &	capFloorStartDate = `Date()`,
		const QuantLib::Real &	upperVolBound = `StrippedCPIVolSurfaceDefaultValues::upperVolBound`,
		const QuantLib::Real &	lowerVolBound = `StrippedCPIVolSurfaceDefaultValues::lowerVolBound`,
		const QuantLib::Real &	solverTolerance = `StrippedCPIVolSurfaceDefaultValues::solverTolerance`,
		const Interpolator2D &	interpolator2d = `Interpolator2D()`,
		const QuantLib::VolatilityType &	volType = `QuantLib::ShiftedLognormal`,
		const double	displacement = `0.0`
	)

Definition at line 182 of file strippedcpivolatilitystructure.hpp.

    : StrippedCPIVolatilitySurface<Interpolator2D>::StrippedCPIVolatilitySurface(
          type, priceSurface, index, index->interpolated(), engine, capFloorStartDate, upperVolBound, lowerVolBound,
          solverTolerance, interpolator2d, volType, displacement) {}

◆ StrippedCPIVolatilitySurface() [2/2]

StrippedCPIVolatilitySurface	(	PriceQuotePreference	type,
		const QuantLib::Handle< QuantLib::CPICapFloorTermPriceSurface > &	priceSurface,
		const QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex > &	zeroIndex,
		const bool	quotedPricesUseInterpolatedCPIFixings,
		const QuantLib::ext::shared_ptr< QuantExt::CPICapFloorEngine > &	engine,
		const QuantLib::Date &	capFloorStartDate = `Date()`,
		const QuantLib::Real &	upperVolBound = `StrippedCPIVolSurfaceDefaultValues::upperVolBound`,
		const QuantLib::Real &	lowerVolBound = `StrippedCPIVolSurfaceDefaultValues::lowerVolBound`,
		const QuantLib::Real &	solverTolerance = `StrippedCPIVolSurfaceDefaultValues::solverTolerance`,
		const Interpolator2D &	interpolator2d = `Interpolator2D()`,
		const QuantLib::VolatilityType &	volType = `QuantLib::ShiftedLognormal`,
		const double	displacement = `0.0`
	)

Definition at line 161 of file strippedcpivolatilitystructure.hpp.

    : QuantExt::CPIVolatilitySurface(priceSurface->settlementDays(), priceSurface->calendar(),
                                     priceSurface->businessDayConvention(), priceSurface->dayCounter(),
                                     priceSurface->observationLag(), index->frequency(),
                                     quotedPriceUseInterpolatedCPIFixing,
                                     capFloorStartDate, volType, displacement),
      preference_(type), priceSurface_(priceSurface), index_(index), engine_(engine), upperVolBound_(upperVolBound),
      lowerVolBound_(lowerVolBound), solverTolerance_(solverTolerance), interpolator2d_(interpolator2d) {
 
    performCalculations();
}

Here is the call graph for this function:

Member Function Documentation

◆ performCalculations()

QL_DEPRECATED_ENABLE_WARNING void performCalculations

Definition at line 194 of file strippedcpivolatilitystructure.hpp.

                                                                                                             {
    strikes_ = priceSurface_->strikes();
    maturities_ = priceSurface_->maturities();
    volData_ = QuantLib::Matrix(strikes_.size(), maturities_.size(), QuantLib::Null<QuantLib::Real>());
    QuantLib::Brent solver;
    QuantLib::Real guess = (upperVolBound_ + lowerVolBound_) / 2.0;
    QuantLib::Date startDate = capFloorStartDate();
    QuantLib::Date underlyingBaseDate =
        ZeroInflation::fixingDate(startDate, observationLag(), frequency(), indexIsInterpolated());
    double baseCPI = ZeroInflation::cpiFixing(index_, startDate, observationLag(), indexIsInterpolated());
    for (QuantLib::Size i = 0; i < strikes_.size(); i++) {
        for (QuantLib::Size j = 0; j < maturities_.size(); j++) {
 
            QuantLib::Date maturityDate = optionDateFromTenor(maturities_[j]);
            QuantLib::Date fixDate =
                ZeroInflation::fixingDate(maturityDate, observationLag(), frequency(), indexIsInterpolated());
            Rate I1 = ZeroInflation::cpiFixing(index_, maturityDate, observationLag(), indexIsInterpolated());
 
            Time timeToMaturity = dayCounter().yearFraction(underlyingBaseDate, fixDate);
            QuantLib::Real atmRate = std::pow(I1 / baseCPI, 1 / timeToMaturity) - 1.0;
 
            bool useFloor = chooseFloor(strikes_[i], atmRate);
 
            // FIXME: Do we need an effective maturity here ?
            QuantLib::Real priceToMatch = useFloor ? priceSurface_->floorPrice(maturities_[j], strikes_[i])
                                                   : priceSurface_->capPrice(maturities_[j], strikes_[i]);
            try {
                auto interpolationType =
                    indexIsInterpolated() ? CPI::InterpolationType::Linear : CPI::InterpolationType::Flat;
                ObjectiveFunction func(priceToMatch, useFloor, strikes_[i], startDate, maturityDate, baseCPI,
                                       priceSurface_, index_, engine_, interpolationType);
                QuantLib::Real found = solver.solve(func, solverTolerance_, guess, lowerVolBound_, upperVolBound_);
                volData_[i][j] = found;
            } catch (std::exception& e) {
                QL_FAIL("failed to find implied vol for "
                        << (useFloor ? "Floor" : "Cap") << " with strike " << strikes_[i] << " and maturity "
                        << maturities_[j] << ", because: " << e.what() << " "
                        << QuantLib::io::iso_date(startDate + maturities_[j]) << " " << maturityDate);
            }
        }
    }
 
    maturityTimes_.clear();
    for (QuantLib::Size i = 0; i < maturities_.size(); i++) {
        QuantLib::Date d = optionDateFromTenor(maturities_[i]);
        maturityTimes_.push_back(fixingTime(d));
    }
 
    vols_ = interpolator2d_.interpolate(maturityTimes_.begin(), maturityTimes_.end(), strikes_.begin(), strikes_.end(),
                                        volData_);
    vols_.enableExtrapolation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minStrike()

QuantLib::Real minStrike

override

the minimum strike for which the term structure can return vols

Definition at line 295 of file strippedcpivolatilitystructure.hpp.

                                                                                                           {
    return strikes_.front() - QL_EPSILON;
}

◆ maxStrike()

QuantLib::Real maxStrike

override

the maximum strike for which the term structure can return vols

Definition at line 299 of file strippedcpivolatilitystructure.hpp.

                                                                                                           {
    return strikes_.back() + QL_EPSILON;
}

◆ maxDate()

QuantLib::Date maxDate

override

maximum date for which the term structure can return vols

Definition at line 303 of file strippedcpivolatilitystructure.hpp.

                                                                                                         {
    QuantLib::Date today = QuantLib::Settings::instance().evaluationDate();
    return today + maturities_.back();
}

◆ strikes()

const std::vector< QuantLib::Real > & strikes ( )

Definition at line 104 of file strippedcpivolatilitystructure.hpp.

104{ return strikes_; }

◆ maturities()

const std::vector< QuantLib::Period > & maturities ( )

Definition at line 105 of file strippedcpivolatilitystructure.hpp.

105{ return maturities_; }

◆ volData()

const QuantLib::Matrix & volData ( )

Definition at line 106 of file strippedcpivolatilitystructure.hpp.

106{ return volData_; }

◆ atmStrike()

QuantLib::Real atmStrike	(	const QuantLib::Date &	maturity,
		const QuantLib::Period &	obsLag = `QuantLib::Period(-1, QuantLib::Days)`
	)		const

overridevirtual

Implements CPIVolatilitySurface.

Definition at line 357 of file strippedcpivolatilitystructure.hpp.

                                                                                                               {
    QuantLib::Period lag = obsLag == -1 * QuantLib::Days ? observationLag() : obsLag;
    QuantLib::Date fixingDate = ZeroInflation::fixingDate(maturity, lag, frequency(), indexIsInterpolated());
    double forwardCPI = ZeroInflation::cpiFixing(index_, maturity, lag, indexIsInterpolated());
    double baseCPI = ZeroInflation::cpiFixing(index_, capFloorStartDate(), observationLag(), indexIsInterpolated());
    double atm = forwardCPI / baseCPI;
    double ttm =
        QuantLib::inflationYearFraction(frequency(), indexIsInterpolated(), dayCounter(), baseDate(), fixingDate);
    return std::pow(atm, 1.0 / ttm) - 1.0;
}

Here is the call graph for this function:

◆ volatilityImpl()

QuantLib::Volatility volatilityImpl	(	QuantLib::Time	length,
		QuantLib::Rate	strike
	)		const

overrideprivate

Definition at line 309 of file strippedcpivolatilitystructure.hpp.

                                                                                                             {
    return vols_(length, strike);
}

◆ chooseFloor()

bool chooseFloor	(	QuantLib::Real	strike,
		QuantLib::Real	atmRate
	)		const

private

Definition at line 248 of file strippedcpivolatilitystructure.hpp.

                                                                                                              {
    if (preference_ == Floor) {
        if (strike <= priceSurface_->floorStrikes().back())
            return true;
        else
            return false;
    }
 
    if (preference_ == Cap) {
        if (strike < priceSurface_->capStrikes().front())
            return true;
        else
            return false;
    }
 
    // else: Use floors where we have floor quotes only, caps where we have cap quotes only,
    // and decide based on ATM where we have both cap and floor quotes
 
    // 1) strike < maxFloorStrike < minCapStrike: Floor!
    if (strike <= priceSurface_->floorStrikes().back() && strike < priceSurface_->capStrikes().front())
        return true;
    // 2) strike > maxFloorStrike and strike >= minCapStrike: Cap!
    else if (strike > priceSurface_->floorStrikes().back() && strike >= priceSurface_->capStrikes().front())
        return false;
    // 3) Overlap, maxFloorStrike > minCapStrike and strike in between: Depends on atmRate which surface we pick
    else if (strike <= priceSurface_->floorStrikes().back() && strike >= priceSurface_->capStrikes().front()) {
        // we have overlapping strikes, decide depending on atm level
        if (strike < atmRate)
            return true;
        else
            return false;
        // 4) Gap, maxFloorStrike < minCapStrike and strike in the gap: Depends on atmRate which surface we
        // extrapolate
    } else if (strike > priceSurface_->floorStrikes().back() && strike < priceSurface_->capStrikes().front()) {
        // there is a gap between floor end and caps begin, decide again depending on strike level
        if (strike < atmRate)
            return true;
        else
            return false;
    } else {
        QL_FAIL("case not covered in  StrippedCPIVolatilitySurface: strike="
                << strike << " maxFloorStrike=" << priceSurface_->floorStrikes().back()
                << " minCapStrike=" << priceSurface_->capStrikes().front() << " atm=" << atmRate);
        return false;
    }
}