Class that converts a supplied SwaptionVolatilityStructure to one of another type with possibly different shifts. More...

#include <qle/termstructures/swaptionvolatilityconverter.hpp>

Collaboration diagram for SwaptionVolatilityConverter:

Public Member Functions
	SwaptionVolatilityConverter (const Date &asof, const QuantLib::ext::shared_ptr< SwaptionVolatilityStructure > &svsIn, const Handle< YieldTermStructure > &discount, const Handle< YieldTermStructure > &shortDiscount, const QuantLib::ext::shared_ptr< SwapConventions > &conventions, const QuantLib::ext::shared_ptr< SwapConventions > &shortConventions, const Period &conventionsTenor, const Period &shortConventionsTenor, const VolatilityType targetType, const Matrix &targetShifts=Matrix())
	Construct from SwapConventions. More...

	SwaptionVolatilityConverter (const Date &asof, const QuantLib::ext::shared_ptr< SwaptionVolatilityStructure > &svsIn, const QuantLib::ext::shared_ptr< SwapIndex > &swapIndex, const QuantLib::ext::shared_ptr< SwapIndex > &shortSwapIndex, const VolatilityType targetType, const Matrix &targetShifts=Matrix())
	Construct from SwapIndex. More...

QuantLib::ext::shared_ptr< SwaptionVolatilityStructure >	convert () const
	Method that returns the converted `SwaptionVolatilityStructure` More...

Real	convert (const Date &expiry, const Period &swapTenor, Real strikeSpread, const DayCounter &volDayCounter, VolatilityType outType, Real outShift=0.0) const

Real &	accuracy ()
	Set implied volatility solver accuracy. More...

Natural &	maxEvaluations ()
	Set implied volatility solver max evaluations. More...

Private Member Functions
void	checkInputs () const

QuantLib::ext::shared_ptr< SwaptionVolatilityStructure >	convert (const QuantLib::ext::shared_ptr< SwaptionVolatilityMatrix > &svMatrix) const

Private Attributes
const Date	asof_

const QuantLib::ext::shared_ptr< SwaptionVolatilityStructure >	svsIn_

Handle< YieldTermStructure >	discount_

Handle< YieldTermStructure >	shortDiscount_

const QuantLib::ext::shared_ptr< SwapConventions >	conventions_

const QuantLib::ext::shared_ptr< SwapConventions >	shortConventions_

const Period	conventionsTenor_

const Period	shortConventionsTenor_

const VolatilityType	targetType_

const Matrix	targetShifts_

Real	accuracy_

Natural	maxEvaluations_

Static Private Attributes
static const Volatility	minVol_ = 1.0e-7

static const Volatility	maxVol_ = 10.0

static const Real	minVega_ = 1.0e-6

Detailed Description

Class that converts a supplied SwaptionVolatilityStructure to one of another type with possibly different shifts.

Warning:: the converted SwaptionVolatilityStructure object has a fixed reference date equal to asof and fixed market data regardless of the type of reference date and market data of the original SwaptionVolatilityStructure that is passed in

Definition at line 74 of file swaptionvolatilityconverter.hpp.

Constructor & Destructor Documentation

◆ SwaptionVolatilityConverter() [1/2]

SwaptionVolatilityConverter	(	const Date &	asof,
		const QuantLib::ext::shared_ptr< SwaptionVolatilityStructure > &	svsIn,
		const Handle< YieldTermStructure > &	discount,
		const Handle< YieldTermStructure > &	shortDiscount,
		const QuantLib::ext::shared_ptr< SwapConventions > &	conventions,
		const QuantLib::ext::shared_ptr< SwapConventions > &	shortConventions,
		const Period &	conventionsTenor,
		const Period &	shortConventionsTenor,
		const VolatilityType	targetType,
		const Matrix &	targetShifts = `Matrix()`
	)

Construct from SwapConventions.

Definition at line 38 of file swaptionvolatilityconverter.cpp.

    : asof_(asof), svsIn_(svsIn), discount_(discount), shortDiscount_(shortDiscount), conventions_(conventions),
      shortConventions_(shortConventions), conventionsTenor_(conventionsTenor),
      shortConventionsTenor_(shortConventionsTenor), targetType_(targetType), targetShifts_(targetShifts),
      accuracy_(1.0e-5), maxEvaluations_(100) {
 
    // Some checks
    checkInputs();
}

Here is the call graph for this function:

◆ SwaptionVolatilityConverter() [2/2]

SwaptionVolatilityConverter	(	const Date &	asof,
		const QuantLib::ext::shared_ptr< SwaptionVolatilityStructure > &	svsIn,
		const QuantLib::ext::shared_ptr< SwapIndex > &	swapIndex,
		const QuantLib::ext::shared_ptr< SwapIndex > &	shortSwapIndex,
		const VolatilityType	targetType,
		const Matrix &	targetShifts = `Matrix()`
	)

