#include <qle/termstructures/creditvolcurve.hpp>

Inheritance diagram for InterpolatingCreditVolCurve:

Collaboration diagram for InterpolatingCreditVolCurve:

Public Member Functions
	InterpolatingCreditVolCurve (const QuantLib::Natural settlementDays, const QuantLib::Calendar &cal, QuantLib::BusinessDayConvention bdc, const QuantLib::DayCounter &dc, const std::vector< QuantLib::Period > &terms, const std::vector< QuantLib::Handle< CreditCurve > > &termCurves, const std::map< std::tuple< QuantLib::Date, QuantLib::Period, QuantLib::Real >, QuantLib::Handle< QuantLib::Quote > > &quotes, const Type &type)

	InterpolatingCreditVolCurve (const QuantLib::Date &referenceDate, const QuantLib::Calendar &cal, QuantLib::BusinessDayConvention bdc, const QuantLib::DayCounter &dc, const std::vector< QuantLib::Period > &terms, const std::vector< QuantLib::Handle< CreditCurve > > &termCurves, const std::map< std::tuple< QuantLib::Date, QuantLib::Period, QuantLib::Real >, QuantLib::Handle< QuantLib::Quote > > &quotes, const Type &type)

QuantLib::Real	volatility (const QuantLib::Date &exerciseDate, const QuantLib::Real underlyingLength, const QuantLib::Real strike, const Type &targetType) const override

Public Member Functions inherited from CreditVolCurve
	CreditVolCurve (QuantLib::BusinessDayConvention bdc, const QuantLib::DayCounter &dc, const std::vector< QuantLib::Period > &terms, const std::vector< QuantLib::Handle< CreditCurve > > &termCurves, const Type &type)

	CreditVolCurve (const QuantLib::Natural settlementDays, const QuantLib::Calendar &cal, QuantLib::BusinessDayConvention bdc, const QuantLib::DayCounter &dc, const std::vector< QuantLib::Period > &terms, const std::vector< QuantLib::Handle< CreditCurve > > &termCurves, const Type &type)

	CreditVolCurve (const QuantLib::Date &referenceDate, const QuantLib::Calendar &cal, QuantLib::BusinessDayConvention bdc, const QuantLib::DayCounter &dc, const std::vector< QuantLib::Period > &terms, const std::vector< QuantLib::Handle< CreditCurve > > &termCurves, const Type &type)

QuantLib::Real	volatility (const QuantLib::Date &exerciseDate, const QuantLib::Period &underlyingTerm, const QuantLib::Real strike, const Type &targetType) const

virtual QuantLib::Real	volatility (const QuantLib::Date &exerciseDate, const QuantLib::Real underlyingLength, const QuantLib::Real strike, const Type &targetType) const =0

QuantLib::Real	volatility (const QuantLib::Real exerciseTime, const QuantLib::Real underlyingLength, const QuantLib::Real strike, const Type &targetType) const

virtual const std::vector< QuantLib::Period > &	terms () const

virtual const std::vector< QuantLib::Handle< CreditCurve > > &	termCurves () const

const Type &	type () const

QuantLib::Real	atmStrike (const QuantLib::Date &expiry, const QuantLib::Period &term) const

QuantLib::Real	atmStrike (const QuantLib::Date &expiry, const QuantLib::Real underlyingLength) const

QuantLib::Real	minStrike () const override

QuantLib::Real	maxStrike () const override

QuantLib::Date	maxDate () const override

Private Types
using	Smile = std::pair< QuantLib::Real, QuantLib::ext::shared_ptr< QuantLib::Interpolation > >

using	Key = std::pair< QuantLib::Date, QuantLib::Period >

Private Member Functions
void	init ()

void	performCalculations () const override

void	createSmile (const QuantLib::Date &expiry, const QuantLib::Period &term, const QuantLib::Date &expiry_m, const QuantLib::Date &expiry_p) const

Private Attributes
std::map< std::tuple< QuantLib::Date, QuantLib::Period, QuantLib::Real >, QuantLib::Handle< QuantLib::Quote > >	quotes_

std::vector< QuantLib::Period >	smileTerms_

std::vector< QuantLib::Date >	smileExpiries_

