SabrParametricVolatility Class Reference

#include <qle/termstructures/sabrparametricvolatility.hpp>

Inheritance diagram for SabrParametricVolatility:

Collaboration diagram for SabrParametricVolatility:

Public Types
enum class	ModelVariant {   Hagan2002Lognormal = 0 , Hagan2002Normal = 1 , Hagan2002NormalZeroBeta = 2 , Antonov2015FreeBoundaryNormal = 3 ,   KienitzLawsonSwaynePde = 4 , FlochKennedy = 5 }
Public Types inherited from ParametricVolatility
enum class	MarketModelType { Black76 }
enum class	MarketQuoteType { Price , NormalVolatility , ShiftedLognormalVolatility }

Public Member Functions
	SabrParametricVolatility (const ModelVariant modelVariant, const std::vector< MarketSmile > marketSmiles, const MarketModelType marketModelType, const MarketQuoteType inputMarketQuoteType, const QuantLib::Handle< QuantLib::YieldTermStructure > discountCurve, const std::map< std::pair< QuantLib::Real, QuantLib::Real >, std::vector< std::pair< Real, bool > > > modelParameters={}, const QuantLib::Size maxCalibrationAttempts=10, const QuantLib::Real exitEarlyErrorThreshold=0.005, const QuantLib::Real maxAcceptableError=0.05)
QuantLib::Real	evaluate (const QuantLib::Real timeToExpiry, const QuantLib::Real underlyingLength, const QuantLib::Real strike, const QuantLib::Real forward, const MarketQuoteType outputMarketQuoteType, const QuantLib::Real outputLognormalShift=QuantLib::Null< QuantLib::Real >(), const boost::optional< QuantLib::Option::Type > outputOptionType=boost::none) const override
const std::vector< Real > &	timeToEpiries () const
const std::vector< Real > &	underlyingLenghts () const
const QuantLib::Matrix &	alpha () const
const QuantLib::Matrix &	beta () const
const QuantLib::Matrix &	nu () const
const QuantLib::Matrix &	rho () const
const QuantLib::Matrix &	lognormalShift () const
const QuantLib::Matrix &	numberOfCalibrationAttempts () const
const QuantLib::Matrix &	calibrationError () const
const QuantLib::Matrix &	isInterpolated () const
Public Member Functions inherited from ParametricVolatility
virtual	~ParametricVolatility ()
	ParametricVolatility (const std::vector< MarketSmile > marketSmiles, const MarketModelType marketModelType, const MarketQuoteType inputMarketQuoteType, const QuantLib::Handle< QuantLib::YieldTermStructure > discountCurve)
Real	convert (const Real inputQuote, const MarketQuoteType inputMarketQuoteType, const QuantLib::Real inputLognormalShift, const boost::optional< QuantLib::Option::Type > inputOptionType, const QuantLib::Real timeToExpiry, const QuantLib::Real strike, const QuantLib::Real forward, const MarketQuoteType outputMarketQuoteType, const QuantLib::Real outputLognormalShift, const boost::optional< QuantLib::Option::Type > outputOptionType=boost::none) const
virtual QuantLib::Real	evaluate (const QuantLib::Real timeToExpiry, const QuantLib::Real underlyingLength, const QuantLib::Real strike, const QuantLib::Real forward, const MarketQuoteType outputMarketQuoteType, const QuantLib::Real outputLognormalShift=QuantLib::Null< QuantLib::Real >(), const boost::optional< QuantLib::Option::Type > outputOptionType=boost::none) const =0

Private Member Functions
void	calculate ()
std::vector< std::pair< Real, bool > >	defaultModelParameters () const
std::vector< Real >	getGuess (const std::vector< std::pair< Real, bool > > &params, const std::vector< Real > &randomSeq, const Real forward, const Real lognormalShift) const
ParametricVolatility::MarketQuoteType	preferredOutputQuoteType () const
std::vector< Real >	direct (const std::vector< Real > &x, const Real forward, const Real lognormalShift) const
std::vector< Real >	inverse (const std::vector< Real > &y, const Real forward, const Real lognormalShift) const
std::vector< Real >	evaluateSabr (const std::vector< Real > &params, const Real forward, const Real timeToExpiry, const Real lognormalShift, const std::vector< Real > &strikes) const
std::tuple< std::vector< Real >, Real, QuantLib::Size >	calibrateModelParameters (const MarketSmile &marketSmile, const std::vector< std::pair< Real, bool > > &params) const

