Abstract Spreaded Black volatility surface based on moneyness (moneyness defined in subclasses) More...

#include <qle/termstructures/spreadedblackvolatilitysurfacemoneyness.hpp>

Inheritance diagram for SpreadedBlackVolatilitySurfaceMoneyness:

Collaboration diagram for SpreadedBlackVolatilitySurfaceMoneyness:

Public Member Functions
	SpreadedBlackVolatilitySurfaceMoneyness (const Handle< BlackVolTermStructure > &referenceVol, const Handle< Quote > &movingSpot, const std::vector< Time > &times, const std::vector< Real > &moneyness, const std::vector< std::vector< Handle< Quote > > > &volSpreads, const Handle< Quote > &stickySpot, const Handle< YieldTermStructure > &stickyDividendTs, const Handle< YieldTermStructure > &stickyRiskFreeTs, const Handle< YieldTermStructure > &movingDividendTs, const Handle< YieldTermStructure > &movingRiskFreeTs, bool stickyStrike)

Date	maxDate () const override

const Date &	referenceDate () const override

Calendar	calendar () const override

Natural	settlementDays () const override

Real	minStrike () const override

Real	maxStrike () const override

void	update () override

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

Protected Member Functions
virtual Real	strikeFromMoneyness (Time t, Real moneyness, const bool stickyReference) const =0

virtual Real	moneynessFromStrike (Time t, Real strike, const bool stickyReference) const =0

Protected Attributes
Handle< BlackVolTermStructure >	referenceVol_

Handle< Quote >	movingSpot_

std::vector< Time >	times_

std::vector< Real >	moneyness_

std::vector< std::vector< Handle< Quote > > >	volSpreads_

Handle< Quote >	stickySpot_

Handle< YieldTermStructure >	stickyDividendTs_

Handle< YieldTermStructure >	stickyRiskFreeTs_

Handle< YieldTermStructure >	movingDividendTs_

Handle< YieldTermStructure >	movingRiskFreeTs_

bool	stickyStrike_

Matrix	data_

Interpolation2D	volSpreadSurface_

Private Member Functions
void	performCalculations () const override

Real	blackVolImpl (Time t, Real strike) const override

Detailed Description

Abstract Spreaded Black volatility surface based on moneyness (moneyness defined in subclasses)

Definition at line 38 of file spreadedblackvolatilitysurfacemoneyness.hpp.

Constructor & Destructor Documentation

◆ SpreadedBlackVolatilitySurfaceMoneyness()

SpreadedBlackVolatilitySurfaceMoneyness	(	const Handle< BlackVolTermStructure > &	referenceVol,
		const Handle< Quote > &	movingSpot,
		const std::vector< Time > &	times,
		const std::vector< Real > &	moneyness,
		const std::vector< std::vector< Handle< Quote > > > &	volSpreads,
		const Handle< Quote > &	stickySpot,
		const Handle< YieldTermStructure > &	stickyDividendTs,
		const Handle< YieldTermStructure > &	stickyRiskFreeTs,
		const Handle< YieldTermStructure > &	movingDividendTs,
		const Handle< YieldTermStructure > &	movingRiskFreeTs,
		bool	stickyStrike
	)

Definition at line 34 of file spreadedblackvolatilitysurfacemoneyness.cpp.

    : BlackVolatilityTermStructure(referenceVol->businessDayConvention(), referenceVol->dayCounter()),
      referenceVol_(referenceVol), movingSpot_(movingSpot), times_(times), moneyness_(moneyness),
      volSpreads_(volSpreads), stickySpot_(stickySpot), stickyDividendTs_(stickyDividendTs),
      stickyRiskFreeTs_(stickyRiskFreeTs), movingDividendTs_(movingDividendTs), movingRiskFreeTs_(movingRiskFreeTs),
      stickyStrike_(stickyStrike) {
 
    // register with observables
 
    registerWith(referenceVol_);
    registerWith(movingSpot_);
    registerWith(stickySpot_);
 
    for (auto const& v : volSpreads_)
        for (auto const& s : v)
            registerWith(s);
 
    registerWith(stickyDividendTs_);
    registerWith(stickyRiskFreeTs_);
    registerWith(movingDividendTs_);
    registerWith(movingRiskFreeTs_);
 
    // check our preconditions on the inputs
 
    QL_REQUIRE(!times_.empty(), "no times given");
    QL_REQUIRE(!moneyness_.empty(), "no moneyness values given");
    QL_REQUIRE(moneyness_.size() == volSpreads_.size(), "mismatch between moneyness vector and vol matrix rows");
 
    for (auto const& v : volSpreads_) {
        QL_REQUIRE(times_.size() == v.size(), "mismatch between times vector and vol matrix columns");
    }
 
    for (Size j = 1; j < times_.size(); ++j) {
        QL_REQUIRE(times_[j] > times_[j - 1], "Times must be sorted and unique but found that the "
                                                  << io::ordinal(j) << " time, " << times_[j]
                                                  << ", is not greater than the " << io::ordinal(j - 1) << " time, "
                                                  << times_[j - 1] << ".");
    }
 
    // add an artificial time if there is only one to make the interpolation work
 
    if (times_.size() == 1) {
        times_.push_back(times_.back() + 1.0);
        for (auto& v : volSpreads_)
            v.push_back(v.back());
    }
 
    // add an artificial moneyness if there is only one to make the interpolation work
 
    if (moneyness_.size() == 1) {
        moneyness_.push_back(moneyness_.back() + 1.0);
        volSpreads_.push_back(volSpreads_.back());
    }
 
    // create data matrix used for interpolation and the interpolation object
 
    data_ = Matrix(moneyness_.size(), times_.size(), 0.0);
    volSpreadSurface_ = FlatExtrapolator2D(QuantLib::ext::make_shared<BilinearInterpolation>(
        times_.begin(), times_.end(), moneyness_.begin(), moneyness_.end(), data_));
    volSpreadSurface_.enableExtrapolation();
}

