inflationvol.cpp File Reference

#include "toplevelfixture.hpp"
#include <boost/test/unit_test.hpp>
#include <ql/indexes/inflation/aucpi.hpp>
#include <ql/indexes/inflation/euhicp.hpp>
#include <ql/math/interpolations/bilinearinterpolation.hpp>
#include <ql/math/matrix.hpp>
#include <ql/pricingengines/blackcalculator.hpp>
#include <ql/termstructures/inflation/inflationhelpers.hpp>
#include <ql/termstructures/inflationtermstructure.hpp>
#include <ql/termstructures/volatility/inflation/cpivolatilitystructure.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <ql/time/calendars/nullcalendar.hpp>
#include <ql/time/daycounters/actual365fixed.hpp>
#include <qle/pricingengines/cpiblackcapfloorengine.hpp>
#include <qle/termstructures/inflation/cpipricevolatilitysurface.hpp>
#include <qle/termstructures/inflation/piecewisezeroinflationcurve.hpp>
#include <qle/termstructures/interpolatedcpivolatilitysurface.hpp>
#include <qle/utilities/inflation.hpp>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (testCPIVolatilitySurface)
	BOOST_AUTO_TEST_CASE (testCPIBlackCapFloorEngine)
	BOOST_AUTO_TEST_CASE (testCPIBlackCapFloorEngineSeasonedCapFloors)
	BOOST_AUTO_TEST_CASE (testCPIPriceVolSurface)
	BOOST_AUTO_TEST_CASE (testCPIPriceVolSurfaceMissingQuoteInterpolation)
	BOOST_AUTO_TEST_CASE (testCPIPriceVolSurfaceMissingQuoteExtrapolation)
	BOOST_AUTO_TEST_CASE (testCPIPriceVolSurfaceAllButOneQuoteMissing)
	BOOST_AUTO_TEST_CASE (testVolatiltiySurfaceWithStartDate)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/8]

BOOST_AUTO_TEST_CASE

(

testCPIVolatilitySurface

)

Definition at line 232 of file inflationvol.cpp.

                                               {
    // Test case when the ZCIIS and Cap/Floors start today with using todays fixing
    CommonData cd;
 
    Date lastKnownFixing(1, Jul, 2022);
    Date capFloorBaseDate(1, Jun, 2022); // first day of the month of today - 2M
 
    auto index = buildIndexWithForwardTermStructure(cd);
 
    Handle<ZeroInflationIndex> hindex(index);
 
    BOOST_CHECK_EQUAL(index->zeroInflationTermStructure()->baseDate(), lastKnownFixing);
 
    auto volSurface = buildVolSurface(cd, index);
 
    // Expect the base fixing date of the cap/floor today - 2M
    BOOST_CHECK_EQUAL(volSurface->baseDate(), capFloorBaseDate);
 
    double baseCPI = index->fixing(volSurface->baseDate());
 
    BOOST_CHECK_CLOSE(baseCPI, cd.cpiFixings[capFloorBaseDate], cd.tolerance);
 
    for (size_t i = 0; i < cd.tenors.size(); ++i) {
        auto fixingDate = volSurface->baseDate() + cd.tenors[i];
        for (size_t j = 0; j < cd.strikes.size(); ++j) {   
            auto expectedVol = cd.vols[i][j]->value();
            auto volByTenor = volSurface->volatility(cd.tenors[i], cd.strikes[j]);
            auto volByFixingDate = volSurface->volatility(fixingDate, cd.strikes[j], 0 * Days);
            BOOST_CHECK_CLOSE(volByTenor, expectedVol, cd.tolerance);
            BOOST_CHECK_CLOSE(volByFixingDate, expectedVol, cd.tolerance);
        }
    }
}

BOOST_AUTO_TEST_CASE() [2/8]

BOOST_AUTO_TEST_CASE

(

testCPIBlackCapFloorEngine

)

