inflationcurve.cpp File Reference

#include "toplevelfixture.hpp"
#include <boost/test/unit_test.hpp>
#include <ql/termstructures/inflationtermstructure.hpp>
#include <qle/termstructures/inflation/piecewisezeroinflationcurve.hpp>
#include <ql/indexes/inflation/euhicp.hpp>
#include <ql/termstructures/inflation/inflationhelpers.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <ql/time/calendars/nullcalendar.hpp>
#include <ql/time/daycounters/actual365fixed.hpp>
#include <qle/utilities/inflation.hpp>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (testZeroInflationCurveNonInterpolatedLastMonthFixingUnknown)
	BOOST_AUTO_TEST_CASE (testZeroInflationCurveNonInterpolatedLastMonthFixing)
	BOOST_AUTO_TEST_CASE (testZeroInflationCurveInterpolatedLastMonthFixing)
	BOOST_AUTO_TEST_CASE (testZeroInflationCurveNonInterpolatedLastMonthFixingUnknownWithSeasonality)
	BOOST_AUTO_TEST_CASE (testZeroInflationCurveNonInterpolatedLastMonthFixingWithSeasonality)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/5]

BOOST_AUTO_TEST_CASE

(

testZeroInflationCurveNonInterpolatedLastMonthFixingUnknown

)

Definition at line 107 of file inflationcurve.cpp.

                                                                                  {
 
    CommonData cd;
    Settings::instance().evaluationDate() = cd.today;
    bool isInterpolated = false;
    bool useLastKnownFixingDateAsBaseDate = false;
    // Build Curve and Index
    QuantLib::ext::shared_ptr<ZeroInflationIndex> curveBuildIndex = QuantLib::ext::make_shared<EUHICPXT>(false);
    addFixings(cd.cpiFixings, *curveBuildIndex);
    auto curve = buildZeroInflationCurve(cd, useLastKnownFixingDateAsBaseDate, curveBuildIndex, isInterpolated);
 
    BOOST_CHECK_NO_THROW(curve->zeroRate(1.0));
 
    auto index = curveBuildIndex->clone(Handle<ZeroInflationTermStructure>(curve));
 
    std::vector<Date> expectedPillarDates{Date(1, June, 2022), Date(1, June, 2023), Date(1, June, 2024),
                                          Date(1, June, 2025), Date(1, June, 2027)};
 
    std::vector<Real> expectedZeroRates{0.06, 0.06, 0.04, 0.03, 0.02};
 
    std::vector<Real> expectedCPIs{100., 106., 108.171622850024, 109.281549591561, 110.414070537467};
 
    BOOST_CHECK_EQUAL(curve->baseDate(), expectedPillarDates.front());
 
    BOOST_CHECK_EQUAL(curve->dates().size(), expectedPillarDates.size());
 
    for (size_t i = 0; i < expectedPillarDates.size(); ++i) {
        BOOST_CHECK_EQUAL(curve->dates().at(i), expectedPillarDates.at(i));
        BOOST_CHECK_CLOSE(curve->zeroRate(curve->dates().at(i), 0 * Days), expectedZeroRates.at(i), cd.tolerance);
    }
 
    // Check index fixing forecasts
 
    for (size_t i = 0; i < expectedPillarDates.size(); ++i) {
        auto forwardCPI = index->fixing(expectedPillarDates.at(i));
        BOOST_CHECK_CLOSE(forwardCPI, expectedCPIs.at(i), cd.tolerance);
    }
}

BOOST_AUTO_TEST_CASE() [2/5]

BOOST_AUTO_TEST_CASE

(

testZeroInflationCurveNonInterpolatedLastMonthFixing

)

Definition at line 146 of file inflationcurve.cpp.

                                                                           {
 
    CommonData cd;
    Settings::instance().evaluationDate() = cd.today;
    bool isInterpolated = false;
    bool useLastKnownFixingDateAsBaseDate = true;
    // Build Curve and Index
    QuantLib::ext::shared_ptr<ZeroInflationIndex> curveBuildIndex = QuantLib::ext::make_shared<EUHICPXT>(false);
    addFixings(cd.cpiFixings, *curveBuildIndex);
    auto curve = buildZeroInflationCurve(cd, useLastKnownFixingDateAsBaseDate, curveBuildIndex, isInterpolated);
 
    BOOST_CHECK_NO_THROW(curve->zeroRate(1.0));
 
    auto index = curveBuildIndex->clone(Handle<ZeroInflationTermStructure>(curve));
 
    std::vector<Date> expectedPillarDates{Date(1, July, 2022), Date(1, June, 2023), Date(1, June, 2024),
                                          Date(1, June, 2025), Date(1, June, 2027)};
 
    std::vector<Real> expectedZeroRates{0.02097086546, 0.02097086546, 0.02068868041, 0.01710609424437, 0.01223686945};
 
    std::vector<Real> expectedCPIs{104, 106., 108.171622850024, 109.281549591561, 110.414070537467};
 
    BOOST_CHECK_EQUAL(curve->baseDate(), expectedPillarDates.front());
 
    BOOST_CHECK_EQUAL(curve->dates().size(), expectedPillarDates.size());
 
    for (size_t i = 0; i < expectedPillarDates.size(); ++i) {
        BOOST_CHECK_EQUAL(curve->dates().at(i), expectedPillarDates.at(i));
        BOOST_CHECK_CLOSE(curve->zeroRate(curve->dates().at(i), 0 * Days), expectedZeroRates.at(i), cd.tolerance);
    }
 
    // Check index fixing forecasts
 
    for (size_t i = 0; i < expectedPillarDates.size(); ++i) {
        auto forwardCPI = index->fixing(expectedPillarDates.at(i));
        BOOST_CHECK_CLOSE(forwardCPI, expectedCPIs.at(i), cd.tolerance);
    }
}