std::vector< QuantLib::Real >	smileTermLengths_

std::vector< QuantLib::Real >	smileExpiryTimes_

std::map< Key, std::vector< QuantLib::Real > >	strikes_

std::map< Key, std::vector< QuantLib::Real > >	vols_

std::map< Key, Smile >	smiles_

Additional Inherited Members
Public Types inherited from CreditVolCurve
enum class	Type { Price , Spread }

Protected Member Functions inherited from CreditVolCurve
void	init ()

void	update () override

void	performCalculations () const override

QuantLib::Real	moneyness (const QuantLib::Real strike, const QuantLib::Real atmStrike) const

QuantLib::Real	strike (const QuantLib::Real moneyness, const QuantLib::Real atmStrike) const

Protected Attributes inherited from CreditVolCurve
std::vector< QuantLib::Period >	terms_

std::vector< QuantLib::Handle< CreditCurve > >	termCurves_

Type	type_

std::map< std::pair< QuantLib::Date, double >, double >	atmStrikeCache_

Detailed Description

Definition at line 87 of file creditvolcurve.hpp.

Member Typedef Documentation

◆ Smile

using Smile = std::pair<QuantLib::Real, QuantLib::ext::shared_ptr<QuantLib::Interpolation> >

private

Definition at line 108 of file creditvolcurve.hpp.

◆ Key

using Key = std::pair<QuantLib::Date, QuantLib::Period>

private

Definition at line 109 of file creditvolcurve.hpp.

Constructor & Destructor Documentation

◆ InterpolatingCreditVolCurve() [1/2]

InterpolatingCreditVolCurve	(	const QuantLib::Natural	settlementDays,
		const QuantLib::Calendar &	cal,
		QuantLib::BusinessDayConvention	bdc,
		const QuantLib::DayCounter &	dc,
		const std::vector< QuantLib::Period > &	terms,
		const std::vector< QuantLib::Handle< CreditCurve > > &	termCurves,
		const std::map< std::tuple< QuantLib::Date, QuantLib::Period, QuantLib::Real >, QuantLib::Handle< QuantLib::Quote > > &	quotes,
		const Type &	type
	)

◆ InterpolatingCreditVolCurve() [2/2]

InterpolatingCreditVolCurve	(	const QuantLib::Date &	referenceDate,
		const QuantLib::Calendar &	cal,
		QuantLib::BusinessDayConvention	bdc,
		const QuantLib::DayCounter &	dc,
		const std::vector< QuantLib::Period > &	terms,
		const std::vector< QuantLib::Handle< CreditCurve > > &	termCurves,
		const std::map< std::tuple< QuantLib::Date, QuantLib::Period, QuantLib::Real >, QuantLib::Handle< QuantLib::Quote > > &	quotes,
		const Type &	type
	)

Member Function Documentation

◆ volatility()

Real volatility	(	const QuantLib::Date &	exerciseDate,
		const QuantLib::Real	underlyingLength,
		const QuantLib::Real	strike,
		const Type &	targetType
	)		const

overridevirtual

Implements CreditVolCurve.

