SpreadedBlackVolatilitySurfaceMoneynessSpotAbsolute Class Reference

Spreaded Black volatility surface based on absolute spot moneyness. More...

#include <qle/termstructures/spreadedblackvolatilitysurfacemoneyness.hpp>

Inheritance diagram for SpreadedBlackVolatilitySurfaceMoneynessSpotAbsolute:

Collaboration diagram for SpreadedBlackVolatilitySurfaceMoneynessSpotAbsolute:

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)
Public Member Functions inherited from 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)
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

Private Member Functions
Real	strikeFromMoneyness (Time t, Real moneyness, const bool stickyReference) const override
Real	moneynessFromStrike (Time t, Real strike, const bool stickyReference) const override

Additional Inherited Members
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 inherited from SpreadedBlackVolatilitySurfaceMoneyness
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_

Detailed Description

Spreaded Black volatility surface based on absolute spot moneyness.

Definition at line 138 of file spreadedblackvolatilitysurfacemoneyness.hpp.

Member Function Documentation

strikeFromMoneyness()

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

overrideprivatevirtual

Implements SpreadedBlackVolatilitySurfaceMoneyness.

Definition at line 340 of file spreadedblackvolatilitysurfacemoneyness.cpp.

                                                                                                                {
    QL_REQUIRE(!stickyReference || !stickySpot_.empty(),
               "SpreadedBlackVolatilitySurfaceMoneynessSpot: stickySpot is empty");
    QL_REQUIRE(stickyReference || !movingSpot_.empty(),
               "SpreadedBlackVolatilitySurfaceMoneynessSpot: movingSpot is empty");
    return moneyness + (stickyReference ? stickySpot_->value() : movingSpot_->value());
}

Here is the call graph for this function:

moneynessFromStrike()

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

overrideprivatevirtual

Implements SpreadedBlackVolatilitySurfaceMoneyness.

Definition at line 327 of file spreadedblackvolatilitysurfacemoneyness.cpp.

                                                                                                                {
    if (strike == Null<Real>() || close_enough(strike, 0.0)) {
        return 0.0;
    } else {
        QL_REQUIRE(!stickyReference || !stickySpot_.empty(),
                   "SpreadedBlackVolatilitySurfaceMoneynessSpot: stickySpot is empty");
        QL_REQUIRE(stickyReference || !movingSpot_.empty(),
                   "SpreadedBlackVolatilitySurfaceMoneynessSpot: movingSpot is empty");
        return strike - (stickyReference ? stickySpot_->value() : movingSpot_->value());
    }
}

Here is the call graph for this function:

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 43 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();
}