Member Function Documentation

◆ maxDate()

Date maxDate ( ) const

override

Definition at line 101 of file spreadedblackvolatilitysurfacemoneyness.cpp.

101{ return referenceVol_->maxDate(); }

◆ referenceDate()

const Date & referenceDate ( ) const

override

Definition at line 102 of file spreadedblackvolatilitysurfacemoneyness.cpp.

102{ return referenceVol_->referenceDate(); }

◆ calendar()

Calendar calendar ( ) const

override

Definition at line 103 of file spreadedblackvolatilitysurfacemoneyness.cpp.

103{ return referenceVol_->calendar(); }

◆ settlementDays()

Natural settlementDays ( ) const

override

Definition at line 104 of file spreadedblackvolatilitysurfacemoneyness.cpp.

104{ return referenceVol_->settlementDays(); }

◆ minStrike()

Real minStrike ( ) const

override

Definition at line 105 of file spreadedblackvolatilitysurfacemoneyness.cpp.

105{ return referenceVol_->minStrike(); }

◆ maxStrike()

Real maxStrike ( ) const

override

Definition at line 106 of file spreadedblackvolatilitysurfacemoneyness.cpp.

106{ return referenceVol_->maxStrike(); }

◆ update()

void update ( )

override

Definition at line 108 of file spreadedblackvolatilitysurfacemoneyness.cpp.

                                                     {
    LazyObject::update();
    BlackVolatilityTermStructure::update();
}

◆ moneyness()

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

Definition at line 113 of file spreadedblackvolatilitysurfacemoneyness.cpp.

113{ return moneyness_; }

Here is the caller graph for this function:

◆ strikeFromMoneyness()

virtual Real strikeFromMoneyness	(	Time	t,
		Real	moneyness,
		const bool	stickyReference
	)		const

protectedpure virtual

Implemented in SpreadedBlackVolatilitySurfaceMoneynessSpot, SpreadedBlackVolatilitySurfaceMoneynessForward, SpreadedBlackVolatilitySurfaceLogMoneynessSpot, SpreadedBlackVolatilitySurfaceLogMoneynessForward, SpreadedBlackVolatilitySurfaceStdDevs, SpreadedBlackVolatilitySurfaceMoneynessSpotAbsolute, and SpreadedBlackVolatilitySurfaceMoneynessForwardAbsolute.

Here is the caller graph for this function:

◆ moneynessFromStrike()

virtual Real moneynessFromStrike	(	Time	t,
		Real	strike,
		const bool	stickyReference
	)		const

protectedpure virtual

Implemented in SpreadedBlackVolatilitySurfaceMoneynessSpot, SpreadedBlackVolatilitySurfaceMoneynessForward, SpreadedBlackVolatilitySurfaceLogMoneynessSpot, SpreadedBlackVolatilitySurfaceLogMoneynessForward, SpreadedBlackVolatilitySurfaceStdDevs, SpreadedBlackVolatilitySurfaceMoneynessSpotAbsolute, and SpreadedBlackVolatilitySurfaceMoneynessForwardAbsolute.

Here is the caller graph for this function:

◆ performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 115 of file spreadedblackvolatilitysurfacemoneyness.cpp.

                                                                        {
    for (Size j = 0; j < data_.columns(); ++j) {
        for (Size i = 0; i < data_.rows(); ++i) {
            data_(i, j) = volSpreads_[i][j]->value();
        }
    }
    volSpreadSurface_.update();
}

◆ blackVolImpl()

Real blackVolImpl	(	Time	t,
		Real	strike
	)		const

overrideprivate

Definition at line 124 of file spreadedblackvolatilitysurfacemoneyness.cpp.

                                                                                    {
    calculate();
    QL_REQUIRE(!referenceVol_.empty(), "SpreadedBlackVolatilitySurfaceMoneyness: reference vol is empty");
    Real m = moneynessFromStrike(t, strike, false);
    QL_REQUIRE(std::isfinite(m),
               "SpreadedBlackVolatilitySurfaceMoneyness: got invalid moneyness (dynamic reference) at t = "
                   << t << ", strike = " << strike << ": " << m);
    Real effStrike;
    if (stickyStrike_)
        effStrike = strike;
    else {
        effStrike = strikeFromMoneyness(t, m, true);
        QL_REQUIRE(std::isfinite(effStrike),
                   "SpreadedBlackVolatilitySurfaceMoneyness: got invalid strike from moneyness at t = "
                       << t << ", input strike = " << strike << ", moneyness = " << m);
    }
    Real m2 = moneynessFromStrike(t, strike, false);
    QL_REQUIRE(std::isfinite(m2),
               "SpreadedBlackVolatilitySurfaceMoneyness: got invalid moneyness (sticky reference) at t = "
                   << t << ", strike = " << strike << ": " << m2);
    return referenceVol_->blackVol(t, effStrike) + volSpreadSurface_(t, m2);
}