BlackIndexCdsOptionEngine Class Reference

#include <qle/pricingengines/blackindexcdsoptionengine.hpp>

Inheritance diagram for BlackIndexCdsOptionEngine:

Collaboration diagram for BlackIndexCdsOptionEngine:

Public Member Functions
	IndexCdsOptionBaseEngine (const QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > &probability, QuantLib::Real recovery, const Handle< YieldTermStructure > &discountSwapCurrency, const Handle< YieldTermStructure > &discountTradeCollateral, const QuantLib::Handle< QuantExt::CreditVolCurve > &volatility)
	Constructor taking a default probability term structure bootstrapped from the index spreads. More...
	IndexCdsOptionBaseEngine (const std::vector< QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > > &probabilities, const std::vector< QuantLib::Real > &recoveries, const Handle< YieldTermStructure > &discountSwapCurrency, const Handle< YieldTermStructure > &discountTradeCollateral, const QuantLib::Handle< QuantExt::CreditVolCurve > &volatility, QuantLib::Real indexRecovery=QuantLib::Null< QuantLib::Real >())
Public Member Functions inherited from IndexCdsOptionBaseEngine
	IndexCdsOptionBaseEngine (const QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > &probability, QuantLib::Real recovery, const Handle< YieldTermStructure > &discountSwapCurrency, const Handle< YieldTermStructure > &discountTradeCollateral, const QuantLib::Handle< QuantExt::CreditVolCurve > &volatility)
	Constructor taking a default probability term structure bootstrapped from the index spreads. More...
	IndexCdsOptionBaseEngine (const std::vector< QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > > &probabilities, const std::vector< QuantLib::Real > &recoveries, const Handle< YieldTermStructure > &discountSwapCurrency, const Handle< YieldTermStructure > &discountTradeCollateral, const QuantLib::Handle< QuantExt::CreditVolCurve > &volatility, QuantLib::Real indexRecovery=QuantLib::Null< QuantLib::Real >())
const std::vector< QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > > &	probabilities () const
const std::vector< QuantLib::Real > &	recoveries () const
const QuantLib::Handle< QuantLib::YieldTermStructure >	discountSwapCurrency () const
const QuantLib::Handle< QuantLib::YieldTermStructure >	discountTradeCollateral () const
const QuantLib::Handle< QuantExt::CreditVolCurve >	volatility () const
void	calculate () const override

Private Member Functions
void	doCalc () const override
	Engine specific calculation. More...
void	spreadStrikeCalculate (QuantLib::Real fep) const
void	priceStrikeCalculate (QuantLib::Real fep) const
QuantLib::Real	forwardRiskyAnnuityStrike () const

Additional Inherited Members
Protected Member Functions inherited from IndexCdsOptionBaseEngine
void	registerWithMarket ()
	Register with market data. More...
QuantLib::Real	fep () const
	Calculate the discounted value of the front end protection. More...
Protected Attributes inherited from IndexCdsOptionBaseEngine
std::vector< QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > >	probabilities_
	Store inputs. More...
std::vector< QuantLib::Real >	recoveries_
QuantLib::Handle< QuantLib::YieldTermStructure >	discountSwapCurrency_
QuantLib::Handle< QuantLib::YieldTermStructure >	discountTradeCollateral_
QuantLib::Handle< QuantExt::CreditVolCurve >	volatility_
QuantLib::Real	indexRecovery_
	Assumed index recovery used in the flat strike spread curve calculation if provided. More...
std::vector< QuantLib::Real >	notionals_
	Store the underlying index CDS notional(s) during calculation. More...

Detailed Description

Black index CDS option engine

Prices index CDS option instruments quoted in terms of strike spread or strike price. If the strike is in terms of spread, it is assumed that the volatility structure's strike dimension, if there is one, is in terms of spread also. This is the standard quotation convention for investment grade index families like CDX IG and ITraxx Europe. If the strike is in terms of price, it is assumed that the volatility structure's strike dimension, if there is one, is in terms of price also. This is the standard quotation convention for high yield index families like CDX HY and CDX EM.

The valuation of the index CDS options with strike price is a reasonably straightforward application of Black's formula. The approach is outlined for example in Mark-to-market Credit Index Option Pricing and Credit Volatility Index, John Yang and Lukasz Dobrek, 23 June 2015, Section 1.1. Here, we calculate the front end protection (FEP) adjusted forward price as opposed to deriving it from the market quotes of payer and receiver CDS options with the same strike.

The valuation of the index CDS options with strike spread follows the approach outlined in Modelling Single-name and Multi-name Credit Derivatives, Dominic O'Kane, 2008, Section 11.7. This is also the approach outlined in Credit Index Option, ICE, 2018.

