capfloortermvolcurve.cpp File Reference

#include <boost/assign.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/test/data/test_case.hpp>
#include <boost/variant.hpp>
#include <test/capfloormarketdata.hpp>
#include <test/toplevelfixture.hpp>
#include <ql/math/interpolations/backwardflatinterpolation.hpp>
#include <ql/quotes/simplequote.hpp>
#include <qle/math/flatextrapolation.hpp>
#include <qle/termstructures/capfloortermvolcurve.hpp>

Go to the source code of this file.

Namespaces
namespace	boost
namespace	boost::test_tools
namespace	boost::test_tools::tt_detail

Functions
	BOOST_DATA_TEST_CASE_F (CommonVars, testCapFloorTermVolCurveInterpolation, bdata::make(interpolationTypes) *bdata::make(isMovingValues) *bdata::make(flatFirstPeriodValues), interpolationType, isMoving, flatFirstPeriod)

Function Documentation

BOOST_DATA_TEST_CASE_F()

BOOST_DATA_TEST_CASE_F	(	CommonVars	,
		testCapFloorTermVolCurveInterpolation	,
		bdata::make(interpolationTypes) *bdata::make(isMovingValues) *bdata::make(flatFirstPeriodValues)	,
		interpolationType	,
		isMoving	,
		flatFirstPeriod
	)

