StrippedOptionletAdapter< TimeInterpolator, SmileInterpolator > Class Template Reference

#include <qle/termstructures/strippedoptionletadapter.hpp>

Inheritance diagram for StrippedOptionletAdapter< TimeInterpolator, SmileInterpolator >:

Collaboration diagram for StrippedOptionletAdapter< TimeInterpolator, SmileInterpolator >:

Public Member Functions
	StrippedOptionletAdapter (const QuantLib::ext::shared_ptr< QuantLib::StrippedOptionletBase > &sob, const TimeInterpolator &ti=TimeInterpolator(), const SmileInterpolator &si=SmileInterpolator())
	StrippedOptionletAdapter (const QuantLib::Date &referenceDate, const QuantLib::ext::shared_ptr< QuantLib::StrippedOptionletBase > &sob, const TimeInterpolator &ti=TimeInterpolator(), const SmileInterpolator &si=SmileInterpolator())
TermStructure interface
QuantLib::Date	maxDate () const override
VolatilityTermStructure interface
QuantLib::Rate	minStrike () const override
QuantLib::Rate	maxStrike () const override
LazyObject interface
void	update () override
void	performCalculations () const override
Observer interface
void	deepUpdate () override
Inspectors
QuantLib::ext::shared_ptr< QuantLib::StrippedOptionletBase >	optionletBase () const

OptionletVolatilityStructure interface
QuantLib::ext::shared_ptr< QuantLib::StrippedOptionletBase >	optionletBase_
	Base optionlet object that provides the stripped optionlet volatilities. More...
TimeInterpolator	ti_
	The interpolation object in the time direction. More...
SmileInterpolator	si_
	The interpolation object in the strike direction. More...
std::vector< QuantLib::Interpolation >	strikeSections_
bool	oneStrike_
	Flag that indicates if optionletBase_ has only one strike for all option tenors. More...
QuantLib::VolatilityType	volatilityType () const override
QuantLib::Real	displacement () const override
QuantLib::ext::shared_ptr< QuantLib::SmileSection >	smileSectionImpl (QuantLib::Time optionTime) const override
QuantLib::Volatility	volatilityImpl (QuantLib::Time length, QuantLib::Rate strike) const override
void	populateOneStrike ()
	Method to populate oneStrike_ on initialisation. More...

Detailed Description

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

Adapter class for turning a StrippedOptionletBase into an OptionletVolatilityStructure.

The class takes two template parameters indicating the interpolation in the time and strike direction respectively.

The class can take a QuantLib::StrippedOptionletBase that has only one strike column. In this case, the strike interpolation is ignored and the volatility at one of the pillar tenors, and any strike, is merely the passed in volatility. In this case, the smile sections are flat. All of this enables the StrippedOptionletAdapter to represent a stripped ATM optionlet curve. The single strike in the QuantLib::StrippedOptionletBase is ignored.

Definition at line 51 of file strippedoptionletadapter.hpp.

Constructor & Destructor Documentation

StrippedOptionletAdapter() [1/2]

StrippedOptionletAdapter	(	const QuantLib::ext::shared_ptr< QuantLib::StrippedOptionletBase > &	sob,
		const TimeInterpolator &	ti = TimeInterpolator(),
		const SmileInterpolator &	si = SmileInterpolator()
	)

Constructor that does not take a reference date. The settlement days is derived from sob and the term structure will be a moving term structure.

Definition at line 131 of file strippedoptionletadapter.hpp.

    : OptionletVolatilityStructure(sob->settlementDays(), sob->calendar(), sob->businessDayConvention(),
                                   sob->dayCounter()),
      optionletBase_(sob), ti_(ti), si_(si), strikeSections_(optionletBase_->optionletMaturities()) {
    registerWith(optionletBase_);
    populateOneStrike();
}

Here is the call graph for this function:

StrippedOptionletAdapter() [2/2]

StrippedOptionletAdapter	(	const QuantLib::Date &	referenceDate,
		const QuantLib::ext::shared_ptr< QuantLib::StrippedOptionletBase > &	sob,
		const TimeInterpolator &	ti = TimeInterpolator(),
		const SmileInterpolator &	si = SmileInterpolator()
	)

Constructor taking an explicit referenceDate and the term structure will therefore be not moving.

