swaptionvolatilityconverter.cpp File Reference

#include "swaptionmarketdata.hpp"
#include "toplevelfixture.hpp"
#include "yieldcurvemarketdata.hpp"
#include <boost/test/unit_test.hpp>
#include <qle/termstructures/swaptionvolatilityconverter.hpp>
#include <qle/termstructures/swaptionvolcube2.hpp>
#include <ql/indexes/swap/euriborswap.hpp>
#include <ql/pricingengines/blackformula.hpp>
#include <boost/assign/list_of.hpp>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (testNormalToLognormal)
	BOOST_AUTO_TEST_CASE (testLognormalToNormal)
	BOOST_AUTO_TEST_CASE (testNormalToShiftedLognormal)
	BOOST_AUTO_TEST_CASE (testShiftedLognormalToShiftedLognormal)
	BOOST_AUTO_TEST_CASE (testShiftedLognormalToNormal)
	BOOST_AUTO_TEST_CASE (testFailureImplyingVol)
	BOOST_AUTO_TEST_CASE (testNormalShiftsIgnored)
	BOOST_AUTO_TEST_CASE (testConstructionFromSwapIndex)
	BOOST_AUTO_TEST_CASE (testConstructionFromSwapIndexNoDiscount)
	BOOST_AUTO_TEST_CASE (testCube)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/10]

BOOST_AUTO_TEST_CASE

(

testNormalToLognormal

)

