#include <qle/termstructures/blackvolsurfacebfrr.hpp>

Collaboration diagram for SimpleDeltaInterpolatedSmile:

Public Member Functions
	SimpleDeltaInterpolatedSmile (const Real spot, const Real domDisc, const Real forDisc, const Real expiryTime, const std::vector< Real > &deltas, const std::vector< Real > &putVols, const std::vector< Real > &callVols, const Real atmVol, const DeltaVolQuote::DeltaType dt, const DeltaVolQuote::AtmType at, const BlackVolatilitySurfaceBFRR::SmileInterpolation smileInterpolation, const Real accuracy=1E-6, const Size maxIterations=1000)

Real	volatilityAtSimpleDelta (const Real tnp)

Real	volatility (const Real strike)

Real	strikeFromDelta (const Option::Type type, const Real delta, const DeltaVolQuote::DeltaType dt)

Real	atmStrike (const DeltaVolQuote::DeltaType dt, const DeltaVolQuote::AtmType at)

Private Member Functions
Real	simpleDeltaFromStrike (const Real strike) const

Private Attributes
Real	spot_

Real	domDisc_

Real	forDisc_

Real	expiryTime_

std::vector< Real >	deltas_

std::vector< Real >	putVols_

std::vector< Real >	callVols_

Real	atmVol_

DeltaVolQuote::DeltaType	dt_

DeltaVolQuote::AtmType	at_

BlackVolatilitySurfaceBFRR::SmileInterpolation	smileInterpolation_

Real	accuracy_

Size	maxIterations_

Real	forward_

std::vector< Real >	x_

std::vector< Real >	y_

QuantLib::ext::shared_ptr< Interpolation >	interpolation_

Detailed Description

Definition at line 120 of file blackvolsurfacebfrr.hpp.

Constructor & Destructor Documentation

◆ SimpleDeltaInterpolatedSmile()

SimpleDeltaInterpolatedSmile	(	const Real	spot,
		const Real	domDisc,
		const Real	forDisc,
		const Real	expiryTime,
		const std::vector< Real > &	deltas,
		const std::vector< Real > &	putVols,
		const std::vector< Real > &	callVols,
		const Real	atmVol,
		const DeltaVolQuote::DeltaType	dt,
		const DeltaVolQuote::AtmType	at,
		const BlackVolatilitySurfaceBFRR::SmileInterpolation	smileInterpolation,
		const Real	accuracy = `1E-6`,
		const Size	maxIterations = `1000`
	)

Definition at line 35 of file blackvolsurfacebfrr.cpp.

    : spot_(spot), domDisc_(domDisc), forDisc_(forDisc), expiryTime_(expiryTime), deltas_(deltas), putVols_(putVols),
      callVols_(callVols), atmVol_(atmVol), dt_(dt), at_(at), smileInterpolation_(smileInterpolation),
      accuracy_(accuracy), maxIterations_(maxIterations) {
 
    forward_ = spot_ / domDisc_ * forDisc_;
 
    std::vector<Real> x, y;
 
    /* Convert the puts, atm, calls to strikes using the given conventions and then to simple delta
       using the given conventions. Store the simple deltas as x-values for the interpolation and
       the log of the vols as y-values */
 
    for (Size i = 0; i < deltas_.size(); ++i) {
        try {
            BlackDeltaCalculator c(Option::Put, dt_, spot_, domDisc_, forDisc_, putVols_[i] * std::sqrt(expiryTime_));
            x.push_back(simpleDeltaFromStrike(c.strikeFromDelta(-deltas[i])));
            y.push_back(transformVol(putVols_[i]));
        } catch (const std::exception& e) {
            QL_FAIL("SimpleDeltaInterpolatedSmile: strikeFromDelta("
                    << -deltas[i] << ") could not be computed for spot=" << spot_
                    << ", forward=" << spot_ / domDisc_ * forDisc_ << " (domRate=" << -std::log(domDisc_) / expiryTime_
                    << ", forRate=" << -std::log(forDisc) / expiryTime_ << "), putVol=" << putVols_[i]
                    << ", expiry=" << expiryTime_ << ": " << e.what());
        }
    }
 
    try {
        BlackDeltaCalculator c(Option::Call, dt_, spot_, domDisc_, forDisc_, atmVol * std::sqrt(expiryTime_));
        x.push_back(simpleDeltaFromStrike(c.atmStrike(at_)));
        y.push_back(transformVol(atmVol_));
    } catch (const std::exception& e) {
        QL_FAIL("SimpleDeltaIinterpolatedSmile: atmStrike could not be computed for spot="
                << spot_ << ", forward=" << spot_ / domDisc_ * forDisc_
                << " (domRate=" << -std::log(domDisc_) / expiryTime_ << ", forRate=" << -std::log(forDisc) / expiryTime_
                << "), atmVol=" << atmVol << ", expiry=" << expiryTime_ << ": " << e.what());
    }
 
    for (Size i = deltas_.size(); i > 0; --i) {
        try {
            BlackDeltaCalculator c(Option::Call, dt_, spot_, domDisc_, forDisc_,
                                   callVols_[i - 1] * std::sqrt(expiryTime_));
            x.push_back(simpleDeltaFromStrike(c.strikeFromDelta(deltas[i - 1])));
            y.push_back(transformVol(callVols_[i - 1]));
        } catch (const std::exception& e) {
            QL_FAIL("SimpleDeltaInterpolatedSmile: strikeFromDelta("
                    << deltas[i - 1] << ") could not be computed for spot=" << spot_
                    << ", forward=" << spot_ / domDisc_ * forDisc_ << " (domRate=" << -std::log(domDisc_) / expiryTime_
                    << ", forRate=" << -std::log(forDisc) / expiryTime_ << "), callVol=" << callVols_[i - 1]
                    << ", expiry=" << expiryTime_ << ": " << e.what());
        }
    }
 
    /* sort the strikes */
 
    std::vector<Size> perm(x.size());
    std::iota(perm.begin(), perm.end(), 0);
    std::sort(perm.begin(), perm.end(), [&x](Size a, Size b) { return x[a] < x[b]; });
    for (Size i = 0; i < perm.size(); ++i) {
        x_.push_back(x[perm[i]]);
        y_.push_back(y[perm[i]]);
    }
 
    /* check the strikes are not (numerically) identical */
 
    for (Size i = 0; i < x_.size() - 1; ++i) {
        QL_REQUIRE(!close_enough(x_[i], x_[i + 1]), "SmileDeltaInterpolatedSmile: interpolation points x["
                                                        << i << "] = x[" << (i + 1) << "] = " << x_[i]
                                                        << " are numerically identical.");
    }
 
    /* Create the interpolation object */
 
    if (smileInterpolation_ == BlackVolatilitySurfaceBFRR::SmileInterpolation::Linear) {
        interpolation_ = QuantLib::ext::make_shared<LinearInterpolation>(x_.begin(), x_.end(), y_.begin());
    } else if (smileInterpolation_ == BlackVolatilitySurfaceBFRR::SmileInterpolation::Cubic) {
        interpolation_ = QuantLib::ext::make_shared<CubicInterpolation>(
            x_.begin(), x_.end(), y_.begin(), CubicInterpolation::Spline, false, CubicInterpolation::SecondDerivative,
            0.0, CubicInterpolation::SecondDerivative, 0.0);
    } else {
        QL_FAIL("invalid interpolation, this is unexpected");
    }
 
    interpolation_->enableExtrapolation();
}

Here is the call graph for this function:

Member Function Documentation

◆ volatilityAtSimpleDelta()

Real volatilityAtSimpleDelta ( const Real tnp )

Definition at line 179 of file blackvolsurfacebfrr.cpp.

                                                                                 {
    Real tmp = untransformVol((*interpolation_)(simpleDelta));
    QL_REQUIRE(std::isfinite(tmp), "SimpleDeltaInterpolatedSmile::volatilityAtSimpleDelta() non-finite result ("
                                       << tmp << ") for simple delta " << simpleDelta);
    return tmp;
}