BOOST_AUTO_TEST_CASE() [3/5]

BOOST_AUTO_TEST_CASE

(

testZeroInflationCurveInterpolatedLastMonthFixing

)

Definition at line 185 of file inflationcurve.cpp.

                                                                        {
 
    CommonData cd;
    Settings::instance().evaluationDate() = cd.today;
    bool isInterpolated = true;
    bool useLastKnownFixingDateAsBaseDate = true;
    // Build Curve and Index
    QuantLib::ext::shared_ptr<ZeroInflationIndex> curveBuildIndex = QuantLib::ext::make_shared<EUHICPXT>(false);
    addFixings(cd.cpiFixings, *curveBuildIndex);
    auto curve = buildZeroInflationCurve(cd, useLastKnownFixingDateAsBaseDate, curveBuildIndex, isInterpolated);
 
    BOOST_CHECK_NO_THROW(curve->zeroRate(1.0));
 
    auto index = curveBuildIndex->clone(Handle<ZeroInflationTermStructure>(curve));
 
    std::vector<Date> expectedPillarDates{Date(1, July, 2022), Date(1, July, 2023), Date(1, July, 2024),
                                          Date(1, July, 2025), Date(1, July, 2027)};
 
    std::vector<Real> expectedZeroRates{0.03945267289772, 0.03945267289772, 0.02921461897637, 0.02277721089513,
                                        0.01564691567};
 
    std::vector<Date> fixingDates{Date(15, June, 2022), Date(15, June, 2023), Date(15, June, 2024),
                                  Date(15, June, 2025), Date(15, June, 2027)};
 
    // Base CPI is 100 + (104-100)*14/31, and then for the forward cpi it is baseCPI * (1+r)^T
    std::vector<Real> expectedCPIs{101.806451613, 107.914838710, 110.125690876, 111.255667907, 112.408647296};
 
    BOOST_CHECK_EQUAL(curve->baseDate(), expectedPillarDates.front());
 
    BOOST_CHECK_EQUAL(curve->dates().size(), expectedPillarDates.size());
 
    for (size_t i = 0; i < expectedPillarDates.size(); ++i) {
        BOOST_CHECK_EQUAL(curve->dates().at(i), expectedPillarDates.at(i));
        BOOST_CHECK_CLOSE(curve->zeroRate(curve->dates().at(i), 0 * Days), expectedZeroRates.at(i), 1e-6);
    }
 
    // Check index fixing forecasts
 
    for (size_t i = 0; i < fixingDates.size(); ++i) {
        Date fixDate1 = inflationPeriod(fixingDates.at(i), index->frequency()).first;
        Date fixDate2 = inflationPeriod(fixingDates.at(i), index->frequency()).second + 1 * Days;
        Rate cpi1 = index->fixing(fixDate1);
        Rate cpi2 = index->fixing(fixDate2);
        auto forwardCPI = cpi1 + (cpi2 - cpi1) * 14 / 31;
        BOOST_CHECK_CLOSE(forwardCPI, expectedCPIs.at(i), cd.tolerance);
    }
}

BOOST_AUTO_TEST_CASE() [4/5]

BOOST_AUTO_TEST_CASE

(

testZeroInflationCurveNonInterpolatedLastMonthFixingUnknownWithSeasonality

)

