#include <qle/termstructures/blackvariancesurfacestddevs.hpp>

Inheritance diagram for BlackVarianceSurfaceStdDevs:

Collaboration diagram for BlackVarianceSurfaceStdDevs:

Public Member Functions
	BlackVarianceSurfaceStdDevs (const Calendar &cal, const Handle< Quote > &spot, const std::vector< Time > &times, const std::vector< Real > &stdDevs, const std::vector< std::vector< Handle< Quote > > > &blackVolMatrix, const DayCounter &dayCounter, const QuantLib::ext::shared_ptr< EqFxIndexBase > &index, bool stickyStrike=false, bool flatExtrapMoneyness=false)

Public Member Functions inherited from BlackVarianceSurfaceMoneyness
	BlackVarianceSurfaceMoneyness (const Calendar &cal, const Handle< Quote > &spot, const std::vector< Time > &times, const std::vector< Real > &moneyness, const std::vector< std::vector< Handle< Quote > > > &blackVolMatrix, const DayCounter &dayCounter, bool stickyStrike, bool flatExtrapMoneyness=false)

	BlackVarianceSurfaceMoneyness (const Date &referenceDate, const Calendar &cal, const Handle< Quote > &spot, const std::vector< Time > &times, const std::vector< Real > &moneyness, const std::vector< std::vector< Handle< Quote > > > &blackVolMatrix, const DayCounter &dayCounter, bool stickyStrike, bool flatExtrapMoneyness=false)
	Moneyness variance surface with a fixed reference date. More...

Date	maxDate () const override

Real	minStrike () const override

Real	maxStrike () const override

void	update () override

void	performCalculations () const override

virtual void	accept (AcyclicVisitor &) override

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

Static Public Member Functions
static void	populateVolMatrix (const QuantLib::Handle< QuantLib::BlackVolTermStructure > &termStructre, std::vector< std::vector< Handle< QuantLib::Quote > > > &quotesToPopulate, const std::vector< Real > &times, const std::vector< Real > &stdDevPoints, const QuantLib::Interpolation &forwardCurve, const QuantLib::Interpolation atmVolCurve)

Private Member Functions
virtual Real	moneyness (Time t, Real strike) const override

Private Attributes
QuantLib::ext::shared_ptr< EqFxIndexBase >	index_

std::vector< Real >	forwards_

Interpolation	forwardCurve_

Interpolation	atmVarCurve_

std::vector< Time >	atmTimes_

std::vector< Real >	atmVariances_

bool	flatExtrapolateMoneyness_

Additional Inherited Members
Protected Member Functions inherited from BlackVarianceSurfaceMoneyness
Protected Attributes inherited from BlackVarianceSurfaceMoneyness
bool	stickyStrike_

Handle< Quote >	spot_

std::vector< Time >	times_

std::vector< Real >	moneyness_

bool	flatExtrapMoneyness_

Detailed Description

Black volatility surface based on forward moneyness

Definition at line 40 of file blackvariancesurfacestddevs.hpp.

Constructor & Destructor Documentation

◆ BlackVarianceSurfaceStdDevs()

BlackVarianceSurfaceStdDevs	(	const Calendar &	cal,
		const Handle< Quote > &	spot,
		const std::vector< Time > &	times,
		const std::vector< Real > &	stdDevs,
		const std::vector< std::vector< Handle< Quote > > > &	blackVolMatrix,
		const DayCounter &	dayCounter,
		const QuantLib::ext::shared_ptr< EqFxIndexBase > &	index,
		bool	stickyStrike = `false`,
		bool	flatExtrapMoneyness = `false`
	)