Definition at line 48 of file blackindexcdsoptionengine.hpp.

Member Function Documentation

doCalc()

void doCalc ( ) const

overrideprivatevirtual

Engine specific calculation.

Implements IndexCdsOptionBaseEngine.

Definition at line 38 of file blackindexcdsoptionengine.cpp.

                                             {
    // Calculate option value depending on strike type.
    if (arguments_.strikeType == CdsOption::Spread)
        spreadStrikeCalculate(fep());
    else
        priceStrikeCalculate(fep());
}

Here is the call graph for this function:

spreadStrikeCalculate()

void spreadStrikeCalculate ( QuantLib::Real  fep ) const

private

Definition at line 46 of file blackindexcdsoptionengine.cpp.

                                                                    {
 
    const Date& exerciseDate = arguments_.exercise->dates().front();
    Real exerciseTime = volatility_->timeFromReference(exerciseDate);
    const auto& cds = *arguments_.swap;
    const Real& strike = arguments_.strike;
    results_.additionalResults["strikeSpread"] = strike;
    Real runningSpread = cds.runningSpread();
    results_.additionalResults["runningSpread"] = runningSpread;
 
    DiscountFactor discTradeCollToExercise = discountTradeCollateral_->discount(exerciseDate);
    DiscountFactor discSwapCurrToExercise = discountSwapCurrency_->discount(exerciseDate);
    results_.additionalResults["discountToExerciseTradeCollateral"] = discTradeCollToExercise;
    results_.additionalResults["discountToExerciseSwapCurrency"] = discSwapCurrToExercise;
 
    // Calculate the risky annuity
    Real rpv01 = std::abs(cds.couponLegNPV() + cds.accrualRebateNPV()) / (cds.notional() * cds.runningSpread());
    results_.additionalResults["riskyAnnuity"] = rpv01;
    QL_REQUIRE(cds.notional() > 0.0 || close_enough(cds.notional(), 0.0),
               "BlackIndexCdsOptionEngine: notional must not be negative (" << cds.notional() << ")");
    QL_REQUIRE(rpv01 > 0.0, "BlackIndexCdsOptionEngine: risky annuity must be positive (couponLegNPV="
                                << cds.couponLegNPV() << ", accrualRebateNPV=" << cds.accrualRebateNPV()
                                << ", notional=" << cds.notional() << ", runningSpread=" << cds.runningSpread() << ")");
 
    Real fairSpread = cds.fairSpreadClean();
    results_.additionalResults["forwardSpread"] = fairSpread;
 
    // FEP adjusted forward spread. F^{Adjusted} in O'Kane 2008, Section 11.7. F' in ICE paper (notation is poor).
    Real Fp = fairSpread + fep * (Settlement::Cash ? discSwapCurrToExercise : discTradeCollToExercise) / rpv01 /
                               discTradeCollToExercise / cds.notional();
    results_.additionalResults["fepAdjustedForwardSpread"] = Fp;
 
    // Adjusted strike spread. K' in O'Kane 2008, Section 11.7. K' in ICE paper (notation is poor).
    Real Kp = close_enough(strike, 0.0)
                  ? 0.0
                  : runningSpread + arguments_.tradeDateNtl / cds.notional() * forwardRiskyAnnuityStrike() *
                                        (strike - runningSpread) *
                                        (Settlement::Cash ? discSwapCurrToExercise : discTradeCollToExercise) / rpv01;
    results_.additionalResults["adjustedStrikeSpread"] = Kp;
 
    // Read the volatility from the volatility surface
    Real volatility = volatility_->volatility(exerciseDate, QuantExt::periodToTime(arguments_.indexTerm), strike,
                                              CreditVolCurve::Type::Spread);
    Real stdDev = volatility * std::sqrt(exerciseTime);
    results_.additionalResults["volatility"] = volatility;
    results_.additionalResults["standardDeviation"] = stdDev;
 
    // Option type
    Option::Type callPut = cds.side() == Protection::Buyer ? Option::Call : Option::Put;
    results_.additionalResults["callPut"] = callPut == Option::Call ? string("Call") : string("Put");
 
    // NPV. Add the relevant notionals to the additional results also.
    results_.additionalResults["valuationDateNotional"] = cds.notional();
    results_.additionalResults["tradeDateNotional"] = arguments_.tradeDateNtl;
 
    // Check the forward before plugging it into the black formula
    QL_REQUIRE(Fp > 0.0 || close_enough(stdDev, 0.0),
               "BlackIndexCdsOptionEngine: FEP adjusted forward spread ("
                   << Fp << ") is not positive, can not calculate a reasonable option price");
    // The strike spread might get negative through the adjustment above, but economically the strike is
    // floored at 0.0, so we ensure this here. This lets us compute the black formula as well in all cases.
    Kp = std::max(Kp, 0.0);
 
    results_.value = discTradeCollToExercise / (Settlement::Cash ? discSwapCurrToExercise : discTradeCollToExercise) *
                     rpv01 * cds.notional() * blackFormula(callPut, Kp, Fp, stdDev, 1.0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

priceStrikeCalculate()

void priceStrikeCalculate ( QuantLib::Real  fep ) const

private

Definition at line 113 of file blackindexcdsoptionengine.cpp.

                                                                   {
 
    // Underlying index CDS.
    const auto& cds = *arguments_.swap;
 
    // Add some additional entries to additional results.
    results_.additionalResults["strikePrice"] = arguments_.strike;
 
    const Real& tradeDateNtl = arguments_.tradeDateNtl;
    results_.additionalResults["valuationDateNotional"] = cds.notional();
    results_.additionalResults["tradeDateNotional"] = tradeDateNtl;
 
    // effective strike (strike is expressed w.r.t. trade date notional by market convention)
    Real effStrike = 1.0 - tradeDateNtl / cds.notional() * (1.0 - arguments_.strike);
    results_.additionalResults["strikePriceDefaultAdjusted"] = effStrike;
 
    // Discount factor to exercise
    const Date& exerciseDate = arguments_.exercise->dates().front();
    Real exerciseTime = volatility_->timeFromReference(exerciseDate);
    DiscountFactor discTradeCollToExercise = discountTradeCollateral_->discount(exerciseDate);
    DiscountFactor discSwapCurrToExercise = discountSwapCurrency_->discount(exerciseDate);
    results_.additionalResults["discountToExerciseTradeCollateral"] = discTradeCollToExercise;
    results_.additionalResults["discountToExerciseSwapCurrency"] = discSwapCurrToExercise;
 
    // NPV from buyer's perspective gives upfront, as of valuation date, with correct sign.
    Real npv = cds.side() == Protection::Buyer ? cds.NPV() : -cds.NPV();
    results_.additionalResults["upfront"] =
        npv * (arguments_.settlementType == Settlement::Cash ? discTradeCollToExercise / discSwapCurrToExercise : 1.0);
 
    Real forwardPrice =
        1 - npv / cds.notional() / (Settlement::Cash ? discSwapCurrToExercise : discTradeCollToExercise);
    results_.additionalResults["forwardPrice"] = forwardPrice;
 
    // Front end protection adjusted forward price.
    Real Fp = forwardPrice - fep / cds.notional() / discTradeCollToExercise;
    results_.additionalResults["fepAdjustedForwardPrice"] = Fp;
 
    // Read the volatility from the volatility surface
    Real volatility = volatility_->volatility(exerciseDate, QuantExt::periodToTime(arguments_.indexTerm), effStrike,
                                              CreditVolCurve::Type::Price);
    Real stdDev = volatility * std::sqrt(exerciseTime);
    results_.additionalResults["volatility"] = volatility;
    results_.additionalResults["standardDeviation"] = stdDev;
 
    // If protection buyer, put on price.
    Option::Type cp = cds.side() == Protection::Buyer ? Option::Put : Option::Call;
    results_.additionalResults["callPut"] = cp == Option::Put ? string("Put") : string("Call");
 
    // Check the inputs to the black formula before applying it
    QL_REQUIRE(Fp > 0.0 || close_enough(stdDev, 0.0),
               "BlackIndexCdsOptionEngine: FEP adjusted forward price ("
                   << Fp << ") is not positive, can not calculate a reasonable option price");
    QL_REQUIRE(effStrike > 0 || close_enough(effStrike, 0.0),
               "BlackIndexCdsOptionEngine: Effective Strike price ("
                   << effStrike << ") is not positive, can not calculate a reasonable option price");
 
    results_.value = cds.notional() * blackFormula(cp, effStrike, Fp, stdDev, discTradeCollToExercise);
}

Here is the call graph for this function:

Here is the caller graph for this function:

forwardRiskyAnnuityStrike()

Real forwardRiskyAnnuityStrike ( ) const

private

Definition at line 172 of file blackindexcdsoptionengine.cpp.

                                                                {
 
    // Underlying index CDS.
    const auto& cds = *arguments_.swap;
 
    // This method returns RPV01(0; t_e, T, K) / SP(t_e; K). This is the quantity in formula 11.9 of O'Kane 2008.
    // There is a slight modification in that we divide by the survival probability to t_E using the flat curve at
    // the strike spread that we create here.
 
    // Standard index CDS schedule.
    Schedule schedule = MakeSchedule()
                            .from(cds.protectionStartDate())
                            .to(cds.maturity())
                            .withCalendar(WeekendsOnly())
                            .withFrequency(Quarterly)
                            .withConvention(Following)
                            .withTerminationDateConvention(Unadjusted)
                            .withRule(DateGeneration::CDS2015);
 
    // Derive hazard rate curve from a single forward starting CDS matching the characteristics of underlying index
    // CDS with a running spread equal to the strike.
    const Real& strike = arguments_.strike;
    Real accuracy = 1e-8;
 
    auto strikeCds = QuantLib::ext::make_shared<CreditDefaultSwap>(
        Protection::Buyer, 1 / accuracy, strike, schedule, Following, Actual360(), cds.settlesAccrual(),
        cds.protectionPaymentTime(), cds.protectionStartDate(), QuantLib::ext::shared_ptr<Claim>(), Actual360(true),
        true, cds.tradeDate(), cds.cashSettlementDays());
    // dummy engine
    strikeCds->setPricingEngine(QuantLib::ext::make_shared<MidPointCdsEngine>(
        Handle<DefaultProbabilityTermStructure>(
            QuantLib::ext::make_shared<FlatHazardRate>(0, NullCalendar(), 0.0, Actual365Fixed())),
        0.0, Handle<YieldTermStructure>(QuantLib::ext::make_shared<FlatForward>(0, NullCalendar(), 0.0, Actual365Fixed()))));
 
    Real hazardRate;
    try {
        hazardRate =
            strikeCds->impliedHazardRate(0.0, discountSwapCurrency_, Actual365Fixed(), indexRecovery_, accuracy);
    } catch (const std::exception& e) {
        QL_FAIL("can not imply fair hazard rate for CDS at option strike "
                << strike << ". Is the strike correct? Exception: " << e.what());
    }
 
    Handle<DefaultProbabilityTermStructure> dph(
        QuantLib::ext::make_shared<FlatHazardRate>(discountSwapCurrency_->referenceDate(), hazardRate, Actual365Fixed()));
 
    // Calculate the forward risky strike annuity.
    strikeCds->setPricingEngine(
        QuantLib::ext::make_shared<QuantExt::MidPointCdsEngine>(dph, indexRecovery_, discountSwapCurrency_));
    Real rpv01_K = std::abs(strikeCds->couponLegNPV() + strikeCds->accrualRebateNPV()) /
                   (strikeCds->notional() * strikeCds->runningSpread());
    results_.additionalResults["riskyAnnuityStrike"] = rpv01_K;
    QL_REQUIRE(rpv01_K > 0.0, "BlackIndexCdsOptionEngine: strike based risky annuity must be positive.");
 
    // Survival to exercise
    const Date& exerciseDate = arguments_.exercise->dates().front();
    Probability spToExercise = dph->survivalProbability(exerciseDate);
    Real discToExercise = discountSwapCurrency_->discount(exerciseDate);
    results_.additionalResults["strikeBasedSurvivalToExercise"] = spToExercise;
 
    // Forward risky annuity strike (divides out the survival probability and discount to exercise)
    Real rpv01_K_fwd = rpv01_K / spToExercise / discToExercise;
    results_.additionalResults["forwardRiskyAnnuityStrike"] = rpv01_K_fwd;
 
    return rpv01_K_fwd;
}

Here is the caller graph for this function:

IndexCdsOptionBaseEngine() [1/2]

IndexCdsOptionBaseEngine	(	const QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > &	probability,
		QuantLib::Real	recovery,
		const Handle< YieldTermStructure > &	discountSwapCurrency,
		const Handle< YieldTermStructure > &	discountTradeCollateral,
		const QuantLib::Handle< QuantExt::CreditVolCurve > &	volatility
	)

Constructor taking a default probability term structure bootstrapped from the index spreads.

IndexCdsOptionBaseEngine() [2/2]

IndexCdsOptionBaseEngine	(	const std::vector< QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > > &	probabilities,
		const std::vector< QuantLib::Real > &	recoveries,
		const Handle< YieldTermStructure > &	discountSwapCurrency,
		const Handle< YieldTermStructure > &	discountTradeCollateral,
		const QuantLib::Handle< QuantExt::CreditVolCurve > &	volatility,
		QuantLib::Real	indexRecovery = QuantLib::Null<QuantLib::Real>()
	)

Constructor taking a vector of default probability term structures bootstrapped from the index constituent spread curves and a vector of associated recovery rates.