Construct from SwapIndex.

Definition at line 53 of file swaptionvolatilityconverter.cpp.

    : asof_(asof), svsIn_(svsIn), discount_(swapIndex->discountingTermStructure()),
      shortDiscount_(shortSwapIndex->discountingTermStructure()),
      conventions_(QuantLib::ext::make_shared<SwapConventions>(swapIndex->fixingDays(), swapIndex->fixedLegTenor(),
                                                       swapIndex->fixingCalendar(), swapIndex->fixedLegConvention(),
                                                       swapIndex->dayCounter(), swapIndex->iborIndex())),
      shortConventions_(QuantLib::ext::make_shared<SwapConventions>(
          shortSwapIndex->fixingDays(), shortSwapIndex->fixedLegTenor(), shortSwapIndex->fixingCalendar(),
          shortSwapIndex->fixedLegConvention(), shortSwapIndex->dayCounter(), shortSwapIndex->iborIndex())),
      conventionsTenor_(swapIndex->tenor()), shortConventionsTenor_(shortSwapIndex->tenor()), targetType_(targetType),
      targetShifts_(targetShifts), accuracy_(1.0e-5), maxEvaluations_(100) {
 
    // Some checks
    if (discount_.empty())
        discount_ = swapIndex->iborIndex()->forwardingTermStructure();
    if (shortDiscount_.empty())
        shortDiscount_ = shortSwapIndex->iborIndex()->forwardingTermStructure();
    checkInputs();
}

Here is the call graph for this function:

Member Function Documentation

◆ convert() [1/3]

QuantLib::ext::shared_ptr< SwaptionVolatilityStructure > convert ( ) const

Method that returns the converted SwaptionVolatilityStructure

Definition at line 87 of file swaptionvolatilityconverter.cpp.

                                                                                              {
 
    QuantLib::ext::shared_ptr<SwaptionVolatilityDiscrete> svDisc;
 
    // We expect either the wrapper adding ATM to a cube or a swaption vol discrete
    // instance (like a matrix, a regular cube).
 
    vector<Real> strikeSpreads(1, 0.0);
    QuantLib::ext::shared_ptr<SwapIndex> swapIndexBase, shortSwapIndexBase;
    QuantLib::ext::shared_ptr<SwaptionVolatilityCube> cube;
    if (QuantLib::ext::dynamic_pointer_cast<SwaptionVolCubeWithATM>(svsIn_)) {
        cube = QuantLib::ext::static_pointer_cast<SwaptionVolCubeWithATM>(svsIn_)->cube();
    }
    if (QuantLib::ext::dynamic_pointer_cast<SwaptionVolatilityCube>(svsIn_)) {
        cube = QuantLib::ext::static_pointer_cast<SwaptionVolatilityCube>(svsIn_);
    }
    if (cube) {
        svDisc = cube;
        strikeSpreads = cube->strikeSpreads();
        swapIndexBase = cube->swapIndexBase();
        shortSwapIndexBase = cube->shortSwapIndexBase();
    } else if (QuantLib::ext::dynamic_pointer_cast<SwaptionVolatilityDiscrete>(svsIn_)) {
        svDisc = QuantLib::ext::static_pointer_cast<SwaptionVolatilityDiscrete>(svsIn_);
    } else {
        QL_FAIL("SwaptionVolatilityConverter: unknown input volatility structure");
    }
 
    // Some aspects of original volatility structure that we will need
    DayCounter dayCounter = svDisc->dayCounter();
    bool extrapolation = svDisc->allowsExtrapolation();
    Calendar calendar = svDisc->calendar();
    BusinessDayConvention bdc = svDisc->businessDayConvention();
 
    const vector<Date>& optionDates = svDisc->optionDates();
    const vector<Period>& optionTenors = svDisc->optionTenors();
    const vector<Period>& swapTenors = svDisc->swapTenors();
    const vector<Time>& optionTimes = svDisc->optionTimes();
    const vector<Time>& swapLengths = svDisc->swapLengths();
    Size nOptionTimes = optionTimes.size();
    Size nSwapLengths = swapLengths.size();
    Size nStrikeSpreads = strikeSpreads.size();
 
    Real targetShift = 0.0;
 
    // If target type is ShiftedLognormal and shifts are provided, check size
    if (targetType_ == ShiftedLognormal && !targetShifts_.empty()) {
        QL_REQUIRE(targetShifts_.rows() == nOptionTimes,
                   "SwaptionVolatilityConverter: number of shift rows does not equal the number of option tenors");
        QL_REQUIRE(targetShifts_.columns() == nSwapLengths,
                   "SwaptionVolatilityConverter: number of shift columns does not equal the number of swap tenors");
    }
 
    // Calculate the converted ATM volatilities
    Matrix volatilities(nOptionTimes, nSwapLengths);
    for (Size i = 0; i < nOptionTimes; ++i) {
        for (Size j = 0; j < nSwapLengths; ++j) {
            if (!targetShifts_.empty())
                targetShift = targetShifts_[i][j];
            volatilities[i][j] = convert(optionDates[i], swapTenors[j], 0.0, dayCounter, targetType_, targetShift);
        }
    }
 
    // Build ATM matrix
    Handle<SwaptionVolatilityStructure> atmStructure;
    if (calendar.empty() || optionTenors.empty()) {
        // Original matrix was created with fixed option dates
        atmStructure = Handle<SwaptionVolatilityStructure>(
            QuantLib::ext::make_shared<SwaptionVolatilityMatrix>(asof_, calendar, bdc, optionDates, swapTenors, volatilities,
                                                         Actual365Fixed(), extrapolation, targetType_, targetShifts_));
    } else {
        atmStructure = Handle<SwaptionVolatilityStructure>(QuantLib::ext::shared_ptr<SwaptionVolatilityMatrix>(
            new SwaptionVolatilityMatrix(asof_, calendar, bdc, optionTenors, swapTenors, volatilities, Actual365Fixed(),
                                         extrapolation, targetType_, targetShifts_)));
    }
 
    // no cube input => we are done
    if (!cube)
        return *atmStructure;
 
    // convert non-ATM volatilities, note that we use the ATM option tenors and swap tenors here!
 
    std::vector<std::vector<Handle<Quote> > > volSpreads(nOptionTimes * nSwapLengths,
                                                         std::vector<Handle<Quote> >(nStrikeSpreads));
    for (Size k = 0; k < nStrikeSpreads; ++k) {
        for (Size i = 0; i < nOptionTimes; ++i) {
            for (Size j = 0; j < nSwapLengths; ++j) {
                if (!targetShifts_.empty())
                    targetShift = targetShifts_[i][j];
                Real outVol =
                    convert(optionDates[i], swapTenors[j], strikeSpreads[k], dayCounter, targetType_, targetShift);
                volSpreads[i * nSwapLengths + j][k] = Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(outVol));
            }
        }
    }
 
    // Build and return cube, note that we hardcode flat extrapolation
    QuantLib::ext::shared_ptr<SwaptionVolatilityCube> cubeOut = QuantLib::ext::shared_ptr<QuantExt::SwaptionVolCube2>(
        new QuantExt::SwaptionVolCube2(atmStructure, optionTenors, swapTenors, strikeSpreads, volSpreads, swapIndexBase,
                                       shortSwapIndexBase, false, true, false));
    cubeOut->enableExtrapolation(cube->allowsExtrapolation());
    return QuantLib::ext::make_shared<SwaptionVolCubeWithATM>(cubeOut);
 
} // namespace QuantExt

Here is the call graph for this function:

Here is the caller graph for this function:

◆ convert() [2/3]

Real convert	(	const Date &	expiry,
		const Period &	swapTenor,
		Real	strikeSpread,
		const DayCounter &	volDayCounter,
		VolatilityType	outType,
		Real	outShift = `0.0`
	)		const

Definition at line 191 of file swaptionvolatilityconverter.cpp.

                                                               {
 
    const QuantLib::ext::shared_ptr<SwapConventions> tmpConv =
        swapTenor <= shortConventionsTenor_ ? shortConventions_ : conventions_;
    Handle<YieldTermStructure> tmpDiscount = swapTenor <= shortConventionsTenor_ ? shortDiscount_ : discount_;
 
    // Create the underlying swap with fixed rate = fair rate
    // We rely on the fact that MakeVanillaSwap sets the fixed rate to the fair rate if it is left null in the ctor
    Date effectiveDate = tmpConv->fixedCalendar().advance(expiry, tmpConv->settlementDays(), Days);
    QuantLib::ext::shared_ptr<PricingEngine> engine = QuantLib::ext::make_shared<DiscountingSwapEngine>(tmpDiscount);
    QuantLib::ext::shared_ptr<VanillaSwap> swap = MakeVanillaSwap(swapTenor, tmpConv->floatIndex())
                                              .withType(strikeSpread < 0.0 ? VanillaSwap::Receiver : VanillaSwap::Payer)
                                              .withEffectiveDate(effectiveDate)
                                              .withFixedLegCalendar(tmpConv->fixedCalendar())
                                              .withFixedLegDayCount(tmpConv->fixedDayCounter())
                                              .withFixedLegTenor(tmpConv->fixedTenor())
                                              .withFixedLegConvention(tmpConv->fixedConvention())
                                              .withFixedLegTerminationDateConvention(tmpConv->fixedConvention())
                                              .withFloatingLegSpread(0.0)
                                              .withPricingEngine(engine);
    // we need this also for non-atm swaps
    Rate atmRate = swap->fairRate(), strike;
    if (!close_enough(strikeSpread, 0.0)) {
        strike = atmRate + strikeSpread;
        swap = MakeVanillaSwap(swapTenor, tmpConv->floatIndex(), strike)
                   .withEffectiveDate(effectiveDate)
                   .withFixedLegTenor(tmpConv->fixedTenor())
                   .withFixedLegDayCount(tmpConv->fixedDayCounter())
                   .withFloatingLegSpread(0.0)
                   .withPricingEngine(engine);
    } else {
        strike = atmRate;
    }
 
    Real inShift = svsIn_->shift(expiry, swapTenor);
    VolatilityType inType = svsIn_->volatilityType();
 
    // if strike is invalid w.r.t. the given input or output vol types, return zero vol
    // (for a lognormal cube e.g. it is common that some effective strikes are negative)
    Real inMinStrike = inType == ShiftedLognormal ? -inShift : -QL_MAX_REAL;
    Real outMinStrike = outType == ShiftedLognormal ? -outShift : -QL_MAX_REAL;
    if (strike < inMinStrike || strike < outMinStrike)
        return 0.0;
 
    Real inVol = svsIn_->volatility(expiry, swapTenor, strike);
 
    // Create the swaption
    QuantLib::ext::shared_ptr<Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(expiry);
    QuantLib::ext::shared_ptr<Swaption> swaption = QuantLib::ext::make_shared<Swaption>(swap, exercise, Settlement::Physical);
 
    // Price the swaption with the input volatility
    QuantLib::ext::shared_ptr<PricingEngine> swaptionEngine;
    if (inType == ShiftedLognormal) {
        swaptionEngine = QuantLib::ext::make_shared<BlackSwaptionEngine>(discount_, inVol, volDayCounter, inShift);
    } else {
        swaptionEngine = QuantLib::ext::make_shared<BachelierSwaptionEngine>(discount_, inVol, volDayCounter);
    }
    swaption->setPricingEngine(swaptionEngine);
 
    // zero might be the actual implied vol (if we e.g. convert from LN to N with a strike near zero),
    // but the Swaption::impliedVolatility function will not find this, so we check for this case
    // explicitly here
    Real vega = swaption->result<Real>("vega");
    if (vega < minVega_)
        return 0.0;
 
    Volatility impliedVol = 0.0;
    try {
        Real npv = swaption->NPV();
 
        // Calculate guess for implied volatility solver
        Real guess = 0.0;
        if (outType == ShiftedLognormal) {
            QL_REQUIRE(atmRate + outShift > 0.0, "SwaptionVolatilityConverter: ATM rate + shift must be > 0.0");
            if (inType == Normal)
                guess = inVol / (atmRate + outShift);
            else
                guess = inVol * (atmRate + inShift) / (atmRate + outShift);
        } else {
            if (inType == Normal)
                guess = inVol;
            else
                guess = inVol * (atmRate + inShift);
        }
 
        // Note: In implying the volatility the volatility day counter is hardcoded to Actual365Fixed
        impliedVol = swaption->impliedVolatility(npv, discount_, guess, accuracy_, maxEvaluations_, minVol_, maxVol_,
                                                 outType, outShift);
 
    } catch (std::exception& e) {
        // couldn't find implied volatility
        QL_FAIL("SwaptionVolatilityConverter: volatility conversion failed while trying to convert volatility"
                " for expiry "
                << expiry << " and swap tenor " << swapTenor << ". Error: " << e.what());
    }
 
    return impliedVol;
}

Here is the call graph for this function:

◆ accuracy()

Real & accuracy ( )

Set implied volatility solver accuracy.

Definition at line 98 of file swaptionvolatilityconverter.hpp.

98{ return accuracy_; }

◆ maxEvaluations()

Natural & maxEvaluations ( )

Set implied volatility solver max evaluations.

Definition at line 100 of file swaptionvolatilityconverter.hpp.

100{ return maxEvaluations_; }

◆ checkInputs()

void checkInputs ( ) const

private

Definition at line 77 of file swaptionvolatilityconverter.cpp.

                                                    {
    QL_REQUIRE(svsIn_->referenceDate() == asof_,
               "SwaptionVolatilityConverter requires the asof date and reference date to align");
    QL_REQUIRE(!discount_.empty() && discount_->referenceDate() == asof_,
               "SwaptionVolatilityConverter requires a valid discount curve with reference date equal to asof date");
    Handle<YieldTermStructure> forwardCurve = conventions_->floatIndex()->forwardingTermStructure();
    QL_REQUIRE(!forwardCurve.empty() && forwardCurve->referenceDate() == asof_,
               "SwaptionVolatilityConverter requires a valid forward curve with reference date equal to asof date");
}