Definition at line 266 of file inflationvol.cpp.

                                                 {
    // Test case when the ZCIIS and Cap/Floors start today with using todays fixing
    CommonData cd;
    auto index = buildIndexWithForwardTermStructure(cd);
 
    auto volSurface = buildVolSurface(cd, index);
 
    double baseCPI = index->fixing(volSurface->baseDate());
 
    auto priceData = pricesFromVolQuotes(cd, index, false, Date());
 
    QuantLib::ext::shared_ptr<PricingEngine> engine = QuantLib::ext::make_shared<QuantExt::CPIBlackCapFloorEngine>(
        cd.discountTS, Handle<CPIVolatilitySurface>(volSurface), true);
 
    for (size_t i = 0; i < priceData.cStrikes.size(); ++i) {
        double strike = priceData.cStrikes[i];
        for (size_t j = 0; j < priceData.tenors.size(); ++j) {
            Period tenor = priceData.tenors[j];
            CPICapFloor cap(Option::Call, 1.0, cd.today, baseCPI, cd.today + tenor, cd.fixingCalendar, cd.bdc,
                            cd.fixingCalendar, cd.bdc, strike, index, cd.obsLag, CPI::Flat);
            cap.setPricingEngine(engine);
            BOOST_CHECK_CLOSE(cap.NPV(), priceData.cPrices[i][j], cd.tolerance);
        }
    }
 
    for (size_t i = 0; i < priceData.fStrikes.size(); ++i) {
        double strike = priceData.fStrikes[i];
        for (size_t j = 0; j < priceData.tenors.size(); ++j) {
            Period tenor = priceData.tenors[j];
            CPICapFloor put(Option::Put, 1.0, cd.today, baseCPI, cd.today + tenor, cd.fixingCalendar, cd.bdc,
                            cd.fixingCalendar, cd.bdc, strike, index, cd.obsLag, CPI::Flat);
            put.setPricingEngine(engine);
            BOOST_CHECK_CLOSE(put.NPV(), priceData.fPrices[i][j], cd.tolerance);
        }
    }
}

BOOST_AUTO_TEST_CASE() [3/8]

BOOST_AUTO_TEST_CASE

(

testCPIBlackCapFloorEngineSeasonedCapFloors

)

Definition at line 303 of file inflationvol.cpp.

                                                                  {
    // Pricing seasoned cap/floors
    CommonData cd;
 
    Date lastKnownFixing(1, Jul, 2022);
    Date capFloorBaseDate(1, Jun, 2022); // first day of the month of today - 2M
 
    auto index = buildIndexWithForwardTermStructure(cd);
 
    auto volSurface = buildVolSurface(cd, index);
 
    double baseCPI = index->fixing(volSurface->baseDate());
 
    QuantLib::ext::shared_ptr<PricingEngine> engine = QuantLib::ext::make_shared<QuantExt::CPIBlackCapFloorEngine>(
        cd.discountTS, Handle<CPIVolatilitySurface>(volSurface), true);
 
    Date seasonedStartDate(15, Aug, 2021);
    Date seasonedMaturity(15, Aug, 2024);
    Date seasonedBaseFixingDate(1, Jun, 2021);
    Date seasonedFixingDate(1, Jun, 2024);
    double seasonedStrike = 0.03;
    double seasonedBaseCPI = index->fixing(seasonedBaseFixingDate);
 
    double K = pow(1 + seasonedStrike, cd.dayCounter.yearFraction(seasonedBaseFixingDate, seasonedFixingDate));
    double atm = index->fixing(seasonedFixingDate) / seasonedBaseCPI;
 
    double adjustedStrike = std::pow(K * seasonedBaseCPI / baseCPI,
                                     1.0 / cd.dayCounter.yearFraction(volSurface->baseDate(), seasonedFixingDate)) -
                            1.0;
 
    double volTimeFrom = cd.dayCounter.yearFraction(lastKnownFixing, seasonedFixingDate);
    double vol = volSurface->volatility(seasonedFixingDate, adjustedStrike, 0 * Days, false);
    double discountFactor = cd.discountTS->discount(seasonedMaturity);
    QuantLib::BlackCalculator callPricer(Option::Call, K, atm, sqrt(volTimeFrom) * vol, discountFactor);
 
    QuantLib::CPICapFloor cap(Option::Call, 1.0, seasonedStartDate, Null<double>(), seasonedMaturity, cd.fixingCalendar,
                              cd.bdc, cd.fixingCalendar, cd.bdc, seasonedStrike, index,
                              cd.obsLag, CPI::Flat);
 
    cap.setPricingEngine(engine);
 
    BOOST_CHECK_CLOSE(cap.NPV(), callPricer.value(), cd.tolerance);
}

BOOST_AUTO_TEST_CASE() [4/8]

BOOST_AUTO_TEST_CASE

(

testCPIPriceVolSurface

)