Definition at line 147 of file capfloortermvolcurve.cpp.

                                                                     {
 
    BOOST_TEST_MESSAGE("Testing cap floor term volatility curve with different interpolation methods");
 
    BOOST_TEST_MESSAGE("Test inputs are:");
    BOOST_TEST_MESSAGE("  Interpolation type: " << to_string(interpolationType));
    BOOST_TEST_MESSAGE("  Floating reference date: " << boolalpha << isMoving);
    BOOST_TEST_MESSAGE("  Flat first period: " << boolalpha << flatFirstPeriod);
 
    // Create the CapFloorTermVolatilityStructure using the appropriate interpolation and reference date/settlement days
    QuantLib::ext::shared_ptr<CapFloorTermVolatilityStructure> cftvs;
    switch (interpolationType.which()) {
    case 0:
        if (isMoving) {
            BOOST_TEST_MESSAGE("Using Linear interpolation with a moving reference date");
            BOOST_REQUIRE_NO_THROW(cftvs = QuantLib::ext::make_shared<InterpolatedCapFloorTermVolCurve<Linear> >(
                                       settlementDays, calendar, bdc, tenors, volHandles, dayCounter, flatFirstPeriod));
        } else {
            BOOST_TEST_MESSAGE("Using Linear interpolation with a fixed reference date");
            BOOST_REQUIRE_NO_THROW(cftvs = QuantLib::ext::make_shared<InterpolatedCapFloorTermVolCurve<Linear> >(
                                       referenceDate, calendar, bdc, tenors, volHandles, dayCounter, flatFirstPeriod));
        }
        break;
    case 1:
        if (isMoving) {
            BOOST_TEST_MESSAGE("Using BackwardFlat interpolation with a moving reference date");
            BOOST_REQUIRE_NO_THROW(cftvs = QuantLib::ext::make_shared<InterpolatedCapFloorTermVolCurve<BackwardFlat> >(
                                       settlementDays, calendar, bdc, tenors, volHandles, dayCounter, flatFirstPeriod));
        } else {
            BOOST_TEST_MESSAGE("Using BackwardFlat interpolation with a fixed reference date");
            BOOST_REQUIRE_NO_THROW(cftvs = QuantLib::ext::make_shared<InterpolatedCapFloorTermVolCurve<BackwardFlat> >(
                                       referenceDate, calendar, bdc, tenors, volHandles, dayCounter, flatFirstPeriod));
        }
        break;
    case 2:
        if (isMoving) {
            BOOST_TEST_MESSAGE("Using LinearFlat interpolation with a moving reference date");
            BOOST_REQUIRE_NO_THROW(cftvs = QuantLib::ext::make_shared<InterpolatedCapFloorTermVolCurve<LinearFlat> >(
                                       settlementDays, calendar, bdc, tenors, volHandles, dayCounter, flatFirstPeriod));
        } else {
            BOOST_TEST_MESSAGE("Using LinearFlat interpolation with a fixed reference date");
            BOOST_REQUIRE_NO_THROW(cftvs = QuantLib::ext::make_shared<InterpolatedCapFloorTermVolCurve<LinearFlat> >(
                                       referenceDate, calendar, bdc, tenors, volHandles, dayCounter, flatFirstPeriod));
        }
        break;
    case 3:
        if (isMoving) {
            BOOST_TEST_MESSAGE("Using Cubic interpolation with a moving reference date");
            BOOST_REQUIRE_NO_THROW(cftvs = QuantLib::ext::make_shared<InterpolatedCapFloorTermVolCurve<Cubic> >(
                                       settlementDays, calendar, bdc, tenors, volHandles, dayCounter, flatFirstPeriod));
        } else {
            BOOST_TEST_MESSAGE("Using Cubic interpolation with a fixed reference date");
            BOOST_REQUIRE_NO_THROW(cftvs = QuantLib::ext::make_shared<InterpolatedCapFloorTermVolCurve<Cubic> >(
                                       referenceDate, calendar, bdc, tenors, volHandles, dayCounter, flatFirstPeriod));
        }
        break;
    case 4:
        if (isMoving) {
            BOOST_TEST_MESSAGE("Using CubicFlat interpolation with a moving reference date");
            BOOST_REQUIRE_NO_THROW(cftvs = QuantLib::ext::make_shared<InterpolatedCapFloorTermVolCurve<CubicFlat> >(
                                       settlementDays, calendar, bdc, tenors, volHandles, dayCounter, flatFirstPeriod));
        } else {
            BOOST_TEST_MESSAGE("Using CubicFlat interpolation with a fixed reference date");
            BOOST_REQUIRE_NO_THROW(cftvs = QuantLib::ext::make_shared<InterpolatedCapFloorTermVolCurve<CubicFlat> >(
                                       referenceDate, calendar, bdc, tenors, volHandles, dayCounter, flatFirstPeriod));
        }
        break;
    default:
        BOOST_FAIL("Unexpected interpolation type");
    }
 
    BOOST_TEST_MESSAGE("Test the initial curve dates");
    for (Size i = 0; i < tenors.size(); ++i) {
        Date curveDate = cftvs->optionDateFromTenor(tenors[i]);
        Date manualDate = calendar.advance(referenceDate, tenors[i], bdc);
        BOOST_CHECK_EQUAL(curveDate, manualDate);
    }
 
    BOOST_TEST_MESSAGE("Test that curve returns input values on pillars");
    for (Size i = 0; i < tenors.size(); ++i) {
        Volatility vol = cftvs->volatility(tenors[i], 0.01);
        BOOST_CHECK_SMALL(volQuotes[i]->value() - vol, tolerance);
    }
 
    // Bump the 5Y ATM volatility quote (3rd element in quote vector)
    Size idx = 2;
    Volatility bump = 0.0005;
    Volatility baseValue = volQuotes[idx]->value();
    volQuotes[idx]->setValue(baseValue + bump);
 
    BOOST_TEST_MESSAGE("Test that curve returns input values on pillars after bump");
    for (Size i = 0; i < tenors.size(); ++i) {
        Volatility vol = cftvs->volatility(tenors[i], 0.01);
        BOOST_CHECK_SMALL(volQuotes[i]->value() - vol, tolerance);
        // Also check the point was bumped
        if (i == idx) {
            BOOST_CHECK_SMALL(vol - baseValue - bump, tolerance);
        }
    }
 
    BOOST_TEST_MESSAGE("Test the curve dates after moving the evaluation date");
    Date manualDate;
    Date newDate = calendar.advance(referenceDate, 1 * Months);
    Settings::instance().evaluationDate() = newDate;
    for (Size i = 0; i < tenors.size(); ++i) {
        Date curveDate = cftvs->optionDateFromTenor(tenors[i]);
        manualDate =
            isMoving ? calendar.advance(newDate, tenors[i], bdc) : calendar.advance(referenceDate, tenors[i], bdc);
        BOOST_CHECK_EQUAL(curveDate, manualDate);
    }
 
    BOOST_TEST_MESSAGE("Test that curve returns input values after moving the evaluation date");
    for (Size i = 0; i < tenors.size(); ++i) {
        Volatility vol = cftvs->volatility(tenors[i], 0.01);
        BOOST_CHECK_SMALL(volQuotes[i]->value() - vol, tolerance);
    }
 
    // Reset the evaluation date
    Settings::instance().evaluationDate() = referenceDate;
 
    BOOST_TEST_MESSAGE("Test extrapolation settings with out of range date");
    Date oorDate = cftvs->maxDate() + 1 * Months;
    BOOST_CHECK_NO_THROW(cftvs->volatility(oorDate, 0.01, true));
    BOOST_CHECK_THROW(cftvs->volatility(oorDate, 0.01), Error);
    cftvs->enableExtrapolation();
    BOOST_CHECK_NO_THROW(cftvs->volatility(oorDate, 0.01));
}