Definition at line 90 of file swaptionvolatilityconverter.cpp.

                                            {
    BOOST_TEST_MESSAGE("Testing conversion of swaption vols from normal to lognormal...");
 
    CommonVars vars;
 
    // Tolerance used in boost check
    Real tolerance = 0.00001;
 
    // Set up the converter (Normal -> Lognormal with no shifts)
    SwaptionVolatilityConverter converter(vars.referenceDate, vars.atmNormalVolMatrix, vars.yieldCurves.discountEonia,
                                          vars.yieldCurves.discountEonia, vars.swapConventions, vars.swapConventions,
                                          1 * Years, 30 * Years, ShiftedLognormal);
 
    // Get back converted volatility structure and test result on pillar points
    QuantLib::ext::shared_ptr<SwaptionVolatilityStructure> convertedsvs = converter.convert();
    Volatility targetVol = 0.0;
    Volatility outVol = 0.0;
    Real dummyStrike = 0.0;
    for (Size i = 0; i < vars.atmVols.optionTenors.size(); ++i) {
        for (Size j = 0; j < vars.atmVols.swapTenors.size(); ++j) {
            Period optionTenor = vars.atmVols.optionTenors[i];
            Period swapTenor = vars.atmVols.swapTenors[j];
            targetVol = vars.atmVols.lnVols[i][j];
            outVol = convertedsvs->volatility(optionTenor, swapTenor, dummyStrike);
            BOOST_CHECK_SMALL(outVol - targetVol, tolerance);
        }
    }
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [2/10]

BOOST_AUTO_TEST_CASE

(

testLognormalToNormal

)

Definition at line 119 of file swaptionvolatilityconverter.cpp.

                                            {
    BOOST_TEST_MESSAGE("Testing conversion of swaption vols from lognormal to normal...");
 
    CommonVars vars;
 
    // Tolerance used in boost check
    Real tolerance = 0.00001;
 
    // Set up the converter (Lognormal with no shifts -> Normal)
    SwaptionVolatilityConverter converter(vars.referenceDate, vars.atmLogNormalVolMatrix,
                                          vars.yieldCurves.discountEonia, vars.yieldCurves.discountEonia,
                                          vars.swapConventions, vars.swapConventions, 1 * Years, 30 * Years, Normal);
 
    // Get back converted volatility structure and test result on pillar points
    QuantLib::ext::shared_ptr<SwaptionVolatilityStructure> convertedsvs = converter.convert();
    Volatility targetVol = 0.0;
    Volatility outVol = 0.0;
    Real dummyStrike = 0.0;
    for (Size i = 0; i < vars.atmVols.optionTenors.size(); ++i) {
        for (Size j = 0; j < vars.atmVols.swapTenors.size(); ++j) {
            Period optionTenor = vars.atmVols.optionTenors[i];
            Period swapTenor = vars.atmVols.swapTenors[j];
            targetVol = vars.atmVols.nVols[i][j];
            outVol = convertedsvs->volatility(optionTenor, swapTenor, dummyStrike);
            BOOST_CHECK_SMALL(outVol - targetVol, tolerance);
        }
    }
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [3/10]

BOOST_AUTO_TEST_CASE

(

testNormalToShiftedLognormal

)

Definition at line 148 of file swaptionvolatilityconverter.cpp.

                                                   {
    BOOST_TEST_MESSAGE("Testing conversion of swaption vols from normal to shifted lognormal...");
 
    CommonVars vars;
 
    // Tolerance used in boost check
    Real tolerance = 0.00001;
 
    // Set up the converter (Normal -> Shifted Lognormal with shift set 1)
    SwaptionVolatilityConverter converter(vars.referenceDate, vars.atmNormalVolMatrix, vars.yieldCurves.discountEonia,
                                          vars.yieldCurves.discountEonia, vars.swapConventions, vars.swapConventions,
                                          1 * Years, 30 * Years, ShiftedLognormal, vars.atmVols.shifts_1);
 
    // Get back converted volatility structure and test result on pillar points
    QuantLib::ext::shared_ptr<SwaptionVolatilityStructure> convertedsvs = converter.convert();
    Volatility targetVol = 0.0;
    Volatility outVol = 0.0;
    Real dummyStrike = 0.0;
    for (Size i = 0; i < vars.atmVols.optionTenors.size(); ++i) {
        for (Size j = 0; j < vars.atmVols.swapTenors.size(); ++j) {
            Period optionTenor = vars.atmVols.optionTenors[i];
            Period swapTenor = vars.atmVols.swapTenors[j];
            targetVol = vars.atmVols.slnVols_1[i][j];
            outVol = convertedsvs->volatility(optionTenor, swapTenor, dummyStrike);
            BOOST_CHECK_SMALL(outVol - targetVol, tolerance);
        }
    }
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [4/10]

BOOST_AUTO_TEST_CASE

(

testShiftedLognormalToShiftedLognormal

)

Definition at line 177 of file swaptionvolatilityconverter.cpp.

                                                             {
    BOOST_TEST_MESSAGE("Testing conversion of swaption vols from shifted lognormal to shifted lognormal...");
 
    CommonVars vars;
 
    // Tolerance used in boost check
    Real tolerance = 0.00001;
 
    // Set up the converter (Normal -> Shifted Lognormal with shift set 1)
    SwaptionVolatilityConverter converter(vars.referenceDate, vars.atmShiftedLogNormalVolMatrix_1,
                                          vars.yieldCurves.discountEonia, vars.yieldCurves.discountEonia,
                                          vars.swapConventions, vars.swapConventions, 1 * Years, 30 * Years,
                                          ShiftedLognormal, vars.atmVols.shifts_2);
 
    // Get back converted volatility structure and test result on pillar points
    QuantLib::ext::shared_ptr<SwaptionVolatilityStructure> convertedsvs = converter.convert();
    Volatility targetVol = 0.0;
    Volatility outVol = 0.0;
    Real dummyStrike = 0.0;
    for (Size i = 0; i < vars.atmVols.optionTenors.size(); ++i) {
        for (Size j = 0; j < vars.atmVols.swapTenors.size(); ++j) {
            Period optionTenor = vars.atmVols.optionTenors[i];
            Period swapTenor = vars.atmVols.swapTenors[j];
            targetVol = vars.atmVols.slnVols_2[i][j];
            outVol = convertedsvs->volatility(optionTenor, swapTenor, dummyStrike);
            BOOST_CHECK_SMALL(outVol - targetVol, tolerance);
        }
    }
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [5/10]

BOOST_AUTO_TEST_CASE

(

testShiftedLognormalToNormal

)

Definition at line 207 of file swaptionvolatilityconverter.cpp.

                                                   {
    BOOST_TEST_MESSAGE("Testing conversion of swaption vols from shifted lognormal to normal...");
 
    CommonVars vars;
 
    // Tolerance used in boost check
    Real tolerance = 0.00001;
 
    // Set up the converter (Shifted Lognormal with shift set 2 -> Normal)
    SwaptionVolatilityConverter converter(vars.referenceDate, vars.atmShiftedLogNormalVolMatrix_2,
                                          vars.yieldCurves.discountEonia, vars.yieldCurves.discountEonia,
                                          vars.swapConventions, vars.swapConventions, 1 * Years, 30 * Years, Normal);
 
    // Get back converted volatility structure and test result on pillar points
    QuantLib::ext::shared_ptr<SwaptionVolatilityStructure> convertedsvs = converter.convert();
    Volatility targetVol = 0.0;
    Volatility outVol = 0.0;
    Real dummyStrike = 0.0;
    for (Size i = 0; i < vars.atmVols.optionTenors.size(); ++i) {
        for (Size j = 0; j < vars.atmVols.swapTenors.size(); ++j) {
            Period optionTenor = vars.atmVols.optionTenors[i];
            Period swapTenor = vars.atmVols.swapTenors[j];
            targetVol = vars.atmVols.nVols[i][j];
            outVol = convertedsvs->volatility(optionTenor, swapTenor, dummyStrike);
            BOOST_CHECK_SMALL(outVol - targetVol, tolerance);
        }
    }
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [6/10]

BOOST_AUTO_TEST_CASE

(

testFailureImplyingVol

)

Definition at line 236 of file swaptionvolatilityconverter.cpp.

                                             {
    BOOST_TEST_MESSAGE("Testing failure to imply lognormal vol from normal vol...");
 
    CommonVars vars;
 
    // Normal volatility matrix where we cannot imply lognormal vol at 3M x 1Y point
    vector<Period> optionTenors = list_of(Period(3, Months))(Period(1, Years));
    vector<Period> swapTenors = list_of(Period(1, Years))(Period(5, Years));
    Matrix normalVols(2, 2);
    normalVols[0][0] = 0.003340;
    normalVols[0][1] = 0.004973;
    normalVols[1][0] = 0.003543;
    normalVols[1][1] = 0.005270;
 
    QuantLib::ext::shared_ptr<SwaptionVolatilityStructure> volMatrix = QuantLib::ext::make_shared<SwaptionVolatilityMatrix>(
        vars.referenceDate, vars.conventions.fixedCalendar, vars.conventions.fixedConvention, optionTenors, swapTenors,
        normalVols, Actual365Fixed(), true, Normal);
 
    // Set up the converter (Normal -> Lognormal)
    SwaptionVolatilityConverter converter(vars.referenceDate, volMatrix, vars.yieldCurves.discountEonia,
                                          vars.yieldCurves.discountEonia, vars.swapConventions, vars.swapConventions,
                                          1 * Years, 30 * Years, ShiftedLognormal);
 
    // We expect the conversion to fail
    BOOST_CHECK_THROW(converter.convert(), QuantLib::Error);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [7/10]

BOOST_AUTO_TEST_CASE

(

testNormalShiftsIgnored

)

Definition at line 263 of file swaptionvolatilityconverter.cpp.

                                              {
    BOOST_TEST_MESSAGE("Testing shifts supplied to normal converter ignored...");
 
    CommonVars vars;
 
    // Tolerance used in boost check
    Real tolerance = 0.00001;
 
    // Set up the converter (Lognormal with no shifts -> Normal)
    // We supply target shifts but they are ignored since target type is Normal
    SwaptionVolatilityConverter converter(
        vars.referenceDate, vars.atmLogNormalVolMatrix, vars.yieldCurves.discountEonia, vars.yieldCurves.discountEonia,
        vars.swapConventions, vars.swapConventions, 1 * Years, 30 * Years, Normal, vars.atmVols.shifts_1);
 
    // Get back converted volatility structure and test result on pillar points
    QuantLib::ext::shared_ptr<SwaptionVolatilityStructure> convertedsvs = converter.convert();
    Volatility targetVol = 0.0;
    Volatility outVol = 0.0;
    Real dummyStrike = 0.0;
    for (Size i = 0; i < vars.atmVols.optionTenors.size(); ++i) {
        for (Size j = 0; j < vars.atmVols.swapTenors.size(); ++j) {
            Period optionTenor = vars.atmVols.optionTenors[i];
            Period swapTenor = vars.atmVols.swapTenors[j];
            targetVol = vars.atmVols.nVols[i][j];
            outVol = convertedsvs->volatility(optionTenor, swapTenor, dummyStrike);
            BOOST_CHECK_SMALL(outVol - targetVol, tolerance);
        }
    }
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [8/10]

BOOST_AUTO_TEST_CASE

(

testConstructionFromSwapIndex

)

Definition at line 293 of file swaptionvolatilityconverter.cpp.

                                                    {
    BOOST_TEST_MESSAGE("Testing construction of SwaptionVolatilityConverter from SwapIndex...");
 
    CommonVars vars;
 
    // Tolerance used in boost check
    Real tolerance = 0.00001;
 
    // Set up a SwapIndex
    QuantLib::ext::shared_ptr<SwapIndex> swapIndex =
        QuantLib::ext::make_shared<EuriborSwapIsdaFixA>(2 * Years, vars.yieldCurves.forward6M, vars.yieldCurves.discountEonia);
 
    // Set up the converter using swap index (Shifted Lognormal with shift set 2 -> Normal)
    SwaptionVolatilityConverter converter(vars.referenceDate, vars.atmShiftedLogNormalVolMatrix_2, swapIndex, swapIndex,
                                          Normal);
 
    // Test that the results are still ok
    QuantLib::ext::shared_ptr<SwaptionVolatilityStructure> convertedsvs = converter.convert();
    Volatility targetVol = 0.0;
    Volatility outVol = 0.0;
    Real dummyStrike = 0.0;
    for (Size i = 0; i < vars.atmVols.optionTenors.size(); ++i) {
        for (Size j = 0; j < vars.atmVols.swapTenors.size(); ++j) {
            Period optionTenor = vars.atmVols.optionTenors[i];
            Period swapTenor = vars.atmVols.swapTenors[j];
            targetVol = vars.atmVols.nVols[i][j];
            outVol = convertedsvs->volatility(optionTenor, swapTenor, dummyStrike);
            BOOST_CHECK_SMALL(outVol - targetVol, tolerance);
        }
    }
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [9/10]

BOOST_AUTO_TEST_CASE

(

testConstructionFromSwapIndexNoDiscount

)

Definition at line 325 of file swaptionvolatilityconverter.cpp.

                                                              {
    BOOST_TEST_MESSAGE("Testing construction from SwapIndex with no exogenous discount curve...");
 
    CommonVars vars;
 
    // Set up a SwapIndex
    QuantLib::ext::shared_ptr<SwapIndex> swapIndex =
        QuantLib::ext::make_shared<EuriborSwapIsdaFixA>(2 * Years, vars.yieldCurves.forward6M);
 
    // Set up the converter using swap index (Shifted Lognormal with shift set 2 -> Normal)
    SwaptionVolatilityConverter converter(vars.referenceDate, vars.atmShiftedLogNormalVolMatrix_2, swapIndex, swapIndex,
                                          Normal);
 
    // Test that calling convert() still works
    BOOST_CHECK_NO_THROW(converter.convert());
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [10/10]

BOOST_AUTO_TEST_CASE

(

testCube

)

Definition at line 342 of file swaptionvolatilityconverter.cpp.

                               {
    BOOST_TEST_MESSAGE("Testing lognormal to normal conversion for cube...");
 
    CommonVars vars;
 
    // Set up Swap Indices
    QuantLib::ext::shared_ptr<SwapIndex> shortSwapIndex =
        QuantLib::ext::make_shared<EuriborSwapIsdaFixA>(1 * Years, vars.yieldCurves.forward3M, vars.yieldCurves.discountEonia);
    QuantLib::ext::shared_ptr<SwapIndex> swapIndex =
        QuantLib::ext::make_shared<EuriborSwapIsdaFixA>(30 * Years, vars.yieldCurves.forward6M, vars.yieldCurves.discountEonia);
 
    // Set up a lognormal cube
    QuantLib::ext::shared_ptr<SwaptionVolatilityCube> cube = QuantLib::ext::make_shared<QuantExt::SwaptionVolCube2>(
        Handle<SwaptionVolatilityStructure>(vars.atmLogNormalVolMatrix), vars.atmVols.optionTenors,
        vars.atmVols.swapTenors, vars.atmVols.strikeSpreads, vars.atmVols.lnVolSpreads, swapIndex, shortSwapIndex,
        false, true);
 
    // Convert the cube to normal
    SwaptionVolatilityConverter converter(vars.referenceDate, cube, swapIndex, shortSwapIndex, Normal);
    QuantLib::ext::shared_ptr<SwaptionVolatilityStructure> convertedsvs = converter.convert();
 
    // Price swaptions in the lognormal and normal cube and compare their premiums
    for (Size i = 0; i < vars.atmVols.optionTenors.size(); ++i) {
        for (Size j = 0; j < vars.atmVols.swapTenors.size(); ++j) {
            for (Size k = 0; k < vars.atmVols.strikeSpreads.size(); ++k) {
                Period optionTenor = vars.atmVols.optionTenors[i];
                Period swapTenor = vars.atmVols.swapTenors[j];
                Real atmStrike = cube->atmStrike(optionTenor, swapTenor);
                Real strikeSpread = vars.atmVols.strikeSpreads[k];
                Real strike = atmStrike + strikeSpread;
                if (strike > 0.0) {
                    Real inVol = cube->volatility(optionTenor, swapTenor, atmStrike + strikeSpread);
                    Real outVol = convertedsvs->volatility(optionTenor, swapTenor, atmStrike + strikeSpread);
                    Option::Type type = strikeSpread < 0.0 ? Option::Put : Option::Call;
                    Real tte = cube->optionTimes()[i];
                    Real inPrem = blackFormula(type, strike, atmStrike, inVol * std::sqrt(tte));
                    Real outPrem = bachelierBlackFormula(type, strike, atmStrike, outVol * std::sqrt(tte));
                    BOOST_CHECK_CLOSE(inPrem, outPrem, 0.01);
                }
            }
        }
    }
}

Here is the call graph for this function: