Black volatility surface based on std devs (standardised log moneyness) More...

#include <qle/termstructures/spreadedblackvolatilitysurfacemoneyness.hpp>

Inheritance diagram for SpreadedBlackVolatilitySurfaceStdDevs:

Collaboration diagram for SpreadedBlackVolatilitySurfaceStdDevs:

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 std devs (standardised log moneyness)

Definition at line 128 of file spreadedblackvolatilitysurfacemoneyness.hpp.

Member Function Documentation

◆ strikeFromMoneyness()

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

overrideprivatevirtual

Implements SpreadedBlackVolatilitySurfaceMoneyness.

Definition at line 308 of file spreadedblackvolatilitysurfacemoneyness.cpp.

                                                                                                  {
    Real stickyForward = stickySpot_->value() * stickyDividendTs_->discount(t) / stickyRiskFreeTs_->discount(t);
    Real forward;
    if (stickyReference) {
        forward = stickyForward;
    } else {
        QL_REQUIRE(!movingSpot_.empty(), "SpreadedBlackVolatilitySurfaceStdDevs: movingSpot is empty");
        QL_REQUIRE(!movingDividendTs_.empty(), "SpreadedBlackVolatilitySurfaceStdDevs: movingDividendTs is empty");
        QL_REQUIRE(!movingRiskFreeTs_.empty(), "SpreadedBlackVolatilitySurfaceStdDevs: mocingRiskFreeTs is empty");
        forward = movingSpot_->value() * movingDividendTs_->discount(t) / movingRiskFreeTs_->discount(t);
    }
    // We use the sticky forward to read the vol for the definition of the standardised moneyness to
    // avoid that this changes under forward curve changes. In the end this is a matter of definition and
    // we might want to revise this later.
    Real vol = referenceVol_->blackVol(t, stickyForward);
    return std::exp(moneyness * vol * std::sqrt(t)) * 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 283 of file spreadedblackvolatilitysurfacemoneyness.cpp.

                                                                                                                     {
    if (strike == Null<Real>() || close_enough(strike, 0.0) || close_enough(t, 0.0))
        return 0.0;
    else {
        QL_REQUIRE(!stickySpot_.empty(), "SpreadedBlackVolatilitySurfaceStdDevs: stickySpot is empty");
        QL_REQUIRE(!stickyDividendTs_.empty(), "SpreadedBlackVolatilitySurfaceStdDevs: stickyDividendTs is empty");
        QL_REQUIRE(!stickyRiskFreeTs_.empty(), "SpreadedBlackVolatilitySurfaceStdDevs: stickyRiskFreeTs is empty");
        Real stickyForward = stickySpot_->value() * stickyDividendTs_->discount(t) / stickyRiskFreeTs_->discount(t);
        Real forward;
        if (stickyReference) {
            forward = stickyForward;
        } else {
            QL_REQUIRE(!movingSpot_.empty(), "SpreadedBlackVolatilitySurfaceStdDevs: movingSpot is empty");
            QL_REQUIRE(!movingDividendTs_.empty(), "SpreadedBlackVolatilitySurfaceStdDevs: movingDividendTs is empty");
            QL_REQUIRE(!movingRiskFreeTs_.empty(), "SpreadedBlackVolatilitySurfaceStdDevs: mocingRiskFreeTs is empty");
            forward = movingSpot_->value() * movingDividendTs_->discount(t) / movingRiskFreeTs_->discount(t);
        }
        // We use the sticky forward to read the vol for the definition of the standardised moneyness to
        // avoid that this changes under forward curve changes. In the end this is a matter of definition and
        // we might want to revise this later.
        Real vol = referenceVol_->blackVol(t, stickyForward);
        return std::log(strike / forward) / (vol * std::sqrt(t));
    }
}

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

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ strikeFromMoneyness()

◆ moneynessFromStrike()

◆ SpreadedBlackVolatilitySurfaceMoneyness()