BlackVolatilitySurfaceDelta Class Reference

#include <qle/termstructures/blackvolsurfacedelta.hpp>

Inheritance diagram for BlackVolatilitySurfaceDelta:

Collaboration diagram for BlackVolatilitySurfaceDelta:

Public Member Functions
	BlackVolatilitySurfaceDelta (Date referenceDate, const std::vector< Date > &dates, const std::vector< Real > &putDeltas, const std::vector< Real > &callDeltas, bool hasAtm, const Matrix &blackVolMatrix, const DayCounter &dayCounter, const Calendar &cal, const Handle< Quote > &spot, const Handle< YieldTermStructure > &domesticTS, const Handle< YieldTermStructure > &foreignTS, DeltaVolQuote::DeltaType dt=DeltaVolQuote::DeltaType::Spot, DeltaVolQuote::AtmType at=DeltaVolQuote::AtmType::AtmDeltaNeutral, boost::optional< QuantLib::DeltaVolQuote::DeltaType > atmDeltaType=boost::none, const Period &switchTenor=0 *Days, DeltaVolQuote::DeltaType ltdt=DeltaVolQuote::DeltaType::Fwd, DeltaVolQuote::AtmType ltat=DeltaVolQuote::AtmType::AtmDeltaNeutral, boost::optional< QuantLib::DeltaVolQuote::DeltaType > longTermAtmDeltaType=boost::none, InterpolatedSmileSection::InterpolationMethod interpolationMethod=InterpolatedSmileSection::InterpolationMethod::Linear, bool flatExtrapolation=true)
TermStructure interface
Date	maxDate () const override
VolatilityTermStructure interface
Real	minStrike () const override
Real	maxStrike () const override
Visitability
virtual void	accept (AcyclicVisitor &) override

Inspectors
std::vector< Date >	dates_
std::vector< Time >	times_
std::vector< Real >	putDeltas_
std::vector< Real >	callDeltas_
bool	hasAtm_
std::vector< QuantLib::ext::shared_ptr< BlackVarianceCurve > >	interpolators_
Handle< Quote >	spot_
Handle< YieldTermStructure >	domesticTS_
Handle< YieldTermStructure >	foreignTS_
DeltaVolQuote::DeltaType	dt_
DeltaVolQuote::AtmType	at_
boost::optional< QuantLib::DeltaVolQuote::DeltaType >	atmDeltaType_
Period	switchTenor_
DeltaVolQuote::DeltaType	ltdt_
DeltaVolQuote::AtmType	ltat_
boost::optional< QuantLib::DeltaVolQuote::DeltaType >	longTermAtmDeltaType_
InterpolatedSmileSection::InterpolationMethod	interpolationMethod_
bool	flatExtrapolation_
Real	switchTime_
const std::vector< QuantLib::Date > &	dates () const
QuantLib::ext::shared_ptr< FxSmileSection >	blackVolSmile (Time t) const
	Return an FxSmile for the time t. More...
QuantLib::ext::shared_ptr< FxSmileSection >	blackVolSmile (const QuantLib::Date &d) const
virtual Volatility	blackVolImpl (Time t, Real strike) const override
Real	forward (Time t) const

Detailed Description

Abstract Black volatility surface based on delta

Definition at line 84 of file blackvolsurfacedelta.hpp.

Constructor & Destructor Documentation

BlackVolatilitySurfaceDelta()

BlackVolatilitySurfaceDelta	(	Date	referenceDate,
		const std::vector< Date > &	dates,
		const std::vector< Real > &	putDeltas,
		const std::vector< Real > &	callDeltas,
		bool	hasAtm,
		const Matrix &	blackVolMatrix,
		const DayCounter &	dayCounter,
		const Calendar &	cal,
		const Handle< Quote > &	spot,
		const Handle< YieldTermStructure > &	domesticTS,
		const Handle< YieldTermStructure > &	foreignTS,
		DeltaVolQuote::DeltaType	dt = DeltaVolQuote::DeltaType::Spot,
		DeltaVolQuote::AtmType	at = DeltaVolQuote::AtmType::AtmDeltaNeutral,
		boost::optional< QuantLib::DeltaVolQuote::DeltaType >	atmDeltaType = boost::none,
		const Period &	switchTenor = 0 * Days,
		DeltaVolQuote::DeltaType	ltdt = DeltaVolQuote::DeltaType::Fwd,
		DeltaVolQuote::AtmType	ltat = DeltaVolQuote::AtmType::AtmDeltaNeutral,
		boost::optional< QuantLib::DeltaVolQuote::DeltaType >	longTermAtmDeltaType = boost::none,
		InterpolatedSmileSection::InterpolationMethod	interpolationMethod = InterpolatedSmileSection::InterpolationMethod::Linear,
		bool	flatExtrapolation = true
	)