Definition at line 347 of file inflationvol.cpp.

                                             {
    // Test case when the ZCIIS and Cap/Floors start today with using todays fixing
    CommonData cd;
    auto index = buildIndexWithForwardTermStructure(cd);
 
    auto priceData = pricesFromVolQuotes(cd, index, false, Date());
 
    auto volSurface = buildVolSurfaceFromPrices(cd, priceData, index, true, Date(), false);
 
    for (size_t i = 0; i < cd.tenors.size(); ++i) {
        auto fixingDate = volSurface->baseDate() + cd.tenors[i];
        for (size_t j = 0; j < cd.strikes.size(); ++j) {
            auto expectedVol = cd.vols[i][j]->value();
            auto volByTenor = volSurface->volatility(cd.tenors[i], cd.strikes[j]);
            auto volByFixingDate = volSurface->volatility(fixingDate, cd.strikes[j], 0 * Days);
            BOOST_CHECK_CLOSE(volByTenor, expectedVol, cd.tolerance);
            BOOST_CHECK_CLOSE(volByFixingDate, expectedVol, cd.tolerance);
        }
    }
}

BOOST_AUTO_TEST_CASE() [5/8]

BOOST_AUTO_TEST_CASE

(

testCPIPriceVolSurfaceMissingQuoteInterpolation

)

Definition at line 368 of file inflationvol.cpp.

                                                                      {
    // Test case when the ZCIIS and Cap/Floors start today with using todays fixing
    CommonData cd;
    auto index = buildIndexWithForwardTermStructure(cd);
 
    // Remove 1 Quote and check if its get interpolated
    for (Size tenorIdx = 1; tenorIdx < cd.tenors.size() - 1; tenorIdx++) {
        for (Size strikeIdx = 1; strikeIdx < cd.strikes.size() - 1; strikeIdx++) {
            auto priceData = pricesFromVolQuotes(cd, index, false, Date());
            priceData.cPrices[strikeIdx][tenorIdx] = Null<Real>();
            priceData.fPrices[strikeIdx][tenorIdx] = Null<Real>();
 
            auto volSurface = buildVolSurfaceFromPrices(cd, priceData, index, true, Date(), true);
 
            double vol = volSurface->volatility(cd.tenors[tenorIdx], cd.strikes[strikeIdx]);
 
            double expectedVol =
                cd.vols[tenorIdx][strikeIdx - 1]->value() +
                (cd.vols[tenorIdx][strikeIdx + 1]->value() - cd.vols[tenorIdx][strikeIdx - 1]->value()) *
                    (cd.strikes[strikeIdx] - cd.strikes[strikeIdx - 1]) /
                    (cd.strikes[strikeIdx + 1] - cd.strikes[strikeIdx - 1]);
 
            BOOST_CHECK_CLOSE(vol, expectedVol, cd.tolerance);
        }
    }
}

BOOST_AUTO_TEST_CASE() [6/8]

BOOST_AUTO_TEST_CASE

(

testCPIPriceVolSurfaceMissingQuoteExtrapolation

)

Definition at line 396 of file inflationvol.cpp.

                                                                      {
    // Test case when the ZCIIS and Cap/Floors start today with using todays fixing
    CommonData cd;
    auto index = buildIndexWithForwardTermStructure(cd);
 
    // Remove 1 Quote and check if its get extrapolated
    for (Size tenorIdx = 1; tenorIdx < cd.tenors.size() - 1; tenorIdx++) {
 
        auto priceData = pricesFromVolQuotes(cd, index, false, Date());
 
        priceData.cPrices[0][tenorIdx] = Null<Real>();
        priceData.fPrices[0][tenorIdx] = Null<Real>();
 
        auto volSurface = buildVolSurfaceFromPrices(cd, priceData, index, true, Date(), true);
 
        double vol = volSurface->volatility(cd.tenors[tenorIdx], cd.strikes.front());
 
        double expectedVol = cd.vols[tenorIdx][1]->value();
 
        BOOST_CHECK_CLOSE(vol, expectedVol, cd.tolerance);
    }   
 
    // Remove 1 Quote and check if its get extrapolated
    for (Size tenorIdx = 1; tenorIdx < cd.tenors.size() - 1; tenorIdx++) {
 
        auto priceData = pricesFromVolQuotes(cd, index, false, Date());
 
        priceData.cPrices[cd.strikes.size()-1][tenorIdx] = Null<Real>();
        priceData.fPrices[cd.strikes.size() - 1][tenorIdx] = Null<Real>();
 
        auto volSurface = buildVolSurfaceFromPrices(cd, priceData, index, true, Date(), true);
 
        double vol = volSurface->volatility(cd.tenors[tenorIdx], cd.strikes.back());
 
        double expectedVol = cd.vols[tenorIdx][cd.strikes.size() - 2]->value();
 
        BOOST_CHECK_CLOSE(vol, expectedVol, cd.tolerance);
    }   
 
    // Remove 2 Quote and check if its get extrapolated
    for (Size tenorIdx = 1; tenorIdx < cd.tenors.size() - 1; tenorIdx++) {
 
        auto priceData = pricesFromVolQuotes(cd, index, false, Date());
 
        priceData.cPrices[0][tenorIdx] = Null<Real>();
        priceData.fPrices[0][tenorIdx] = Null<Real>();
 
        priceData.cPrices[1][tenorIdx] = Null<Real>();
        priceData.fPrices[1][tenorIdx] = Null<Real>();
 
        auto volSurface = buildVolSurfaceFromPrices(cd, priceData, index, true, Date(), true);
 
        double vol = volSurface->volatility(cd.tenors[tenorIdx], cd.strikes.front());
 
        double expectedVol = cd.vols[tenorIdx][2]->value();
 
        BOOST_CHECK_CLOSE(vol, expectedVol, cd.tolerance);
    }
}

BOOST_AUTO_TEST_CASE() [7/8]

BOOST_AUTO_TEST_CASE

(

testCPIPriceVolSurfaceAllButOneQuoteMissing

)

Definition at line 457 of file inflationvol.cpp.

                                                                  {
    // Test case when the ZCIIS and Cap/Floors start today with using todays fixing
    CommonData cd;
    auto index = buildIndexWithForwardTermStructure(cd);
 
    // Remove all QUotes for a strike
    auto priceDataAllQuotes = pricesFromVolQuotes(cd, index, false, Date());
    auto priceData = pricesFromVolQuotes(cd, index, false, Date());
    for (Size strikeIdx = 0; strikeIdx < cd.strikes.size(); strikeIdx++) {
        priceData.cPrices[strikeIdx][0] = Null<Real>();
        priceData.fPrices[strikeIdx][0] = Null<Real>();
    }
    priceData.cPrices[1][0] = priceDataAllQuotes.cPrices[1][0];
    priceData.fPrices[1][0] = priceDataAllQuotes.fPrices[1][0];
 
    auto volSurface = buildVolSurfaceFromPrices(cd, priceData, index, true, Date(), true);
 
    double vol = volSurface->volatility(cd.tenors[0], cd.strikes[0]);
    double expectedVol = cd.vols[0][1]->value();
    BOOST_CHECK_CLOSE(vol, expectedVol, cd.tolerance);
 
    for (Size tenorIdx = 0; tenorIdx < cd.tenors.size(); tenorIdx++) {
        for (Size strikeIdx = 0; strikeIdx < cd.strikes.size(); strikeIdx++) {
            priceData.cPrices[strikeIdx][tenorIdx] = Null<Real>();
            priceData.fPrices[strikeIdx][tenorIdx] = Null<Real>();
        }
        priceData.cPrices[1][tenorIdx] = priceDataAllQuotes.cPrices[1][tenorIdx];
        priceData.fPrices[1][tenorIdx] = priceDataAllQuotes.fPrices[1][tenorIdx];
    }
 
    volSurface = buildVolSurfaceFromPrices(cd, priceData, index, true, Date(), true);
    for (Size tenorIdx = 0; tenorIdx < cd.tenors.size(); tenorIdx++) {
        double vol = volSurface->volatility(cd.tenors[tenorIdx], cd.strikes[0]);
        double expectedVol = cd.vols[tenorIdx][1]->value();
        BOOST_CHECK_CLOSE(vol, expectedVol, cd.tolerance);
    }
}

BOOST_AUTO_TEST_CASE() [8/8]

BOOST_AUTO_TEST_CASE

(

testVolatiltiySurfaceWithStartDate

)