Definition at line 284 of file creditvolcurve.cpp.

                                                                           {
 
    calculate();
 
    QL_REQUIRE(targetType == type(), "InterpolatingCreditVolCurve: Vol type conversion between strike types 'Price' "
                                     "and 'Spread' is not supported. The vol "
                                     "surface used to price an option must have the same strike type as the option.");
 
    Real effStrike = strike == Null<Real>() ? atmStrike(expiry, underlyingLength) : strike;
 
    // term interpolation
 
    Size termIndex_m, termIndex_p;
    Real term_alpha;
    std::tie(termIndex_m, termIndex_p, term_alpha) = interpolationIndices(smileTermLengths_, underlyingLength);
 
    // expiry interpolation
 
    Size expiryIndex_m, expiryIndex_p;
    Real expiry_alpha;
    Real t = timeFromReference(expiry);
    std::tie(expiryIndex_m, expiryIndex_p, expiry_alpha) = interpolationIndices(smileExpiryTimes_, t);
 
    // smiles by expiry / term
 
    const Smile& smile_1_1 = smiles_[std::make_pair(smileExpiries_[expiryIndex_m], smileTerms_[termIndex_m])];
    const Smile& smile_1_2 = smiles_[std::make_pair(smileExpiries_[expiryIndex_m], smileTerms_[termIndex_p])];
    const Smile& smile_2_1 = smiles_[std::make_pair(smileExpiries_[expiryIndex_p], smileTerms_[termIndex_m])];
    const Smile& smile_2_2 = smiles_[std::make_pair(smileExpiries_[expiryIndex_p], smileTerms_[termIndex_p])];
 
    // atm levels by expiry / term
 
    Real atm_1_1 = smile_1_1.first;
    Real atm_1_2 = smile_1_2.first;
    Real atm_2_1 = smile_2_1.first;
    Real atm_2_2 = smile_2_2.first;
 
    // vols at target moneyness
 
    Real m = moneyness(effStrike, atmStrike(expiry, underlyingLength));
    Real vol_1_1 = smile_1_1.second->operator()(this->strike(m, atm_1_1));
    Real vol_1_2 = smile_1_2.second->operator()(this->strike(m, atm_1_2));
    Real vol_2_1 = smile_2_1.second->operator()(this->strike(m, atm_2_1));
    Real vol_2_2 = smile_2_2.second->operator()(this->strike(m, atm_2_2));
 
    // interpolate in term direction
 
    Real vol_1 = term_alpha * vol_1_1 + (1.0 - term_alpha) * vol_1_2;
    Real vol_2 = term_alpha * vol_2_1 + (1.0 - term_alpha) * vol_2_2;
 
    // interpolate in expiry direction
 
    return std::sqrt((expiry_alpha * (vol_1 * vol_1 * smileExpiryTimes_[expiryIndex_m]) +
                      (1.0 - expiry_alpha) * (vol_2 * vol_2 * smileExpiryTimes_[expiryIndex_p])) /
                     t);
}

Here is the call graph for this function:

◆ init()

void init ( )

private

Definition at line 279 of file creditvolcurve.cpp.

                                       {
    for (auto const& q : quotes_)
        registerWith(q.second);
}