Private Attributes
ModelVariant	modelVariant_
std::map< std::pair< QuantLib::Real, QuantLib::Real >, std::vector< std::pair< Real, bool > > >	modelParameters_
QuantLib::Size	maxCalibrationAttempts_
QuantLib::Real	exitEarlyErrorThreshold_
QuantLib::Real	maxAcceptableError_
std::map< std::pair< Real, Real >, std::vector< Real > >	calibratedSabrParams_
std::map< std::pair< Real, Real >, Real >	lognormalShifts_
std::map< std::pair< Real, Real >, Real >	calibrationErrors_
std::map< std::pair< Real, Real >, QuantLib::Size >	noOfAttempts_
std::vector< Real >	underlyingLengths_
std::vector< Real >	timeToExpiries_
std::vector< Real >	underlyingLengthsForInterpolation_
std::vector< Real >	timeToExpiriesForInterpolation_
QuantLib::Matrix	alpha_
QuantLib::Matrix	beta_
QuantLib::Matrix	nu_
QuantLib::Matrix	rho_
QuantLib::Matrix	lognormalShift_
QuantLib::Matrix	calibrationError_
QuantLib::Matrix	isInterpolated_
QuantLib::Matrix	numberOfCalibrationAttempts_
QuantLib::Interpolation2D	alphaInterpolation_
QuantLib::Interpolation2D	betaInterpolation_
QuantLib::Interpolation2D	nuInterpolation_
QuantLib::Interpolation2D	rhoInterpolation_
QuantLib::Interpolation2D	lognormalShiftInterpolation_

Static Private Attributes
static constexpr double	eps1 = .0000001
static constexpr double	eps2 = .9999
static constexpr double	max_nvol_equiv = 0.02
static constexpr double	max_nu = 2.0

Additional Inherited Members
Protected Attributes inherited from ParametricVolatility
std::vector< MarketSmile >	marketSmiles_
MarketModelType	marketModelType_
MarketQuoteType	inputMarketQuoteType_
QuantLib::Handle< QuantLib::YieldTermStructure >	discountCurve_

Detailed Description

Definition at line 31 of file sabrparametricvolatility.hpp.

Member Enumeration Documentation

ModelVariant

enum class ModelVariant

strong

Enumerator
Hagan2002Lognormal
Hagan2002Normal
Hagan2002NormalZeroBeta
Antonov2015FreeBoundaryNormal
KienitzLawsonSwaynePde
FlochKennedy

Definition at line 33 of file sabrparametricvolatility.hpp.

                            {
        Hagan2002Lognormal = 0,
        Hagan2002Normal = 1,
        Hagan2002NormalZeroBeta = 2,
        Antonov2015FreeBoundaryNormal = 3,
        KienitzLawsonSwaynePde = 4 ,
        FlochKennedy = 5
    };

Constructor & Destructor Documentation

SabrParametricVolatility()

SabrParametricVolatility	(	const ModelVariant	modelVariant,
		const std::vector< MarketSmile >	marketSmiles,
		const MarketModelType	marketModelType,
		const MarketQuoteType	inputMarketQuoteType,
		const QuantLib::Handle< QuantLib::YieldTermStructure >	discountCurve,
		const std::map< std::pair< QuantLib::Real, QuantLib::Real >, std::vector< std::pair< Real, bool > > >	modelParameters = {},
		const QuantLib::Size	maxCalibrationAttempts = 10,
		const QuantLib::Real	exitEarlyErrorThreshold = 0.005,
		const QuantLib::Real	maxAcceptableError = 0.05
	)

modelParameters are given by (tte, underlyingLen) as a vector of parameter values and whether the values are fixed

Definition at line 36 of file sabrparametricvolatility.cpp.

    : ParametricVolatility(marketSmiles, marketModelType, inputMarketQuoteType, discountCurve),
      modelVariant_(modelVariant), modelParameters_(std::move(modelParameters)),
      maxCalibrationAttempts_(maxCalibrationAttempts), exitEarlyErrorThreshold_(exitEarlyErrorThreshold),
      maxAcceptableError_(maxAcceptableError) {
    calculate();
}

Here is the call graph for this function:

Member Function Documentation

evaluate()

Real evaluate ( const QuantLib::Real  timeToExpiry, const QuantLib::Real  underlyingLength, const QuantLib::Real  strike, const QuantLib::Real  forward, const MarketQuoteType  outputMarketQuoteType, const QuantLib::Real  outputLognormalShift = QuantLib::Null<QuantLib::Real>(), const boost::optional< QuantLib::Option::Type >  outputOptionType = boost::none  ) const

overridevirtual

Implements ParametricVolatility.

Definition at line 602 of file sabrparametricvolatility.cpp.

                                                                                                        {
 
    Real alpha = alphaInterpolation_(timeToExpiry, underlyingLength);
    Real beta = betaInterpolation_(timeToExpiry, underlyingLength);
    Real nu = nuInterpolation_(timeToExpiry, underlyingLength);
    Real rho = rhoInterpolation_(timeToExpiry, underlyingLength);
    Real lognormalShift = lognormalShiftInterpolation_(timeToExpiry, underlyingLength);
 
    Real result = evaluateSabr({alpha, beta, nu, rho}, forward, timeToExpiry, lognormalShift, {strike}).front();
    return convert(result, preferredOutputQuoteType(), lognormalShift, boost::none, timeToExpiry, strike, forward,
                   outputMarketQuoteType, outputLognormalShift == Null<Real>() ? lognormalShift : outputLognormalShift,
                   outputOptionType);
}

Here is the call graph for this function:

timeToEpiries()

const std::vector< Real > & timeToEpiries

(

)

const

underlyingLenghts()

const std::vector< Real > & underlyingLenghts

(

)

const

alpha()

const QuantLib::Matrix & alpha

(

)

const

