Abstract base class for the option stripper. More...

#include <qle/termstructures/eqcommoptionsurfacestripper.hpp>

Inheritance diagram for OptionSurfaceStripper:

Collaboration diagram for OptionSurfaceStripper:

Classes
class	PriceError
	Function object used in solving. More...

Public Member Functions
	OptionSurfaceStripper (const QuantLib::ext::shared_ptr< OptionInterpolatorBase > &callSurface, const QuantLib::ext::shared_ptr< OptionInterpolatorBase > &putSurface, const QuantLib::Calendar &calendar, const QuantLib::DayCounter &dayCounter, QuantLib::Exercise::Type type=QuantLib::Exercise::European, bool lowerStrikeConstExtrap=true, bool upperStrikeConstExtrap=true, bool timeFlatExtrapolation=false, bool preferOutOfTheMoney=false, Solver1DOptions solverOptions={})

LazyObject interface
QuantLib::ext::shared_ptr< OptionInterpolatorBase >	callSurface_

QuantLib::ext::shared_ptr< OptionInterpolatorBase >	putSurface_

const QuantLib::Calendar &	calendar_

const QuantLib::DayCounter &	dayCounter_

QuantLib::Exercise::Type	type_

bool	lowerStrikeConstExtrap_

bool	upperStrikeConstExtrap_

bool	timeFlatExtrapolation_

bool	preferOutOfTheMoney_

QuantLib::ext::shared_ptr< QuantLib::BlackVolTermStructure >	volSurface_

Brent	brent_
	Solver used when implying volatility from price. More...

Solver1DOptions	solverOptions_

bool	havePrices_
	Set to `true` if we must strip volatilities from prices. More...

std::function< Real(const PriceError &)>	solver_
	Store the function that will be called each time to solve for volatility. More...

void	performCalculations () const override

QuantLib::ext::shared_ptr< QuantLib::BlackVolTermStructure >	volSurface ()
	Return the stripped volatility structure. More...

virtual QuantLib::ext::shared_ptr< QuantLib::GeneralizedBlackScholesProcess >	process (const QuantLib::ext::shared_ptr< QuantLib::SimpleQuote > &volatilityQuote) const =0
	Generate the relevant Black Scholes process for the underlying. More...

virtual QuantLib::Real	forward (const QuantLib::Date &date) const =0
	Return the forward price at a given date. More...

std::vector< QuantLib::Real >	strikes (const QuantLib::Date &expiry, bool isCall) const
	Retrieve the vector of strikes at a given expiry date. More...

QuantLib::Real	implyVol (QuantLib::Date expiry, QuantLib::Real strike, QuantLib::Option::Type type, QuantLib::ext::shared_ptr< QuantLib::PricingEngine > engine, QuantLib::SimpleQuote &volQuote) const

void	setUpSolver ()

Detailed Description

Abstract base class for the option stripper.

Definition at line 64 of file eqcommoptionsurfacestripper.hpp.

Constructor & Destructor Documentation

◆ OptionSurfaceStripper()

OptionSurfaceStripper	(	const QuantLib::ext::shared_ptr< OptionInterpolatorBase > &	callSurface,
		const QuantLib::ext::shared_ptr< OptionInterpolatorBase > &	putSurface,
		const QuantLib::Calendar &	calendar,
		const QuantLib::DayCounter &	dayCounter,
		QuantLib::Exercise::Type	type = `QuantLib::Exercise::European`,
		bool	lowerStrikeConstExtrap = `true`,
		bool	upperStrikeConstExtrap = `true`,
		bool	timeFlatExtrapolation = `false`,
		bool	preferOutOfTheMoney = `false`,
		Solver1DOptions	solverOptions = `{}`
	)

Definition at line 84 of file eqcommoptionsurfacestripper.cpp.

    : callSurface_(callSurface),
      putSurface_(putSurface),
      calendar_(calendar),
      dayCounter_(dayCounter),
      type_(type),
      lowerStrikeConstExtrap_(lowerStrikeConstExtrap),
      upperStrikeConstExtrap_(upperStrikeConstExtrap),
      timeFlatExtrapolation_(timeFlatExtrapolation),
      preferOutOfTheMoney_(preferOutOfTheMoney),
      solverOptions_(solverOptions),
      havePrices_(QuantLib::ext::dynamic_pointer_cast<OptionPriceSurface>(callSurface_)) {
 
    QL_REQUIRE(callSurface_->referenceDate() == putSurface_->referenceDate(),
        "Mismatch between Call and Put reference dates in OptionSurfaceStripper");
 
    registerWith(Settings::instance().evaluationDate());
 
    // Set up that is only needed if we have price based surfaces and we are stripping volatilities.
    if (havePrices_) {
 
        // Check that there is also a put price surface
        QL_REQUIRE(QuantLib::ext::dynamic_pointer_cast<OptionPriceSurface>(putSurface_),
            "OptionSurfaceStripper: call price surface provided but no put price surface.");
 
        setUpSolver();
    }
}