Here is the call graph for this function:

◆ volatility()

Real volatility ( const Real strike )

Definition at line 186 of file blackvolsurfacebfrr.cpp.

                                                               {
    Real tmp = untransformVol((*interpolation_)(simpleDeltaFromStrike(strike)));
    if (!std::isfinite(tmp)) {
        std::ostringstream os;
        for (Size i = 0; i < x_.size(); ++i) {
            os << "(" << x_[i] << "," << y_[i] << ")";
        }
        QL_FAIL("SimpleDeltaInterpolatedSmile::volatility() non-finite result ("
                << tmp << ") for strike " << strike << ", simple delta is " << simpleDeltaFromStrike(strike)
                << ", interpolated value is " << (*interpolation_)(simpleDeltaFromStrike(strike))
                << ", interpolation data point are " << os.str());
    }
    return tmp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ strikeFromDelta()

Real strikeFromDelta	(	const Option::Type	type,
		const Real	delta,
		const DeltaVolQuote::DeltaType	dt
	)

Definition at line 126 of file blackvolsurfacebfrr.cpp.

                                                                                    {
    Real result = forward_, lastResult;
    Size iterations = 0;
    do {
        Real stddev = std::sqrt(expiryTime_) * volatility(result);
        try {
            BlackDeltaCalculator c(type, dt, spot_, domDisc_, forDisc_, stddev);
            lastResult = result;
            result = c.strikeFromDelta((type == Option::Call ? 1.0 : -1.0) * delta);
        } catch (const std::exception& e) {
            QL_FAIL("SimpleDeltaInterpolatedSmile::strikeFromDelta("
                    << (type == Option::Call ? 1.0 : -1.0) * delta << ") could not be computed for spot=" << spot_
                    << ", forward=" << spot_ / domDisc_ * forDisc_ << " (domRate=" << -std::log(domDisc_) / expiryTime_
                    << ", forRate=" << -std::log(forDisc_) / expiryTime_ << "), vol=" << stddev / std::sqrt(expiryTime_)
                    << ", expiry=" << expiryTime_ << ": " << e.what());
        }
    } while (std::abs((result - lastResult) / lastResult) > accuracy_ && ++iterations < maxIterations_);
    QL_REQUIRE(iterations < maxIterations_,
               "SmileDeltaInterpolatedSmile::strikeFromDelta("
                   << (type == Option::Call ? 1.0 : -1.0) * delta << "): max iterations (" << maxIterations_
                   << "), no solution found for accuracy " << accuracy_ << ", last iterations: " << lastResult << "/"
                   << result << ", spot=" << spot_ << ", forward=" << spot_ / domDisc_ * forDisc_
                   << " (domRate=" << -std::log(domDisc_) / expiryTime_
                   << ", forRate=" << -std::log(forDisc_) / expiryTime_ << "), expiry=" << expiryTime_);
    return result;
}

Here is the call graph for this function:

◆ atmStrike()

Real atmStrike	(	const DeltaVolQuote::DeltaType	dt,
		const DeltaVolQuote::AtmType	at
	)

Definition at line 154 of file blackvolsurfacebfrr.cpp.

                                                                                                           {
    Real result = forward_, lastResult;
    Size iterations = 0;
    do {
        Real stddev = std::sqrt(expiryTime_) * volatility(result);
        try {
            BlackDeltaCalculator c(Option::Call, dt, spot_, domDisc_, forDisc_, stddev);
            lastResult = result;
            result = c.atmStrike(at);
        } catch (const std::exception& e) {
            QL_FAIL("SimpleDeltaInterpolatedSmile::atmStrike() could not be computed for spot="
                    << spot_ << ", forward=" << spot_ / domDisc_ * forDisc_ << " (domRate="
                    << -std::log(domDisc_) / expiryTime_ << ", forRate=" << -std::log(forDisc_) / expiryTime_
                    << "), vol=" << stddev / std::sqrt(expiryTime_) << ", expiry=" << expiryTime_ << ": " << e.what());
        }
    } while (std::abs((result - lastResult) / lastResult) > accuracy_ && ++iterations < maxIterations_);
    QL_REQUIRE(iterations < maxIterations_,
               "SmileDeltaInterpolatedSmile::atmStrike(): max iterations ("
                   << maxIterations_ << "), no solution found for accuracy " << accuracy_
                   << ", last iterations: " << lastResult << "/" << result << ", spot=" << spot_
                   << ", forward=" << spot_ / domDisc_ * forDisc_ << " (domRate=" << -std::log(domDisc_) / expiryTime_
                   << ", forRate=" << -std::log(forDisc_) / expiryTime_ << "), expiry=" << expiryTime_);
    return result;
}

Here is the call graph for this function:

◆ simpleDeltaFromStrike()

Real simpleDeltaFromStrike ( const Real strike ) const

private

Definition at line 201 of file blackvolsurfacebfrr.cpp.

                                                                                {
    if (close_enough(strike, 0.0))
        return 0.0;
    CumulativeNormalDistribution Phi;
    return Phi(std::log(strike / forward_) / (atmVol_ * std::sqrt(expiryTime_)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ spot_

Real spot_

private

Definition at line 137 of file blackvolsurfacebfrr.hpp.

◆ domDisc_

Real domDisc_

private

Definition at line 137 of file blackvolsurfacebfrr.hpp.

◆ forDisc_

Real forDisc_

private

Definition at line 137 of file blackvolsurfacebfrr.hpp.

◆ expiryTime_

Real expiryTime_

private

Definition at line 137 of file blackvolsurfacebfrr.hpp.

◆ deltas_

std::vector<Real> deltas_

private

Definition at line 138 of file blackvolsurfacebfrr.hpp.

◆ putVols_

std::vector<Real> putVols_

private

Definition at line 138 of file blackvolsurfacebfrr.hpp.

◆ callVols_

std::vector<Real> callVols_

private

Definition at line 138 of file blackvolsurfacebfrr.hpp.

◆ atmVol_

Real atmVol_

private

Definition at line 139 of file blackvolsurfacebfrr.hpp.

◆ dt_

DeltaVolQuote::DeltaType dt_

private

Definition at line 140 of file blackvolsurfacebfrr.hpp.

◆ at_

DeltaVolQuote::AtmType at_

private

Definition at line 141 of file blackvolsurfacebfrr.hpp.

◆ smileInterpolation_

BlackVolatilitySurfaceBFRR::SmileInterpolation smileInterpolation_

private

Definition at line 142 of file blackvolsurfacebfrr.hpp.

◆ accuracy_

Real accuracy_

private

Definition at line 143 of file blackvolsurfacebfrr.hpp.

◆ maxIterations_

Size maxIterations_

private

Definition at line 144 of file blackvolsurfacebfrr.hpp.

◆ forward_

Real forward_

private

Definition at line 146 of file blackvolsurfacebfrr.hpp.

◆ x_

std::vector<Real> x_

private

Definition at line 147 of file blackvolsurfacebfrr.hpp.

◆ y_

std::vector<Real> y_

private

Definition at line 147 of file blackvolsurfacebfrr.hpp.

◆ interpolation_

QuantLib::ext::shared_ptr<Interpolation> interpolation_

private

Definition at line 148 of file blackvolsurfacebfrr.hpp.

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SimpleDeltaInterpolatedSmile()

Member Function Documentation

◆ volatilityAtSimpleDelta()

◆ volatility()

◆ strikeFromDelta()

◆ atmStrike()

◆ simpleDeltaFromStrike()

Member Data Documentation

◆ spot_

◆ domDisc_

◆ forDisc_

◆ expiryTime_

◆ deltas_

◆ putVols_

◆ callVols_

◆ atmVol_

◆ dt_

◆ at_

◆ smileInterpolation_

◆ accuracy_

◆ maxIterations_

◆ forward_

◆ x_

◆ y_

◆ interpolation_