Definition at line 63 of file sabrparametricvolatility.hpp.

{ return alpha_; }

Here is the caller graph for this function:

beta()

const QuantLib::Matrix & beta

(

)

const

Definition at line 64 of file sabrparametricvolatility.hpp.

{ return beta_; }

Here is the caller graph for this function:

nu()

const QuantLib::Matrix & nu

(

)

const

Definition at line 65 of file sabrparametricvolatility.hpp.

{ return nu_; }

Here is the caller graph for this function:

rho()

const QuantLib::Matrix & rho

(

)

const

Definition at line 66 of file sabrparametricvolatility.hpp.

{ return rho_; }

Here is the caller graph for this function:

lognormalShift()

const QuantLib::Matrix & lognormalShift

(

)

const

Definition at line 67 of file sabrparametricvolatility.hpp.

{ return lognormalShift_; }

Here is the caller graph for this function:

numberOfCalibrationAttempts()

const QuantLib::Matrix & numberOfCalibrationAttempts

(

)

const

Definition at line 68 of file sabrparametricvolatility.hpp.

{ return numberOfCalibrationAttempts_; }

calibrationError()

const QuantLib::Matrix & calibrationError

(

)

const

Definition at line 70 of file sabrparametricvolatility.hpp.

{ return calibrationError_; }

isInterpolated()

const QuantLib::Matrix & isInterpolated

(

)

const

Definition at line 72 of file sabrparametricvolatility.hpp.

{ return isInterpolated_; }

calculate()

void calculate ( )

private