Definition at line 28 of file blackvariancesurfacestddevs.cpp.

    : BlackVarianceSurfaceMoneyness(cal, spot, times, stdDevs, blackVolMatrix, dayCounter, stickyStrike), index_(index),
      flatExtrapolateMoneyness_(flatExtrapMoneyness) {
 
    // set up atm variance curve - maybe just take ATM vols in
    vector<Real>::const_iterator it = find(stdDevs.begin(), stdDevs.end(), 0.0);
    QL_REQUIRE(it != stdDevs.end(), "atm D is required."); // this might fail
    atmVariances_.push_back(Real(0.0));
    atmTimes_.push_back(0.0);
    Size atmIndex = distance(stdDevs.begin(), it);
    for (Size i = 0; i < times.size(); i++) {
        atmVariances_.push_back(blackVolMatrix[atmIndex][i]->value() * blackVolMatrix[atmIndex][i]->value() * times[i]);
        atmTimes_.push_back(times[i]);
    }
    atmVarCurve_ = Linear().interpolate(atmTimes_.begin(), atmTimes_.end(), atmVariances_.begin());
 
    if (!stickyStrike) {
        QL_REQUIRE(index_ != nullptr, "index required for vol surface");
        registerWith(index_);
    } else {
        for (Size i = 0; i < times_.size(); i++) {
            Time t = times_[i];
            Real fwd = index_->forecastFixing(t);
            forwards_.push_back(fwd);
        }
        forwardCurve_ = Linear().interpolate(times_.begin(), times_.end(), forwards_.begin());
    }
}

Member Function Documentation

◆ populateVolMatrix()

void populateVolMatrix	(	const QuantLib::Handle< QuantLib::BlackVolTermStructure > &	termStructre,
		std::vector< std::vector< Handle< QuantLib::Quote > > > &	quotesToPopulate,
		const std::vector< Real > &	times,
		const std::vector< Real > &	stdDevPoints,
		const QuantLib::Interpolation &	forwardCurve,
		const QuantLib::Interpolation	atmVolCurve
	)

static

Definition at line 92 of file blackvariancesurfacestddevs.cpp.

                                             {
 
    // check that quotesToPopulate container has the correct dimensions
 
    QL_REQUIRE(quotesToPopulate.size() == stdDevPoints.size(),
               "BlackVarianceSurfaceStdDevs::populateVolMatrix(): quotesToPopulate size ("
                   << quotesToPopulate.size() << ") does not match stdDevPoints size (" << stdDevPoints.size() << ")");
    for (Size i = 0; i < stdDevPoints.size(); ++i) {
        QL_REQUIRE(quotesToPopulate[i].size() == times.size(),
                   "BlackVarianceSurfaceStdDevs::populateVolMatrix(): quotesToPopulate["
                       << i << "] size (" << quotesToPopulate[i].size() << ") does not match times size ("
                       << times.size() << ")");
    }
 
    // populate quotesToPopulate container
 
    for (Size j = 0; j < times.size(); j++) {
        for (Size i = 0; i < stdDevPoints.size(); i++) {
            Real tmpStrike = forwardCurve(times[j]) * exp(atmVolCurve(times[j]) * sqrt(times[j]) * stdDevPoints[i]);
            Volatility vol = termStructre->blackVol(times[j], tmpStrike, true);
            QuantLib::ext::shared_ptr<QuantLib::SimpleQuote> q(new SimpleQuote(vol));
            quotesToPopulate[i][j] = Handle<Quote>(q);
        }
    }
}

Here is the call graph for this function:

◆ moneyness()

Real moneyness	(	Time	t,
		Real	strike
	)		const

overrideprivatevirtual

Implements BlackVarianceSurfaceMoneyness.

Definition at line 60 of file blackvariancesurfacestddevs.cpp.

                                                                     {
    Real fwd;
    Real reqD; // for flat extrapolation
    Real atmVolAtT;
    if (t == 0) {
        atmVolAtT = 0;
    } else {
        atmVolAtT = sqrt(atmVarCurve_(t, true) / t);
    }
 
    if (strike == Null<Real>() || strike == 0) {
        return 0.0;
    } else {
        if (stickyStrike_)
            fwd = forwardCurve_(t, true);
        else
            fwd = index_->forecastFixing(t);
        Real num = log(strike / fwd);
        Real denom = atmVolAtT * sqrt(t);
        reqD = num / denom;
 
        if (flatExtrapolateMoneyness_) {
            if (reqD < moneyness_.front()) {
                reqD = moneyness_.front();
            } else if (reqD > moneyness_.back()) {
                reqD = moneyness_.back();
            }
        }
        return reqD;
    }
}