Definition at line 64 of file blackvolsurfacedelta.cpp.

    : BlackVolatilityTermStructure(referenceDate, cal, Following, dayCounter), dates_(dates), times_(dates.size(), 0),
      putDeltas_(putDeltas), callDeltas_(callDeltas), hasAtm_(hasAtm), spot_(spot), domesticTS_(domesticTS),
      foreignTS_(foreignTS), dt_(dt), at_(at), atmDeltaType_(atmDeltaType), switchTenor_(switchTenor), ltdt_(ltdt),
      ltat_(ltat), longTermAtmDeltaType_(longTermAtmDeltaType), interpolationMethod_(im),
      flatExtrapolation_(flatExtrapolation) {
 
    // If ATM delta type is not given, set it to dt
    if (!atmDeltaType_)
        atmDeltaType_ = dt_;
    if (!longTermAtmDeltaType_)
        longTermAtmDeltaType_ = ltdt_;
 
    // set switch time
    switchTime_ = switchTenor_ == 0 * Days ? QL_MAX_REAL : timeFromReference(optionDateFromTenor(switchTenor));
 
    QL_REQUIRE(dates.size() > 1, "at least 1 date required");
    // this has already been done for dates
    for (Size i = 0; i < dates.size(); i++) {
        QL_REQUIRE(referenceDate < dates[i], "Dates must be greater than reference date");
        times_[i] = timeFromReference(dates[i]);
        if (i > 0) {
            QL_REQUIRE(times_[i] > times_[i - 1], "dates must be sorted unique!");
        }
    }
 
    // check size of matrix
    Size n = putDeltas.size() + (hasAtm ? 1 : 0) + callDeltas.size();
    QL_REQUIRE(n > 0, "Need at least one delta");
    QL_REQUIRE(blackVolMatrix.columns() == n, "Invalid number of columns in blackVolMatrix, got "
                                                  << blackVolMatrix.columns() << " but have " << n << " deltas");
    QL_REQUIRE(blackVolMatrix.rows() == dates.size(), "Invalid number of rows in blackVolMatrix, got "
                                                          << blackVolMatrix.rows() << " but have " << dates.size()
                                                          << " dates");
 
    // build interpolators for each delta
    // TODO: template this so it can be changed
    bool forceMonotoneVariance = false;
    for (Size i = 0; i < n; i++) {
        vector<Volatility> vols(dates.size());
        for (Size j = 0; j < dates.size(); j++) {
            vols[j] = blackVolMatrix[j][i];
        }
 
        // BlackVarianceCurve will make a local copy of vols and dates
        interpolators_.push_back(
            QuantLib::ext::make_shared<BlackVarianceCurve>(referenceDate, dates, vols, dayCounter, forceMonotoneVariance));
    }
 
    // register
    registerWith(spot_);
    registerWith(domesticTS_);
    registerWith(foreignTS_);
}

Here is the call graph for this function:

Member Function Documentation

maxDate()

Date maxDate ( ) const

override

Definition at line 104 of file blackvolsurfacedelta.hpp.

{ return Date::maxDate(); }

minStrike()

Real minStrike ( ) const

override

Definition at line 108 of file blackvolsurfacedelta.hpp.

{ return 0; }

maxStrike()

Real maxStrike ( ) const

override

Definition at line 109 of file blackvolsurfacedelta.hpp.

{ return QL_MAX_REAL; }

accept()

void accept ( AcyclicVisitor &  v )

overridevirtual

Definition at line 166 of file blackvolsurfacedelta.hpp.

                                                                 {
    Visitor<BlackVolatilitySurfaceDelta>* v1 = dynamic_cast<Visitor<BlackVolatilitySurfaceDelta>*>(&v);
    if (v1 != 0)
        v1->visit(*this);
    else
        BlackVolatilityTermStructure::accept(v);
}

dates()

const std::vector< QuantLib::Date > & dates

(

)

const

Definition at line 118 of file blackvolsurfacedelta.hpp.

{ return dates_; }

Here is the caller graph for this function:

blackVolSmile() [1/2]

QuantLib::ext::shared_ptr< FxSmileSection > blackVolSmile

(

Time

t

)

const

Return an FxSmile for the time t.

Note the smile does not observe the spot or YTS handles, it will not update when they change.

This is not really FX specific

Definition at line 126 of file blackvolsurfacedelta.cpp.

                                                                                             {
 
    Real spot = spot_->value();
    DiscountFactor dDiscount = domesticTS_->discount(t);
    DiscountFactor fDiscount = foreignTS_->discount(t);
 
    DeltaVolQuote::AtmType at;
    DeltaVolQuote::DeltaType dt;
    DeltaVolQuote::DeltaType atmDt;
    if (t < switchTime_ && !close_enough(t, switchTime_)) {
        at = at_;
        dt = dt_;
        atmDt = *atmDeltaType_;
    } else {
        at = ltat_;
        dt = ltdt_;
        atmDt = *longTermAtmDeltaType_;
    }
 
    // Store smile section in map. Use strikes as key and vols as values for automatic sorting by strike.
    // If we have already have a strike from a previous delta, we do not overwrite it.
    auto comp = [](Real a, Real b) { return !close(a, b) && a < b; };
    map<Real, Real, decltype(comp)> smileSection(comp);
    Size i = 0;
    for (Real delta : putDeltas_) {
        Real vol = interpolators_.at(i)->blackVol(t, 1, true);
        try {
            BlackDeltaCalculator bdc(Option::Put, dt, spot, dDiscount, fDiscount, vol * sqrt(t));
            Real strike = bdc.strikeFromDelta(delta);
            if (smileSection.count(strike) == 0)
                smileSection[strike] = vol;
        } catch (const std::exception& e) {
            QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating put strike at delta " << delta << ": "
                                                                                                 << e.what());
        }
        i++;
    }
    if (hasAtm_) {
        Real vol = interpolators_.at(i)->blackVol(t, 1, true);
        try {
            BlackDeltaCalculator bdc(Option::Put, atmDt, spot, dDiscount, fDiscount, vol * sqrt(t));
            Real strike = bdc.atmStrike(at);
            if (smileSection.count(strike) == 0)
                smileSection[strike] = vol;
        } catch (const std::exception& e) {
            QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating atm strike: " << e.what());
        }
        i++;
    }
    for (Real delta : callDeltas_) {
        Real vol = interpolators_.at(i)->blackVol(t, 1, true);
        try {
            BlackDeltaCalculator bdc(Option::Call, dt, spot, dDiscount, fDiscount, vol * sqrt(t));
            Real strike = bdc.strikeFromDelta(delta);
            if (smileSection.count(strike) == 0)
                smileSection[strike] = vol;
        } catch (const std::exception& e) {
            QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating call strike at delta " << delta << ": "
                                                                                                  << e.what());
        }
        i++;
    }
 
    // sort and extract to vectors
    vector<Real> strikes;
    strikes.reserve(smileSection.size());
    vector<Real> vols;
    vols.reserve(smileSection.size());
    for (const auto& kv : smileSection) {
        strikes.push_back(kv.first);
        vols.push_back(kv.second);
    }
 
    // now build smile from strikes and vols
    QL_REQUIRE(!vols.empty(),
               "BlackVolatilitySurfaceDelta::blackVolSmile(" << t << "): no strikes given, this is unexpected.");
    if (vols.size() == 1) {
        // handle the situation that we only have one strike (might occur for e.g. t=0)
        return QuantLib::ext::make_shared<ConstantSmileSection>(vols.front());
    } else {
        // we have at least two strikes
        return QuantLib::ext::make_shared<InterpolatedSmileSection>(spot, dDiscount, fDiscount, t, strikes, vols,
                                                            interpolationMethod_, flatExtrapolation_);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

blackVolSmile() [2/2]

QuantLib::ext::shared_ptr< FxSmileSection > blackVolSmile

(

const QuantLib::Date &

d

)

const

blackVolImpl()

Volatility blackVolImpl ( Time  t, Real  strike  ) const

overrideprotectedvirtual

Definition at line 220 of file blackvolsurfacedelta.cpp.

                                                                              {
    // Only flat extrapolation allowed
    Time tme = t <= times_.back() ? t : times_.back();
    // If asked for strike == 0, just return the ATM value.
    if (strike == 0 || strike == Null<Real>()) {
        if (hasAtm_) {
            // ask the ATM interpolator directly
            return interpolators_[putDeltas_.size()]->blackVol(tme, Null<Real>(), true);
        } else {
            // set strike to be fwd and we will return ATMF
            strike = forward(tme);
        }
    }
    return blackVolSmile(tme)->volatility(strike);
}

Here is the call graph for this function:

forward()

Real forward ( Time  t ) const

private

Definition at line 216 of file blackvolsurfacedelta.cpp.

                                                      {
    return spot_->value() * foreignTS_->discount(t) / domesticTS_->discount(t); // TODO
}

Here is the caller graph for this function:

Member Data Documentation

dates_

std::vector<Date> dates_

private

Definition at line 135 of file blackvolsurfacedelta.hpp.

times_

std::vector<Time> times_

private

Definition at line 136 of file blackvolsurfacedelta.hpp.

putDeltas_

std::vector<Real> putDeltas_

private

Definition at line 138 of file blackvolsurfacedelta.hpp.

callDeltas_

std::vector<Real> callDeltas_

private

Definition at line 139 of file blackvolsurfacedelta.hpp.

hasAtm_

bool hasAtm_

private

Definition at line 140 of file blackvolsurfacedelta.hpp.

interpolators_

std::vector<QuantLib::ext::shared_ptr<BlackVarianceCurve> > interpolators_

private

Definition at line 141 of file blackvolsurfacedelta.hpp.

spot_

Handle<Quote> spot_

private

Definition at line 143 of file blackvolsurfacedelta.hpp.

domesticTS_

Handle<YieldTermStructure> domesticTS_

private

Definition at line 144 of file blackvolsurfacedelta.hpp.

foreignTS_

Handle<YieldTermStructure> foreignTS_

private

Definition at line 145 of file blackvolsurfacedelta.hpp.

dt_

DeltaVolQuote::DeltaType dt_

private

Definition at line 147 of file blackvolsurfacedelta.hpp.

at_

DeltaVolQuote::AtmType at_

private

Definition at line 148 of file blackvolsurfacedelta.hpp.

atmDeltaType_

boost::optional<QuantLib::DeltaVolQuote::DeltaType> atmDeltaType_

private

Definition at line 149 of file blackvolsurfacedelta.hpp.

switchTenor_

Period switchTenor_

private

Definition at line 150 of file blackvolsurfacedelta.hpp.

ltdt_

DeltaVolQuote::DeltaType ltdt_

private

Definition at line 151 of file blackvolsurfacedelta.hpp.

ltat_

DeltaVolQuote::AtmType ltat_

private

Definition at line 152 of file blackvolsurfacedelta.hpp.

longTermAtmDeltaType_

boost::optional<QuantLib::DeltaVolQuote::DeltaType> longTermAtmDeltaType_

private

Definition at line 153 of file blackvolsurfacedelta.hpp.

interpolationMethod_

InterpolatedSmileSection::InterpolationMethod interpolationMethod_

private

Definition at line 155 of file blackvolsurfacedelta.hpp.

flatExtrapolation_

bool flatExtrapolation_

private

Definition at line 156 of file blackvolsurfacedelta.hpp.

switchTime_

Real switchTime_

private

Definition at line 158 of file blackvolsurfacedelta.hpp.