Here is the call graph for this function:

Member Function Documentation

◆ performCalculations()

void performCalculations ( ) const

override

Definition at line 141 of file eqcommoptionsurfacestripper.cpp.

                                                      {
 
    // Create a set of all expiries
    auto tmp = callSurface_->expiries();
    set<Date> allExpiries(tmp.begin(), tmp.end());
    tmp = putSurface_->expiries();
    allExpiries.insert(tmp.begin(), tmp.end());
 
    QuantLib::ext::shared_ptr<BlackVarianceSurfaceSparse> callVolSurface;
    QuantLib::ext::shared_ptr<BlackVarianceSurfaceSparse> putVolSurface;
 
    // Switch based on whether surface is direct volatilities or prices to be stripped.
    QuantLib::ext::shared_ptr<PricingEngine> engine;
    QuantLib::ext::shared_ptr<SimpleQuote> volQuote = QuantLib::ext::make_shared<SimpleQuote>(0.1);
    if (havePrices_) {
 
        // a black scholes process
        QuantLib::ext::shared_ptr<GeneralizedBlackScholesProcess> gbsp = process(volQuote);
 
        // hard code the engines here
        if (type_ == Exercise::American) {
            engine = QuantLib::ext::make_shared<QuantExt::BaroneAdesiWhaleyApproximationEngine>(gbsp);
        } else if (type_ == Exercise::European) {
            engine = QuantLib::ext::make_shared<QuantExt::AnalyticEuropeanEngine>(gbsp);
        } else {
            QL_FAIL("Unsupported exercise type for option stripping");
        }
 
    } else {
        // we have variance surfaces, explicitly cast so we can look up vol later
        callVolSurface = QuantLib::ext::dynamic_pointer_cast<BlackVarianceSurfaceSparse>(callSurface_);
        putVolSurface = QuantLib::ext::dynamic_pointer_cast<BlackVarianceSurfaceSparse>(putSurface_);
    }
 
    // Need to populate these below to feed to BlackVarianceSurfaceSparse
    vector<Real> volStrikes;
    vector<Real> volData;
    vector<Date> volExpiries;
 
    // Loop over each expiry
    for (const Date& expiry : allExpiries) {
 
        // Get the forward price at expiry
        Real fwd = forward(expiry);
 
        // Get the call and put strikes at the expiry date. Each may be empty.
        vector<Real> callStrikes = strikes(expiry, true);
        vector<Real> putStrikes = strikes(expiry, false);
 
        // We want a set of prices both sides of ATM forward
        // If preferOutOfTheMoney_ is false, we take calls where strike < atm and puts where strike > atm.
        // If preferOutOfTheMoney_ is true, we take calls where strike > atm and puts where strike < atm.
        auto relevantStrikes = createStrikes(fwd, callStrikes, putStrikes, preferOutOfTheMoney_);
        for (const auto& kv : relevantStrikes) {
            if (havePrices_) {
                // Only use the volatility if the root finding was successful
                Real v = implyVol(expiry, kv.first, kv.second, engine, *volQuote);
                if (v != Null<Real>()) {
                    volExpiries.push_back(expiry);
                    volStrikes.push_back(kv.first);
                    volData.push_back(v);
                }
            } else {
                volExpiries.push_back(expiry);
                volStrikes.push_back(kv.first);
                Real v = kv.second == Option::Call ? callVolSurface->blackVol(expiry, kv.first) :
                    putVolSurface->blackVol(expiry, kv.first);
                volData.push_back(v);
            }
        }
    }
 
    // Populate the variance surface.
    volSurface_ = QuantLib::ext::make_shared<BlackVarianceSurfaceSparse>(
        callSurface_->referenceDate(), calendar_, volExpiries, volStrikes, volData, dayCounter_,
        lowerStrikeConstExtrap_, upperStrikeConstExtrap_, timeFlatExtrapolation_);
}

Here is the call graph for this function:

◆ volSurface()

QuantLib::ext::shared_ptr< BlackVolTermStructure > volSurface ( )

Return the stripped volatility structure.

Definition at line 307 of file eqcommoptionsurfacestripper.cpp.

                                                                               {
    calculate();
    return volSurface_;
}

◆ process()

virtual QuantLib::ext::shared_ptr< QuantLib::GeneralizedBlackScholesProcess > process ( const QuantLib::ext::shared_ptr< QuantLib::SimpleQuote > & volatilityQuote ) const

protectedpure virtual

Generate the relevant Black Scholes process for the underlying.

Implemented in EquityOptionSurfaceStripper, and CommodityOptionSurfaceStripper.

Here is the caller graph for this function:

◆ forward()

virtual QuantLib::Real forward ( const QuantLib::Date & date ) const

protectedpure virtual

Return the forward price at a given date.

Implemented in EquityOptionSurfaceStripper, and CommodityOptionSurfaceStripper.

Here is the caller graph for this function:

◆ strikes()

vector< Real > strikes	(	const QuantLib::Date &	expiry,
		bool	isCall
	)		const

private

Retrieve the vector of strikes at a given expiry date.

Definition at line 219 of file eqcommoptionsurfacestripper.cpp.

                                                                                 {
 
    const QuantLib::ext::shared_ptr<OptionInterpolatorBase>& surface = isCall ? callSurface_ : putSurface_;
    auto expiries = surface->expiries();
    auto it = find(expiries.begin(), expiries.end(), expiry);
 
    if (it != expiries.end()) {
        return surface->strikes().at(distance(expiries.begin(), it));
    } else {
        return {};
    }
 
}

◆ implyVol()

Real implyVol	(	QuantLib::Date	expiry,
		QuantLib::Real	strike,
		QuantLib::Option::Type	type,
		QuantLib::ext::shared_ptr< QuantLib::PricingEngine >	engine,
		QuantLib::SimpleQuote &	volQuote
	)		const

private

Imply the volatility at a given expiry and strike for the given option type. The exercise type is indicated by the member variable type_ and the target price is read off the relevant price surface i.e. either callSurface_ or putSurface_.

If the root finding fails, a Null<Real>() is returned.

Definition at line 233 of file eqcommoptionsurfacestripper.cpp.

                                                                              {
 
    // Create the option instrument used in the solver.
    QuantLib::ext::shared_ptr<StrikedTypePayoff> payoff = QuantLib::ext::make_shared<PlainVanillaPayoff>(type, strike);
    QuantLib::ext::shared_ptr<Exercise> exercise;
    if (type_ == Exercise::American) {
        exercise = QuantLib::ext::make_shared<AmericanExercise>(expiry);
    } else if (type_ == Exercise::European) {
        exercise = QuantLib::ext::make_shared<EuropeanExercise>(expiry);
    } else {
        QL_FAIL("OptionSurfaceStripper: unsupported exercise type for option stripping.");
    }
    VanillaOption option(payoff, exercise);
    option.setPricingEngine(engine);
 
    // Get the target price from the surface.
    Real targetPrice = type == Option::Call ? callSurface_->getValue(expiry, strike)
        : putSurface_->getValue(expiry, strike);
 
    // Attempt to calculate the implied volatility.
    Real vol = Null<Real>();
    try {
        PriceError f(option, volQuote, targetPrice);
        vol = solver_(f);
    } catch (const Error&) {
    }
 
    return vol;
}

Here is the caller graph for this function:

◆ setUpSolver()

void setUpSolver ( )

private

Definition at line 264 of file eqcommoptionsurfacestripper.cpp.

                                        {
 
    // Check that enough solver options have been provided.
    const Real& guess = solverOptions_.initialGuess;
    QL_REQUIRE(guess != Null<Real>(), "OptionSurfaceStripper: need a valid initial " <<
        "guess for a price based surface.");
 
    const Real& accuracy = solverOptions_.accuracy;
    QL_REQUIRE(accuracy != Null<Real>(), "OptionSurfaceStripper: need a valid accuracy " <<
        "for a price based surface.");
 
    // Set maximum evaluations if provided.
    if (solverOptions_.maxEvaluations != Null<Size>())
        brent_.setMaxEvaluations(solverOptions_.maxEvaluations);
 
    // Check and set the lower bound and upper bound
    if (solverOptions_.lowerBound != Null<Real>() && solverOptions_.upperBound != Null<Real>()) {
        QL_REQUIRE(solverOptions_.lowerBound < solverOptions_.upperBound, "OptionSurfaceStripper: lowerBound (" <<
            solverOptions_.lowerBound << ") should be less than upperBound (" << solverOptions_.upperBound << ")");
    }
 
    if (solverOptions_.lowerBound != Null<Real>())
        brent_.setLowerBound(solverOptions_.lowerBound);
    if (solverOptions_.upperBound != Null<Real>())
        brent_.setUpperBound(solverOptions_.upperBound);
 
    // Choose a min/max or step solver based on parameters provided, favouring the min/max based version.
    const Real& min = solverOptions_.minMax.first;
    const Real& max = solverOptions_.minMax.second;
    const Real& step = solverOptions_.step;
    using std::placeholders::_1;
    if (min != Null<Real>() && max != Null<Real>()) {
        typedef Real (Brent::* MinMaxSolver)(const PriceError&, Real, Real, Real, Real) const;
        solver_ = std::bind(static_cast<MinMaxSolver>(&Brent::solve), &brent_, _1, accuracy, guess, min, max);
    } else if (step != Null<Real>()) {
        typedef Real(Brent::* StepSolver)(const PriceError&, Real, Real, Real) const;
        solver_ = std::bind(static_cast<StepSolver>(&Brent::solve), &brent_, _1, accuracy, guess, step);
    } else {
        QL_FAIL("OptionSurfaceStripper: need a valid step size or (min, max) pair for a price based surface.");
    }
 
}