SpreadedBlackVolatilitySurfaceMoneynessForward Class Reference

Black volatility surface based on forward moneyness. More...

#include <qle/termstructures/spreadedblackvolatilitysurfacemoneyness.hpp>

Inheritance diagram for SpreadedBlackVolatilitySurfaceMoneynessForward:

Collaboration diagram for SpreadedBlackVolatilitySurfaceMoneynessForward:

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

Black volatility surface based on forward moneyness.

Definition at line 98 of file spreadedblackvolatilitysurfacemoneyness.hpp.

Member Function Documentation

strikeFromMoneyness()

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

overrideprivatevirtual

Implements SpreadedBlackVolatilitySurfaceMoneyness.

Definition at line 216 of file spreadedblackvolatilitysurfacemoneyness.cpp.

                                                                                                           {
    Real forward;
    if (stickyReference) {
        QL_REQUIRE(!stickySpot_.empty(), "SpreadedBlackVolatilitySurfaceMoneynessForward: stickySpot is empty");
        QL_REQUIRE(!stickyDividendTs_.empty(),
                   "SpreadedBlackVolatilitySurfaceMoneynessForward: stickyDividendTs is empty");
        QL_REQUIRE(!stickyRiskFreeTs_.empty(),
                   "SpreadedBlackVolatilitySurfaceMoneynessForward: stickyRiskFreeTs is empty");
        forward = stickySpot_->value() * stickyDividendTs_->discount(t) / stickyRiskFreeTs_->discount(t);
    } else {
        QL_REQUIRE(!movingSpot_.empty(), "SpreadedBlackVolatilitySurfaceMoneynessForward: movingSpot is empty");
        QL_REQUIRE(!movingDividendTs_.empty(),
                   "SpreadedBlackVolatilitySurfaceMoneynessForward: movingDividendTs is empty");
        QL_REQUIRE(!movingRiskFreeTs_.empty(),
                   "SpreadedBlackVolatilitySurfaceMoneynessForward: mocingRiskFreeTs is empty");
        forward = movingSpot_->value() * movingDividendTs_->discount(t) / movingRiskFreeTs_->discount(t);
    }
    return moneyness * forward;
}

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 191 of file spreadedblackvolatilitysurfacemoneyness.cpp.

                                                                                                           {
    if (strike == Null<Real>() || close_enough(strike, 0.0))
        return 1.0;
    else {
        Real forward;
        if (stickyReference) {
            QL_REQUIRE(!stickySpot_.empty(), "SpreadedBlackVolatilitySurfaceMoneynessForward: stickySpot is empty");
            QL_REQUIRE(!stickyDividendTs_.empty(),
                       "SpreadedBlackVolatilitySurfaceMoneynessForward: stickyDividendTs is empty");
            QL_REQUIRE(!stickyRiskFreeTs_.empty(),
                       "SpreadedBlackVolatilitySurfaceMoneynessForward: stickyRiskFreeTs is empty");
            forward = stickySpot_->value() * stickyDividendTs_->discount(t) / stickyRiskFreeTs_->discount(t);
        } else {
            QL_REQUIRE(!movingSpot_.empty(), "SpreadedBlackVolatilitySurfaceMoneynessForward: movingSpot is empty");
            QL_REQUIRE(!movingDividendTs_.empty(),
                       "SpreadedBlackVolatilitySurfaceMoneynessForward: movingDividendTs is empty");
            QL_REQUIRE(!movingRiskFreeTs_.empty(),
                       "SpreadedBlackVolatilitySurfaceMoneynessForward: mocingRiskFreeTs is empty");
            forward = movingSpot_->value() * movingDividendTs_->discount(t) / movingRiskFreeTs_->discount(t);
        }
        return strike / forward;
    }
}

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