Definition at line 233 of file inflationcurve.cpp.

                                                                                                 {
 
    CommonData cd;
    Settings::instance().evaluationDate() = cd.today;
    bool isInterpolated = false;
    bool useLastKnownFixingDateAsBaseDate = false;
    // Build Curve and Index
    QuantLib::ext::shared_ptr<ZeroInflationIndex> curveBuildIndex = QuantLib::ext::make_shared<EUHICPXT>(false);
    addFixings(cd.cpiFixings, *curveBuildIndex);
    auto seasonalityCurve = buildSeasonalityCurve();
    auto curve = buildZeroInflationCurve(cd, useLastKnownFixingDateAsBaseDate, curveBuildIndex, isInterpolated,
                                         seasonalityCurve);
    BOOST_CHECK_NO_THROW(curve->zeroRate(1.0));
 
    auto index = curveBuildIndex->clone(Handle<ZeroInflationTermStructure>(curve));
 
    std::vector<Date> expectedPillarDates{Date(1, June, 2022), Date(1, June, 2023), Date(1, June, 2024),
                                          Date(1, June, 2025), Date(1, June, 2027)};
 
    std::vector<Real> expectedZeroRates{0.06, 0.06, 0.04, 0.03, 0.02};
 
    std::vector<Real> expectedCPIs{100., 106., 108.171622850024, 109.281549591561, 110.414070537467};
 
    BOOST_CHECK_EQUAL(curve->baseDate(), expectedPillarDates.front());
 
    BOOST_CHECK_EQUAL(curve->dates().size(), expectedPillarDates.size());
 
    for (size_t i = 0; i < expectedPillarDates.size(); ++i) {
        BOOST_CHECK_EQUAL(curve->dates().at(i), expectedPillarDates.at(i));
        BOOST_CHECK_CLOSE(curve->zeroRate(curve->dates().at(i), 0 * Days), expectedZeroRates.at(i), cd.tolerance);
        BOOST_CHECK_CLOSE(curve->data().at(i), expectedZeroRates.at(i), cd.tolerance);
    }
 
    // Check index fixing forecasts
 
    for (size_t i = 0; i < expectedPillarDates.size(); ++i) {
        auto forwardCPI = index->fixing(expectedPillarDates.at(i));
        BOOST_CHECK_CLOSE(forwardCPI, expectedCPIs.at(i), cd.tolerance);
    }
}

BOOST_AUTO_TEST_CASE() [5/5]

BOOST_AUTO_TEST_CASE

(

testZeroInflationCurveNonInterpolatedLastMonthFixingWithSeasonality

)

Definition at line 274 of file inflationcurve.cpp.

                                                                                          {
 
    CommonData cd;
    Settings::instance().evaluationDate() = cd.today;
    bool isInterpolated = false;
    bool useLastKnownFixingDateAsBaseDate = true;
    // Build Curve and Index
    QuantLib::ext::shared_ptr<ZeroInflationIndex> curveBuildIndex = QuantLib::ext::make_shared<EUHICPXT>(false);
    addFixings(cd.cpiFixings, *curveBuildIndex);
    auto seasonalityCurve = buildSeasonalityCurve();
    auto curve = buildZeroInflationCurve(cd, useLastKnownFixingDateAsBaseDate, curveBuildIndex, isInterpolated,
                                         seasonalityCurve);
 
    BOOST_CHECK_NO_THROW(curve->zeroRate(1.0));
 
    auto index = curveBuildIndex->clone(Handle<ZeroInflationTermStructure>(curve));
 
    std::vector<Date> expectedPillarDates{Date(1, July, 2022), Date(1, June, 2023), Date(1, June, 2024),
                                          Date(1, June, 2025), Date(1, June, 2027)};
 
    std::vector<Real> expectedZeroRates{0.02097086546, 0.02097086546, 0.02068868041, 0.01710609424437, 0.01223686945};
    std::vector<Real> expectedZeroRatesWithoutSeasonality{0.02097086546, -0.05439424967, -0.01603861959, -0.00711164972,
                                                          -0.00213855283};
    std::vector<Real> expectedCPIs{104, 106., 108.171622850024, 109.281549591561, 110.414070537467};
 
    BOOST_CHECK_EQUAL(curve->baseDate(), expectedPillarDates.front());
 
    BOOST_CHECK_EQUAL(curve->dates().size(), expectedPillarDates.size());
 
    for (size_t i = 0; i < expectedPillarDates.size(); ++i) {
        BOOST_CHECK_EQUAL(curve->dates().at(i), expectedPillarDates.at(i));
        BOOST_CHECK_CLOSE(curve->data().at(i), expectedZeroRatesWithoutSeasonality.at(i), cd.tolerance);
        BOOST_CHECK_CLOSE(curve->zeroRate(curve->dates().at(i), 0 * Days), expectedZeroRates.at(i), cd.tolerance);
    }
    // Check index fixing forecasts
 
    for (size_t i = 0; i < expectedPillarDates.size(); ++i) {
        auto forwardCPI = index->fixing(expectedPillarDates.at(i));
        BOOST_CHECK_CLOSE(forwardCPI, expectedCPIs.at(i), cd.tolerance);
    }
}