Definition at line 142 of file strippedoptionletadapter.hpp.

    : OptionletVolatilityStructure(referenceDate, sob->calendar(), sob->businessDayConvention(), sob->dayCounter()),
      optionletBase_(sob), ti_(ti), si_(si), strikeSections_(optionletBase_->optionletMaturities()) {
    registerWith(optionletBase_);
    populateOneStrike();
}

Here is the call graph for this function:

Member Function Documentation

maxDate()

QuantLib::Date maxDate

override

Definition at line 152 of file strippedoptionletadapter.hpp.

                                                                                                 {
    return optionletBase_->optionletFixingDates().back();
}

minStrike()

QuantLib::Rate minStrike

override

Definition at line 157 of file strippedoptionletadapter.hpp.

                                                                                                   {
 
    // If only one strike
    if (oneStrike_) {
        if (volatilityType() == QuantLib::ShiftedLognormal) {
            return displacement() > 0.0 ? -displacement() : 0.0;
        } else {
            return QL_MIN_REAL;
        }
    }
 
    // Return the minimum strike over all optionlet tenors
    QuantLib::Rate minStrike = optionletBase_->optionletStrikes(0).front();
    for (QuantLib::Size i = 1; i < optionletBase_->optionletMaturities(); ++i) {
        minStrike = std::min(optionletBase_->optionletStrikes(i).front(), minStrike);
    }
    return minStrike;
}

maxStrike()

QuantLib::Rate maxStrike

override

Definition at line 177 of file strippedoptionletadapter.hpp.

                                                                                                   {
 
    // If only one strike, there is no max strike
    if (oneStrike_) {
        return QL_MAX_REAL;
    }
 
    // Return the maximum strike over all optionlet tenors
    QuantLib::Rate maxStrike = optionletBase_->optionletStrikes(0).back();
    for (QuantLib::Size i = 1; i < optionletBase_->optionletMaturities(); ++i) {
        maxStrike = std::max(optionletBase_->optionletStrikes(i).back(), maxStrike);
    }
    return maxStrike;
}

volatilityType()

QuantLib::VolatilityType volatilityType

override

Definition at line 193 of file strippedoptionletadapter.hpp.

                                                                                                                  {
    return optionletBase_->volatilityType();
}

displacement()

QuantLib::Real displacement

override

Definition at line 198 of file strippedoptionletadapter.hpp.

                                                                                                      {
    return optionletBase_->displacement();
}

update()

void update

override

Definition at line 203 of file strippedoptionletadapter.hpp.

                                                                                  {
 
    // Need this or some tests with ObservationMode::Mode::Disable fail
    // e.g. */SensitivityAnalysisTest/testPortfolioSensitivityDisableObs
    optionletBase_->update();
 
    TermStructure::update();
    LazyObject::update();
}

performCalculations()

void performCalculations

override

Definition at line 214 of file strippedoptionletadapter.hpp.

                                                                                                     {
 
    // Some localised typedefs and using declarations to make the code more readable
    using QuantLib::Rate;
    using QuantLib::Size;
    using QuantLib::Volatility;
    using std::vector;
 
    // If only one strike, no strike section to update
    if (oneStrike_) {
        return;
    }
 
    for (Size i = 0; i < optionletBase_->optionletMaturities(); ++i) {
        const vector<Rate>& strikes = optionletBase_->optionletStrikes(i);
        const vector<Volatility>& vols = optionletBase_->optionletVolatilities(i);
        strikeSections_[i] = si_.interpolate(strikes.begin(), strikes.end(), vols.begin());
        // Extrapolation can be enabled here. Range checks are performed in the volatility methods.
        strikeSections_[i].enableExtrapolation();
    }
}

deepUpdate()

void deepUpdate

override

Definition at line 237 of file strippedoptionletadapter.hpp.

                                                                                      {
    optionletBase_->update();
    update();
}

optionletBase()

QuantLib::ext::shared_ptr< QuantLib::StrippedOptionletBase > optionletBase

Definition at line 244 of file strippedoptionletadapter.hpp.

                                                                                   {
    return optionletBase_;
}

smileSectionImpl()

QuantLib::ext::shared_ptr< QuantLib::SmileSection > smileSectionImpl ( QuantLib::Time  optionTime ) const

overrideprotected