Definition at line 496 of file inflationvol.cpp.

                                                         {
    // Test case when the ZCIIS and Cap/Floors don't start today
    // but depend on the publishing schedule of the fixings
    CommonData cd;
    Date today(15, July, 2022);
    cd.today = today;
    cd.obsLag = 3 * Months;
    Settings::instance().evaluationDate() = today;
    std::map<Date, double> fixings{{Date(1, Mar, 2022), 100.0}};
    // the Q2 fixing not published yet, the zciis swaps and caps start on 15th Jun and
    // reference on the Q1 fixing
    Date startDate(15, Jun, 2022);
    Date lastKnownFixing(1, Jan, 2022);
 
    QuantLib::ext::shared_ptr<ZeroInflationIndex> curveBuildIndex = QuantLib::ext::make_shared<QuantLib::AUCPI>(Quarterly, true, false);
    for (const auto& [date, fixing] : fixings) {
        curveBuildIndex->addFixing(date, fixing);
    }
 
    auto curve = buildZeroInflationCurve(cd, true, curveBuildIndex, false, nullptr, startDate);
 
    auto index = curveBuildIndex->clone(Handle<ZeroInflationTermStructure>(curve));
 
    BOOST_CHECK_EQUAL(curve->baseDate(), lastKnownFixing);
 
    BOOST_CHECK_EQUAL(curve->dates()[1], Date(1, Jan, 2023));
    BOOST_CHECK_CLOSE(curve->data()[0], cd.zeroCouponQuotes[0], cd.tolerance);
    BOOST_CHECK_CLOSE(curve->data()[1], cd.zeroCouponQuotes[0], cd.tolerance);
    BOOST_CHECK_CLOSE(curve->data()[2], cd.zeroCouponQuotes[1], cd.tolerance);
 
    auto volSurface = buildVolSurface(cd, index, startDate);
 
    BOOST_CHECK_EQUAL(volSurface->baseDate(), Date(1, Jan, 2022));
 
    double baseCPI = index->fixing(volSurface->baseDate());
 
    BOOST_CHECK_CLOSE(baseCPI, 100.0, cd.tolerance);
 
    Matrix cPrices(cd.strikes.size(), cd.tenors.size(), 0.0);
    Matrix fPrices(cd.strikes.size(), cd.tenors.size(), 0.0);
 
    for (size_t i = 0; i < cd.strikes.size(); ++i) {
        for (size_t j = 0; j < cd.tenors.size(); ++j) {
            double expectedVol = cd.vols[j][i]->value();
            Date optionFixingDate = volSurface->baseDate() + cd.tenors[j];
            Date optionPaymentDate = startDate + cd.tenors[j];
 
            double vol = volSurface->volatility(optionFixingDate, cd.strikes[i], 0 * Days, false);
            BOOST_CHECK_CLOSE(vol, expectedVol, cd.tolerance);
            double ttm = cd.dayCounter.yearFraction(volSurface->baseDate(), optionFixingDate);
            double atmf = index->fixing(optionFixingDate) / baseCPI;
            double strike = std::pow(1 + cd.strikes[i], ttm);
            double discountFactor = cd.discountTS->discount(optionPaymentDate);
            double volTimeFrom = cd.dayCounter.yearFraction(lastKnownFixing, optionFixingDate);
            QuantLib::BlackCalculator callPricer(Option::Call, strike, atmf, sqrt(volTimeFrom) * vol, discountFactor);
            QuantLib::BlackCalculator putPricer(Option::Put, strike, atmf, sqrt(volTimeFrom) * vol, discountFactor);
 
            cPrices[i][j] = callPricer.value();
            fPrices[i][j] = putPricer.value();
        }
    }
 
    CPICapFloorPriceData priceData;
    priceData.tenors = cd.tenors;
    priceData.cPrices = cPrices;
    priceData.fPrices = fPrices;
    priceData.cStrikes = cd.strikes;
    priceData.fStrikes = cd.strikes;
 
    auto priceSurface = buildVolSurfaceFromPrices(cd, priceData, index, true, startDate);
 
    for (size_t i = 0; i < cd.strikes.size(); ++i) {
        for (size_t j = 0; j < cd.tenors.size(); ++j) {
            double expectedVol = cd.vols[j][i]->value();
            Date optionFixingDate = priceSurface->baseDate() + cd.tenors[j];
            double vol = priceSurface->volatility(optionFixingDate, cd.strikes[i], 0 * Days, false);
            BOOST_CHECK_CLOSE(vol, expectedVol, cd.tolerance);
        }
    }
 
 
 
}