◆ performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 342 of file creditvolcurve.cpp.

                                                            {
 
    CreditVolCurve::performCalculations();
 
    QL_REQUIRE(!quotes_.empty(), "InterpolatingCreditVolCurve: no quotes given, can not build a volatility curve.");
 
    // For each term and option expiry create an interpolation object representing a vol smile.
 
    smileTerms_.clear();
    smileExpiries_.clear();
    smileTermLengths_.clear();
    smileExpiryTimes_.clear();
    strikes_.clear();
    vols_.clear();
    smiles_.clear();
 
    Period currentTerm = 0 * Days;
    Date currentExpiry = Null<Date>();
    std::vector<Real> currentStrikes;
    std::vector<Real> currentVols;
    Date expiry;
    Period term;
    Real strike;
    Real vol;
 
    auto q = quotes_.begin();
    for (Size i = 0; i <= quotes_.size(); ++i) {
        if (i < quotes_.size()) {
            expiry = std::get<0>(q->first);
            term = std::get<1>(q->first);
            strike = std::get<2>(q->first);
            vol = q->second->value();
            ++q;
        } else {
            currentTerm = term;
            currentExpiry = expiry;
        }
        if (term != currentTerm || expiry != currentExpiry || i == quotes_.size()) {
            if (!currentStrikes.empty()) {
                if (currentStrikes.size() == 1) {
                    currentStrikes.push_back(currentStrikes.back() + 0.01);
                    currentVols.push_back(currentVols.back());
                }
                auto key = std::make_pair(currentExpiry, currentTerm);
                auto s = strikes_.insert(std::make_pair(key, currentStrikes)).first;
                auto v = vols_.insert(std::make_pair(key, currentVols)).first;
                auto tmp = QuantLib::ext::make_shared<FlatExtrapolation>(
                    QuantLib::ext::make_shared<LinearInterpolation>(s->second.begin(), s->second.end(), v->second.begin()));
                tmp->enableExtrapolation();
                smiles_[key] = std::make_pair(atmStrike(currentExpiry, currentTerm), tmp);
                currentStrikes.clear();
                currentVols.clear();
                smileTerms_.push_back(currentTerm);
                smileExpiries_.push_back(currentExpiry);
            }
            currentTerm = term;
            currentExpiry = expiry;
        }
        if (i < quotes_.size()) {
            currentStrikes.push_back(strike);
            currentVols.push_back(vol);
        }
    }
 
    // populate times vectors
 
    for (auto const& p : smileTerms_)
        smileTermLengths_.push_back(periodToTime(p));
    for (auto const& d : smileExpiries_)
        smileExpiryTimes_.push_back(timeFromReference(d));
 
    /* For each term, add missing option expiries that we saw for other terms by creating an interpolated smile.
       We interpolate in terms of
       - absolute moneyness (Type = Spread)
       - log-moneyness      (Type = Price)
    */
 
    for (auto const& term : smileTerms_) {
        for (auto const& expiry : smileExpiries_) {
            auto key = std::make_pair(expiry, term);
            if (smiles_.find(key) == smiles_.end()) {
 
                // search neighboured expiries for same term
 
                Date expiry_m = Null<Date>();
                Date expiry_p = Null<Date>();
                for (auto const& s : smiles_) {
                    if (s.first.second != term)
                        continue;
                    if (s.first.first >= expiry) {
                        expiry_p = s.first.first;
                        break;
                    }
                    expiry_m = s.first.first;
                }
 
                // if we have a smile for the expiry and term already, there is nothing to do
 
                if (expiry_m == expiry || expiry_p == expiry)
                    continue;
 
                // otherwise build an interpolated / extrapoalted smile
 
                if (expiry_m == Null<Date>() && expiry_p != Null<Date>()) {
                    // expiry <= smallest expiry for that term = expiry_p
                    createSmile(expiry, term, expiry_p, expiry_m);
                } else if (expiry_m != Null<Date>() && expiry_p != Null<Date>()) {
                    // expiry_m < expiry < expiry_p
                    createSmile(expiry, term, expiry_m, expiry_p);
                } else if (expiry_m != Null<Date>() && expiry_p == Null<Date>()) {
                    // expiry >= largest expiry for that term = expiry_m
                    createSmile(expiry, term, expiry_p, expiry_m);
                } else {
                    QL_FAIL("InterpolatingCreditVolCurve: internal error, expiry_m = expiry_p = null, i.e. there are "
                            "no smiles for term "
                            << term);
                }
            }
        }
    }
}

Here is the call graph for this function:

◆ createSmile()

void createSmile	(	const QuantLib::Date &	expiry,
		const QuantLib::Period &	term,
		const QuantLib::Date &	expiry_m,
		const QuantLib::Date &	expiry_p
	)		const

private