Definition at line 250 of file strippedoptionletadapter.hpp.

                                                                                                             {
 
    // Some localised typedefs and using declarations to make the code more readable
    using QuantLib::Null;
    using QuantLib::Rate;
    using QuantLib::Real;
    using QuantLib::Size;
    using QuantLib::Volatility;
    using QuantLib::io::ordinal;
    using std::equal;
    using std::sqrt;
    using std::vector;
 
    // Leave ATM rate as Null<Real>() for now but could interpolate optionletBase_->atmOptionletRates()?
    Real atmRate = Null<Real>();
 
    // If one strike, return a flat smile section
    if (oneStrike_) {
        Volatility vol = volatility(optionTime, optionletBase_->optionletStrikes(0)[0], true);
        return QuantLib::ext::make_shared<QuantLib::FlatSmileSection>(optionTime, vol, optionletBase_->dayCounter(), atmRate,
                                                              volatilityType(), displacement());
    }
 
    /* we choose the strikes from the first fixing time for interpolation
       - if only fixed strikes are used, they are the same for all times anyway
       - if atm is used in addition, the first time's strikes are a superset of all others, i.e. the densest */
    const vector<Rate>& strikes = optionletBase_->optionletStrikes(0);
 
    // Store standard deviation at each strike
    vector<Real> stdDevs;
    for (Size i = 0; i < strikes.size(); i++) {
        stdDevs.push_back(sqrt(blackVariance(optionTime, strikes[i], true)));
    }
 
    // Return the smile section.
    return QuantLib::ext::make_shared<QuantLib::InterpolatedSmileSection<SmileInterpolator> >(
        optionTime, strikes, stdDevs, atmRate, si_, optionletBase_->dayCounter(), volatilityType(), displacement());
}

Here is the call graph for this function:

volatilityImpl()

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

overrideprotected

Definition at line 291 of file strippedoptionletadapter.hpp.

                                                                                                         {
 
    // Some localised typedefs and using declarations to make the code more readable
    using QuantLib::Interpolation;
    using QuantLib::Size;
    using QuantLib::Time;
    using QuantLib::Volatility;
    using std::vector;
 
    calculate();
 
    vector<Volatility> vols(optionletBase_->optionletMaturities());
    for (Size i = 0; i < optionletBase_->optionletMaturities(); ++i) {
        vols[i] = oneStrike_ ? optionletBase_->optionletVolatilities(i)[0] : strikeSections_[i](strike);
    }
 
    vector<Time> fixingTimes = optionletBase_->optionletFixingTimes();
    Interpolation ti = ti_.interpolate(fixingTimes.begin(), fixingTimes.end(), vols.begin());
 
    // Extrapolation can be enabled at this level. The range checks will have already been performed in
    // the public OptionletVolatilityStructure::volatility method that calls this `Impl`
    ti.enableExtrapolation();
 
    return ti(optionTime);
}

populateOneStrike()

void populateOneStrike

private

Method to populate oneStrike_ on initialisation.

Definition at line 319 of file strippedoptionletadapter.hpp.

                                                                                             {
    oneStrike_ = true;
    for (QuantLib::Size i = 0; i < optionletBase_->optionletMaturities(); ++i) {
        if (optionletBase_->optionletStrikes(i).size() > 1) {
            oneStrike_ = false;
            return;
        }
    }
}

Here is the caller graph for this function:

Member Data Documentation

optionletBase_

QuantLib::ext::shared_ptr<QuantLib::StrippedOptionletBase> optionletBase_

private

Base optionlet object that provides the stripped optionlet volatilities.

Definition at line 110 of file strippedoptionletadapter.hpp.

ti_

TimeInterpolator ti_

private

The interpolation object in the time direction.

Definition at line 113 of file strippedoptionletadapter.hpp.

si_

SmileInterpolator si_

private

The interpolation object in the strike direction.

Definition at line 116 of file strippedoptionletadapter.hpp.

strikeSections_

std::vector<QuantLib::Interpolation> strikeSections_

mutableprivate

The optionlet volatility vs strike section at each optionlet fixing date It is mutable so that we can call enableExtrapolation in performCalculations.

Definition at line 121 of file strippedoptionletadapter.hpp.

oneStrike_

bool oneStrike_

private

Flag that indicates if optionletBase_ has only one strike for all option tenors.

Definition at line 124 of file strippedoptionletadapter.hpp.