Definition at line 426 of file sabrparametricvolatility.cpp.

                                         {
 
    // if no model parameters are given, we provide the default ones
 
    if (modelParameters_.empty()) {
        for (auto const& s : marketSmiles_) {
            modelParameters_[std::make_pair(s.timeToExpiry, s.underlyingLength)] = defaultModelParameters();
        }
    }
 
    // clear stored data
 
    calibratedSabrParams_.clear();
    lognormalShifts_.clear();
    calibrationErrors_.clear();
 
    // for each market smile calibrate the SABR variant
 
    for (auto const& s : marketSmiles_) {
        auto key = std::make_pair(s.timeToExpiry, s.underlyingLength);
        auto param = modelParameters_.find(key);
        QL_REQUIRE(param != modelParameters_.end(),
                   "SabrParametricVolatility::performCalculations(): no model parameter given for ("
                       << s.timeToExpiry << ", " << s.underlyingLength
                       << "). All (timeToExpiry, underlyingLength) pairs that are given as market points must be "
                          "covered by the given model parameters.");
        try {
            auto [params, error, noOfAttempts] = calibrateModelParameters(s, param->second);
            if (error < maxAcceptableError_)
                calibratedSabrParams_[key] = params;
            calibrationErrors_[key] = error;
            noOfAttempts_[key] = noOfAttempts;
        } catch (const std::exception& e) {
            // all calibration failed -> do not populate params, but interpolate them below
        }
        lognormalShifts_[key] = s.lognormalShift;
    }
 
    // build the timeToExpiry, underlyingLength vectors
 
    std::set<Real> tmpTimeToExpiries, tmpUnderlyingLengths;
 
    for (auto const& s : marketSmiles_) {
        tmpTimeToExpiries.insert(s.timeToExpiry);
        tmpUnderlyingLengths.insert(s.underlyingLength);
    }
 
    timeToExpiries_ = std::vector<Real>(tmpTimeToExpiries.begin(), tmpTimeToExpiries.end());
    underlyingLengths_ = std::vector<Real>(tmpUnderlyingLengths.begin(), tmpUnderlyingLengths.end());
 
    // build a matrix of calibrated SABR parameters, possibly with null values
 
    Size m = underlyingLengths_.size();
    Size n = timeToExpiries_.size();
 
    alpha_ = Matrix(m, n, Null<Real>());
    beta_ = Matrix(m, n, Null<Real>());
    nu_ = Matrix(m, n, Null<Real>());
    rho_ = Matrix(m, n, Null<Real>());
    lognormalShift_ = Matrix(m, n, Null<Real>());
    calibrationError_ = Matrix(m, n, Null<Real>());
    isInterpolated_ = Matrix(m, n, 1.0);
    numberOfCalibrationAttempts_ = Matrix(m, n, 0.0);
 
    for (Size i = 0; i < m; ++i) {
        for (Size j = 0; j < n; ++j) {
            auto key = std::make_pair(timeToExpiries_[j], underlyingLengths_[i]);
            if (auto p = calibratedSabrParams_.find(key); p != calibratedSabrParams_.end()) {
                alpha_(i, j) = p->second[0];
                beta_(i, j) = p->second[1];
                nu_(i, j) = p->second[2];
                rho_(i, j) = p->second[3];
                isInterpolated_(i, j) = 0.0;
            }
            if (auto s = lognormalShifts_.find(key); s != lognormalShifts_.end()) {
                lognormalShift_(i, j) = s->second;
            }
            if (auto e = calibrationErrors_.find(key); e != calibrationErrors_.end()) {
                calibrationError_(i, j) = e->second;
            }
            if (auto e = noOfAttempts_.find(key); e != noOfAttempts_.end()) {
                numberOfCalibrationAttempts_(i, j) = static_cast<Real>(e->second);
            }
        }
    }
 
    // interpolate the null values
 
    laplaceInterpolationWithErrorHandling(alpha_, timeToExpiries_, underlyingLengths_);
    laplaceInterpolationWithErrorHandling(beta_, timeToExpiries_, underlyingLengths_);
    laplaceInterpolationWithErrorHandling(nu_, timeToExpiries_, underlyingLengths_);
    laplaceInterpolationWithErrorHandling(rho_, timeToExpiries_, underlyingLengths_);
 
    // sanitize values produced by the the interpolation that are not allowed
 
    for (Size i = 0; i < m; ++i) {
        for (Size j = 0; j < n; ++j) {
            alpha_(i, j) = std::max(alpha_(i, j), 0.0);
            beta_(i, j) = std::max(beta_(i, j), 0.0);
            nu_(i, j) = std::max(nu_(i, j), 0.0);
            rho_(i, j) = std::max(std::min(rho_(i, j), 1.0), -1.0);
        }
    }
 
    // workaround because BilinearInterpolation below requires at least two points in each dimension
 
    timeToExpiriesForInterpolation_ = timeToExpiries_;
    underlyingLengthsForInterpolation_ = underlyingLengths_;
 
    if (m == 1 || n == 1) {
 
        auto mNew = m == 1 ? m + 1 : m;
        auto nNew = n == 1 ? n + 1 : n;
 
        auto alphaTmp = alpha_;
        auto betaTmp = beta_;
        auto nuTmp = nu_;
        auto rhoTmp = rho_;
        auto lognormalShiftTmp = lognormalShift_;
 
        alpha_ = Matrix(mNew, nNew, Null<Real>());
        beta_ = Matrix(mNew, nNew, Null<Real>());
        nu_ = Matrix(mNew, nNew, Null<Real>());
        rho_ = Matrix(mNew, nNew, Null<Real>());
        lognormalShift_ = Matrix(mNew, nNew, Null<Real>());
 
        for (Size i = 0; i < mNew; ++i) {
            for (Size j = 0; j < nNew; ++j) {
                Size iOld = std::min(i, m - 1);
                Size jOld = std::min(j, n - 1);
                alpha_(i, j) = alphaTmp(iOld, jOld);
                beta_(i, j) = betaTmp(iOld, jOld);
                nu_(i, j) = nuTmp(iOld, jOld);
                rho_(i, j) = rhoTmp(iOld, jOld);
                lognormalShift_(i, j) = lognormalShiftTmp(iOld, jOld);
            }
        }
 
        if (m == 1) {
            // do not use null value for interpolation grid
            if (underlyingLengthsForInterpolation_[0] == Null<Real>())
                underlyingLengthsForInterpolation_[0] = 1.0;
            underlyingLengthsForInterpolation_.push_back(underlyingLengthsForInterpolation_.back() + 1.0);
        }
        if (n == 1)
            timeToExpiriesForInterpolation_.push_back(timeToExpiriesForInterpolation_.back() + 1.0);
 
        m = mNew;
        n = nNew;
    }
 
    // set up the parameter interpolations
 
    alphaInterpolation_ = FlatExtrapolator2D(boost::make_shared<BilinearInterpolation>(
        timeToExpiriesForInterpolation_.begin(), timeToExpiriesForInterpolation_.end(),
        underlyingLengthsForInterpolation_.begin(), underlyingLengthsForInterpolation_.end(), alpha_));
    betaInterpolation_ = FlatExtrapolator2D(boost::make_shared<BilinearInterpolation>(
        timeToExpiriesForInterpolation_.begin(), timeToExpiriesForInterpolation_.end(),
        underlyingLengthsForInterpolation_.begin(), underlyingLengthsForInterpolation_.end(), beta_));
    nuInterpolation_ = FlatExtrapolator2D(boost::make_shared<BilinearInterpolation>(
        timeToExpiriesForInterpolation_.begin(), timeToExpiriesForInterpolation_.end(),
        underlyingLengthsForInterpolation_.begin(), underlyingLengthsForInterpolation_.end(), nu_));
    rhoInterpolation_ = FlatExtrapolator2D(boost::make_shared<BilinearInterpolation>(
        timeToExpiriesForInterpolation_.begin(), timeToExpiriesForInterpolation_.end(),
        underlyingLengthsForInterpolation_.begin(), underlyingLengthsForInterpolation_.end(), rho_));
    lognormalShiftInterpolation_ = FlatExtrapolator2D(boost::make_shared<BilinearInterpolation>(
        timeToExpiriesForInterpolation_.begin(), timeToExpiriesForInterpolation_.end(),
        underlyingLengthsForInterpolation_.begin(), underlyingLengthsForInterpolation_.end(), lognormalShift_));
 
    alphaInterpolation_.enableExtrapolation();
    betaInterpolation_.enableExtrapolation();
    nuInterpolation_.enableExtrapolation();
    rhoInterpolation_.enableExtrapolation();
    lognormalShiftInterpolation_.enableExtrapolation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

defaultModelParameters()

std::vector< std::pair< Real, bool > > defaultModelParameters ( ) const

private

Definition at line 103 of file sabrparametricvolatility.cpp.

                                                                                      {
    switch (modelVariant_) {
    case ModelVariant::Hagan2002Lognormal:
        return {{0.0050, false}, {0.8, false}, {0.30, false}, {0.0, false}};
    case ModelVariant::Hagan2002Normal:
        return {{0.0050, false}, {0.8, false}, {0.30, false}, {0.0, false}};
    case ModelVariant::Hagan2002NormalZeroBeta:
        return {{0.0050, false}, {0.0, true}, {0.30, false}, {0.0, false}};
    case ModelVariant::Antonov2015FreeBoundaryNormal:
        return {{0.0050, false}, {0.0, true}, {0.30, false}, {0.0, false}};
    case ModelVariant::KienitzLawsonSwaynePde:
        return {{0.0050, false}, {0.8, false}, {0.30, false}, {0.0, false}};
    case ModelVariant::FlochKennedy:
        return {{0.0050, false}, {0.8, false}, {0.30, false}, {0.0, false}};
    default:
        QL_FAIL("SabrParametricVolatility::defaultModelParameters(): model variant (" << static_cast<int>(modelVariant_)
                                                                                      << ") not handled.");
    }
}

Here is the caller graph for this function:

getGuess()

std::vector< Real > getGuess ( const std::vector< std::pair< Real, bool > > &  params, const std::vector< Real > &  randomSeq, const Real  forward, const Real  lognormalShift  ) const

private

Definition at line 68 of file sabrparametricvolatility.cpp.

                                                                                      {
    std::vector<Real> result(4);
    for (Size i = 0, j = 0; i < 4; ++i) {
        if (params[i].second) {
            result[i] = params[i].first;
        } else {
            switch (i) {
            case 0: {
                Real fbeta = std::pow(forward + lognormalShift, params[1].first);
                result[0] = (eps1 + randomSeq[j] * 0.01) / fbeta;
                break;
            }
            case 1: {
                result[1] = eps1 + randomSeq[j] * eps2;
                break;
            }
            case 2: {
                result[2] = eps1 + randomSeq[j] * 5.0;
                break;
            }
            case 3: {
                result[3] = (randomSeq[j] * 2.0 - 1.0) * eps2;
                break;
            }
            default:
                break;
            }
            ++j;
        }
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

preferredOutputQuoteType()

ParametricVolatility::MarketQuoteType preferredOutputQuoteType ( ) const

private

Definition at line 48 of file sabrparametricvolatility.cpp.

                                                                                             {
    switch (modelVariant_) {
    case ModelVariant::Hagan2002Lognormal:
        return MarketQuoteType::ShiftedLognormalVolatility;
    case ModelVariant::Hagan2002Normal:
        return MarketQuoteType::NormalVolatility;
    case ModelVariant::Hagan2002NormalZeroBeta:
        return MarketQuoteType::NormalVolatility;
    case ModelVariant::Antonov2015FreeBoundaryNormal:
        return MarketQuoteType::Price;
    case ModelVariant::KienitzLawsonSwaynePde:
        return MarketQuoteType::Price;
    case ModelVariant::FlochKennedy:
        return MarketQuoteType::ShiftedLognormalVolatility;
    default:
        QL_FAIL("SabrParametricVolatility::preferredOutputQuoteType(): model variant ("
                << static_cast<int>(modelVariant_) << ") not handled.");
    }
}

Here is the caller graph for this function:

direct()

std::vector< Real > direct ( const std::vector< Real > &  x, const Real  forward, const Real  lognormalShift  ) const

private

Definition at line 123 of file sabrparametricvolatility.cpp.

                                                                                    {
    std::vector<Real> y(4);
    y[1] = std::max(eps1, std::min(1.0 - eps1, std::exp(-(x[1] * x[1]))));
    Real fbeta = std::pow(std::max(forward + lognormalShift, eps1), y[1]);
    y[0] = std::max(eps1, std::exp(-(x[0] * x[0])) / fbeta * max_nvol_equiv);
    y[2] = std::max(eps1, std::exp(-(x[2] * x[2])) * max_nu);
    y[3] = std::fabs(x[3]) < 2.5 * M_PI ? eps2 * std::sin(x[3]) : eps2 * (x[3] > 0.0 ? 1.0 : (-1.0));
    return y;
}

Here is the call graph for this function:

Here is the caller graph for this function:

inverse()

std::vector< Real > inverse ( const std::vector< Real > &  y, const Real  forward, const Real  lognormalShift  ) const

private

Definition at line 134 of file sabrparametricvolatility.cpp.

                                                                                     {
    std::vector<Real> x(4);
    x[1] = std::sqrt(-std::log(std::min(1.0 - eps1, std::max(eps1, y[1]))));
    Real fbeta = std::pow(std::max(forward + lognormalShift, eps1), y[1]);
    x[0] = std::sqrt(-std::log(std::min(1.0 - eps1, std::max(eps1, y[0] * fbeta / max_nvol_equiv))));
    x[2] = std::sqrt(-std::log(std::min(1.0 - eps1, std::max(eps1, y[2] / max_nu))));
    x[3] = std::asin(std::max(-eps2, std::min(eps2, y[3])));
    return x;
}

Here is the call graph for this function:

Here is the caller graph for this function:

evaluateSabr()

std::vector< Real > evaluateSabr ( const std::vector< Real > &  params, const Real  forward, const Real  timeToExpiry, const Real  lognormalShift, const std::vector< Real > &  strikes  ) const

private

Definition at line 145 of file sabrparametricvolatility.cpp.

                                                                                               {
    std::vector<Real> result;
    switch (modelVariant_) {
    case ModelVariant::Hagan2002Lognormal: {
        result.resize(strikes.size());
        for (Size i = 0; i < strikes.size(); ++i) {
            try {
                if (strikes[i] < -lognormalShift || QuantLib::close_enough(strikes[i], 0.0))
                    result[i] = 0.0;
                else
                    result[i] = unsafeSabrLogNormalVolatility(strikes[i] + lognormalShift, forward + lognormalShift,
                                                              timeToExpiry, params[0], params[1], params[2], params[3]);
            } catch (...) {
                result[i] = 0.0;
            }
        }
        break;
    }
    case ModelVariant::Hagan2002Normal: {
        result.resize(strikes.size());
        for (Size i = 0; i < strikes.size(); ++i) {
            try {
                if (strikes[i] < -lognormalShift || QuantLib::close_enough(strikes[i], 0.0))
                    result[i] = 0.0;
                else
                    result[i] = unsafeSabrNormalVolatility(strikes[i] + lognormalShift, forward + lognormalShift,
                                                           timeToExpiry, params[0], params[1], params[2], params[3]);
            } catch (...) {
                result[i] = 0.0;
            }
        }
        break;
    }
    case ModelVariant::Hagan2002NormalZeroBeta: {
        result.resize(strikes.size());
        for (Size i = 0; i < strikes.size(); ++i) {
            try {
                result[i] =
                    QuantExt::normalSabrVolatility(strikes[i], forward, timeToExpiry, params[0], params[2], params[3]);
            } catch (...) {
                result[i] = 0.0;
            }
        }
        break;
    }
    case ModelVariant::Antonov2015FreeBoundaryNormal: {
        result.resize(strikes.size());
        for (Size i = 0; i < strikes.size(); ++i) {
            try {
                result[i] = QuantExt::normalFreeBoundarySabrPrice(strikes[i], forward, timeToExpiry, params[0],
                                                                  params[2], params[3]) *
                            (discountCurve_.empty() ? 1.0 : discountCurve_->discount(timeToExpiry));
                if (strikes[i] < forward)
                    result[i] = result[i] - forward + strikes[i];
            } catch (...) {
                result[i] = 0.0;
            }
        }
        break;
    }
    case ModelVariant::KienitzLawsonSwaynePde: {
        try {
            KienitzLawsonSwayneSabrPdeDensity pde(params[0], params[1], params[2], params[3], forward, timeToExpiry,
                                                  lognormalShift, 50,
                                                  std::max<Size>(5, std::lround(24.0 * timeToExpiry + 0.5)), 5.0);
            result = pde.callPrices(strikes);
            for (Size i = 0; i < strikes.size(); ++i) {
                if (strikes[i] < forward)
                    result[i] = result[i] - forward + strikes[i];
                result[i] *= discountCurve_.empty() ? 1.0 : discountCurve_->discount(timeToExpiry);
            }
        } catch (...) {
            result = std::vector<Real>(strikes.size(), 0.0);
        }
        break;
    }
    case ModelVariant::FlochKennedy: {
        result.resize(strikes.size());
        for (Size i = 0; i < strikes.size(); ++i) {
            try {
                if (strikes[i] < -lognormalShift || QuantLib::close_enough(strikes[i], 0.0))
                    result[i] = 0.0;
                else
                    result[i] = sabrFlochKennedyVolatility(strikes[i] + lognormalShift, forward + lognormalShift,
                                                           timeToExpiry, params[0], params[1], params[2], params[3]);
            } catch (...) {
                result[i] = 0.0;
            }
        }
        break;
    }
    default:
        QL_FAIL("SabrParametricVolatility::preferredOutputQuoteType(): model variant ("
                << static_cast<int>(modelVariant_) << ") not handled.");
    }
 
    // ensure we have a number, not inf or nan
 
    for (auto& v : result)
        if (!std::isfinite(v))
            v = 0.0;
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

calibrateModelParameters()

std::tuple< std::vector< Real >, Real, Size > calibrateModelParameters ( const MarketSmile &  marketSmile, const std::vector< std::pair< Real, bool > > &  params  ) const

private

Definition at line 253 of file sabrparametricvolatility.cpp.

                                                                                                       {
 
    // determine the number of free parameters
 
    Size noFreeParams = 0;
    for (auto const& p : params)
        if (!p.second)
            ++noFreeParams;
 
    // if there are no free parameters, we just pass back the fixed parameters as the result
 
    if (noFreeParams == 0) {
        std::vector<Real> resultParams;
        for (auto const& p : params)
            resultParams.push_back(p.first);
        return std::make_tuple(resultParams, 0.0, 0);
    }
 
    // if we have less data points than free parameters -> exit early
 
    QL_REQUIRE(noFreeParams <= marketSmile.strikes.size(), "internal: less data points than free parameters");
 
    // define the target function
 
    struct TargetFunction : public QuantLib::CostFunction {
        Real forward_;
        Real timeToExpiry_;
        Real lognormalShift_;
        std::vector<Real> strikes_;
        std::vector<Real> marketQuotes_;
        Real refQuote_;
        std::function<std::vector<Real>(const std::vector<Real>&, const Real, const Real, const Real,
                                        const std::vector<Real>&)>
            evalSabr_;
        std::vector<std::pair<Real, bool>> params_;
        std::vector<Real> invParams_;
        std::function<std::vector<Real>(const std::vector<Real>&)> direct_;
        std::function<std::vector<Real>(const std::vector<Real>&)> inverse_;
 
        std::vector<Real> evalSabr(const Array& x) const {
            std::vector<Real> params(4);
            for (Size i = 0, j = 0; i < params_.size(); ++i) {
                if (params_[i].second)
                    params[i] = invParams_[i];
                else
                    params[i] = x[j++];
            }
            params = direct_(params);
            return evalSabr_(params, forward_, timeToExpiry_, lognormalShift_, strikes_);
        }
 
        Array values(const Array& x) const override {
            Array result(strikes_.size());
            auto sabr = evalSabr(x);
            for (Size i = 0; i < strikes_.size(); ++i) {
                result[i] = (marketQuotes_[i] - sabr[i]) / refQuote_;
            }
            return result;
        }
    };
 
    /* build the target function and populate the members:
       strikes, marketQuotes  : the latter are converted to the preferred output quote type of the SABR
       evalSabr               : the function to produce SABR values for a given vector of strikes */
 
    TargetFunction t;
 
    t.forward_ = marketSmile.forward;
    t.timeToExpiry_ = marketSmile.timeToExpiry;
    t.lognormalShift_ = marketSmile.lognormalShift;
 
    t.evalSabr_ = [this](const std::vector<Real>& params, const Real forward, const Real timeToExpiry,
                         const Real lognormalShift, const std::vector<Real>& strikes) {
        return evaluateSabr(params, forward, timeToExpiry, lognormalShift, strikes);
    };
 
    t.params_ = params;
    for (Size i = 0; i < params.size(); ++i)
        t.invParams_.push_back(params[i].first);
    t.invParams_ = inverse(t.invParams_, marketSmile.forward, marketSmile.lognormalShift);
 
    t.inverse_ = [this, &marketSmile](const std::vector<Real>& y) {
        return inverse(y, marketSmile.forward, marketSmile.lognormalShift);
    };
    t.direct_ = [this, &marketSmile](const std::vector<Real>& x) {
        return direct(x, marketSmile.forward, marketSmile.lognormalShift);
    };
 
    t.strikes_ = marketSmile.strikes;
    for (Size i = 0; i < marketSmile.marketQuotes.size(); ++i) {
        t.marketQuotes_.push_back(convert(
            marketSmile.marketQuotes[i], inputMarketQuoteType_, marketSmile.lognormalShift,
            marketSmile.optionTypes.empty() ? boost::none : boost::optional<Option::Type>(marketSmile.optionTypes[i]),
            marketSmile.timeToExpiry, marketSmile.strikes[i], marketSmile.forward, preferredOutputQuoteType(),
            marketSmile.lognormalShift, boost::none));
    }
    // we use relative errors w.r.t. the max market quote, because far otm quotes are close to zero
    t.refQuote_ = *std::max_element(t.marketQuotes_.begin(), t.marketQuotes_.end());
 
    // perform the calibration (this step might throw if all minimizations go wrong)
 
    NoConstraint noConstraint;
    LevenbergMarquardt lm;
    EndCriteria endCriteria(100, 10, 1E-8, 1E-8, 1E-8);
 
    std::vector<Real> bestResult(params.size());
    Real bestError = QL_MAX_REAL;
 
    HaltonRsg haltonRsg(noFreeParams, 42);
 
    Array guess(noFreeParams);
 
    Size attempt;
    for (attempt = 0; attempt < maxCalibrationAttempts_; ++attempt) {
 
        if (attempt == 0) {
            // first attempt uses given initial model parameters
            for (Size i = 0, j = 0; i < t.invParams_.size(); ++i) {
                if (!params[i].second) {
                    guess[j++] = t.invParams_[i];
                }
            }
        } else {
            // subsequent attempts use randomized guess
            auto g = inverse(getGuess(params, haltonRsg.nextSequence().value, t.forward_, t.lognormalShift_),
                             t.forward_, t.lognormalShift_);
            for (Size i = 0, j = 0; i < g.size(); ++i) {
                if (!params[i].second) {
                    guess[j++] = g[i];
                }
            }
        }
 
        Problem problem(t, noConstraint, guess);
        try {
            lm.minimize(problem, endCriteria);
        } catch (...) {
            continue;
        }
 
        Real thisError = problem.functionValue();
        if (thisError < bestError) {
            bestError = thisError;
            for (Size i = 0, j = 0; i < bestResult.size(); ++i) {
                if (params[i].second)
                    bestResult[i] = t.invParams_[i];
                else
                    bestResult[i] = problem.currentValue()[j++];
            }
            bestResult = direct(bestResult, t.forward_, t.lognormalShift_);
        }
 
        if (bestError < exitEarlyErrorThreshold_)
            break;
    }
 
    QL_REQUIRE(bestError < QL_MAX_REAL, "internal: all calibrations failed");
 
    return std::make_tuple(bestResult, bestError, ++attempt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

eps1

constexpr double eps1 = .0000001

staticconstexprprivate

Definition at line 75 of file sabrparametricvolatility.hpp.

eps2

constexpr double eps2 = .9999

staticconstexprprivate

Definition at line 76 of file sabrparametricvolatility.hpp.

max_nvol_equiv

constexpr double max_nvol_equiv = 0.02

staticconstexprprivate

Definition at line 77 of file sabrparametricvolatility.hpp.

max_nu

constexpr double max_nu = 2.0

staticconstexprprivate

Definition at line 78 of file sabrparametricvolatility.hpp.

modelVariant_

ModelVariant modelVariant_

private

Definition at line 93 of file sabrparametricvolatility.hpp.

modelParameters_

std::map<std::pair<QuantLib::Real, QuantLib::Real>, std::vector<std::pair<Real, bool> > > modelParameters_

private

Definition at line 94 of file sabrparametricvolatility.hpp.

maxCalibrationAttempts_

QuantLib::Size maxCalibrationAttempts_

private

Definition at line 95 of file sabrparametricvolatility.hpp.

exitEarlyErrorThreshold_

QuantLib::Real exitEarlyErrorThreshold_

private

Definition at line 96 of file sabrparametricvolatility.hpp.

maxAcceptableError_

QuantLib::Real maxAcceptableError_

private

Definition at line 97 of file sabrparametricvolatility.hpp.

calibratedSabrParams_

std::map<std::pair<Real, Real>, std::vector<Real> > calibratedSabrParams_

mutableprivate

Definition at line 99 of file sabrparametricvolatility.hpp.

lognormalShifts_

std::map<std::pair<Real, Real>, Real> lognormalShifts_

mutableprivate

Definition at line 100 of file sabrparametricvolatility.hpp.

calibrationErrors_

std::map<std::pair<Real, Real>, Real> calibrationErrors_

mutableprivate

Definition at line 101 of file sabrparametricvolatility.hpp.

noOfAttempts_

std::map<std::pair<Real, Real>, QuantLib::Size> noOfAttempts_

mutableprivate

Definition at line 102 of file sabrparametricvolatility.hpp.

underlyingLengths_

std::vector<Real> underlyingLengths_

mutableprivate

Definition at line 104 of file sabrparametricvolatility.hpp.

timeToExpiries_

std::vector<Real> timeToExpiries_

private

Definition at line 104 of file sabrparametricvolatility.hpp.

underlyingLengthsForInterpolation_

std::vector<Real> underlyingLengthsForInterpolation_

mutableprivate

Definition at line 105 of file sabrparametricvolatility.hpp.

timeToExpiriesForInterpolation_

std::vector<Real> timeToExpiriesForInterpolation_

private

Definition at line 105 of file sabrparametricvolatility.hpp.

alpha_

QuantLib::Matrix alpha_

mutableprivate

Definition at line 106 of file sabrparametricvolatility.hpp.

beta_

QuantLib::Matrix beta_

private

Definition at line 106 of file sabrparametricvolatility.hpp.

nu_

QuantLib::Matrix nu_

private

Definition at line 106 of file sabrparametricvolatility.hpp.

rho_

QuantLib::Matrix rho_

private

Definition at line 106 of file sabrparametricvolatility.hpp.

lognormalShift_

QuantLib::Matrix lognormalShift_

private

Definition at line 106 of file sabrparametricvolatility.hpp.

calibrationError_

QuantLib::Matrix calibrationError_

private

Definition at line 106 of file sabrparametricvolatility.hpp.

isInterpolated_

QuantLib::Matrix isInterpolated_

private

Definition at line 106 of file sabrparametricvolatility.hpp.

numberOfCalibrationAttempts_

QuantLib::Matrix numberOfCalibrationAttempts_

private

Definition at line 107 of file sabrparametricvolatility.hpp.

alphaInterpolation_

QuantLib::Interpolation2D alphaInterpolation_

mutableprivate

Definition at line 108 of file sabrparametricvolatility.hpp.

betaInterpolation_

QuantLib::Interpolation2D betaInterpolation_

private

Definition at line 108 of file sabrparametricvolatility.hpp.

nuInterpolation_

QuantLib::Interpolation2D nuInterpolation_

private

Definition at line 108 of file sabrparametricvolatility.hpp.

rhoInterpolation_

QuantLib::Interpolation2D rhoInterpolation_

private

Definition at line 108 of file sabrparametricvolatility.hpp.

lognormalShiftInterpolation_

QuantLib::Interpolation2D lognormalShiftInterpolation_

private

Definition at line 109 of file sabrparametricvolatility.hpp.