Definition at line 470 of file creditvolcurve.cpp.

                                                                          {
    Real thisAtm = atmStrike(expiry, term);
    if (expiry_p == Null<Date>()) {
        auto key = std::make_pair(expiry_m, term);
        const Smile& smile = smiles_[key];
        std::vector<Real> strikes;
        std::vector<Real> vols;
        for (auto const& k : strikes_[key]) {
            strikes.push_back(strike(moneyness(k, smile.first), thisAtm));
        }
        for (auto const& k : strikes)
            vols.push_back(smile.second->operator()(k));
        auto s = strikes_.insert(std::make_pair(key, strikes));
        auto v = vols_.insert(std::make_pair(key, vols));
        auto tmp = QuantLib::ext::make_shared<FlatExtrapolation>(QuantLib::ext::make_shared<LinearInterpolation>(
            s.first->second.begin(), s.first->second.end(), v.first->second.begin()));
        tmp->enableExtrapolation();
        smiles_[std::make_pair(expiry, term)] = std::make_pair(thisAtm, tmp);
    } else if (expiry_m == Null<Date>()) {
        auto key = std::make_pair(expiry_p, term);
        const Smile& smile = smiles_[key];
        std::vector<Real> strikes;
        std::vector<Real> vols;
        for (auto const& k : strikes_[key]) {
            strikes.push_back(strike(moneyness(k, smile.first), thisAtm));
        }
        for (auto const& k : strikes)
            vols.push_back(smile.second->operator()(k));
        auto s = strikes_.insert(std::make_pair(key, strikes));
        auto v = vols_.insert(std::make_pair(key, vols));
        auto tmp = QuantLib::ext::make_shared<FlatExtrapolation>(QuantLib::ext::make_shared<LinearInterpolation>(
            s.first->second.begin(), s.first->second.end(), v.first->second.begin()));
        tmp->enableExtrapolation();
        smiles_[std::make_pair(expiry, term)] = std::make_pair(thisAtm, tmp);
    } else {
        auto key_m = std::make_pair(expiry_m, term);
        auto key_p = std::make_pair(expiry_p, term);
        const Smile& smile_m = smiles_[key_m];
        const Smile& smile_p = smiles_[key_p];
        std::set<Real, CompClose> strikes_set;
        for (auto const& k : strikes_[key_m]) {
            strikes_set.insert(strike(moneyness(k, smile_m.first), thisAtm));
        }
        for (auto const& k : strikes_[key_p]) {
            strikes_set.insert(strike(moneyness(k, smile_p.first), thisAtm));
        }
        std::vector<Real> strikes(strikes_set.begin(), strikes_set.end());
        std::vector<Real> vols;
        Real t = timeFromReference(expiry);
        Real t_m = timeFromReference(expiry_m);
        Real t_p = timeFromReference(expiry_m);
        Real alpha = (t_p - t) / (t_p - t_m);
        for (auto const& k : strikes) {
            Real vol_m = smile_m.second->operator()(k);
            Real vol_p = smile_p.second->operator()(k);
            vols.push_back(std::sqrt((alpha * (vol_m * vol_m * t_m) + (1.0 - alpha) * (vol_p * vol_p * t_p)) / t));
        }
        auto s = strikes_.insert(std::make_pair(std::make_pair(expiry, term), strikes));
        auto v = vols_.insert(std::make_pair(std::make_pair(expiry, term), vols));
        auto tmp = QuantLib::ext::make_shared<FlatExtrapolation>(QuantLib::ext::make_shared<LinearInterpolation>(
            s.first->second.begin(), s.first->second.end(), v.first->second.begin()));
        tmp->enableExtrapolation();
        smiles_[std::make_pair(expiry, term)] = std::make_pair(thisAtm, tmp);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ quotes_

std::map<std::tuple<QuantLib::Date, QuantLib::Period, QuantLib::Real>, QuantLib::Handle<QuantLib::Quote> > quotes_

private

Definition at line 116 of file creditvolcurve.hpp.

◆ smileTerms_

std::vector<QuantLib::Period> smileTerms_

mutableprivate

Definition at line 118 of file creditvolcurve.hpp.

◆ smileExpiries_

std::vector<QuantLib::Date> smileExpiries_

mutableprivate

Definition at line 119 of file creditvolcurve.hpp.

◆ smileTermLengths_

std::vector<QuantLib::Real> smileTermLengths_

mutableprivate

Definition at line 120 of file creditvolcurve.hpp.

◆ smileExpiryTimes_

std::vector<QuantLib::Real> smileExpiryTimes_

mutableprivate

Definition at line 121 of file creditvolcurve.hpp.

◆ strikes_

std::map<Key, std::vector<QuantLib::Real> > strikes_

mutableprivate

Definition at line 123 of file creditvolcurve.hpp.

◆ vols_

std::map<Key, std::vector<QuantLib::Real> > vols_

mutableprivate

Definition at line 124 of file creditvolcurve.hpp.

◆ smiles_

std::map<Key, Smile> smiles_

mutableprivate

Definition at line 125 of file creditvolcurve.hpp.

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Smile

◆ Key

Constructor & Destructor Documentation

◆ InterpolatingCreditVolCurve() [1/2]

◆ InterpolatingCreditVolCurve() [2/2]

Member Function Documentation

◆ volatility()

◆ init()

◆ performCalculations()

◆ createSmile()

Member Data Documentation

◆ quotes_

◆ smileTerms_

◆ smileExpiries_

◆ smileTermLengths_

◆ smileExpiryTimes_

◆ strikes_

◆ vols_

◆ smiles_