formulabasedcoupon.cpp File Reference

#include "toplevelfixture.hpp"
#include <boost/assign/std/vector.hpp>
#include <qle/cashflows/formulabasedcoupon.hpp>
#include <qle/cashflows/mcgaussianformulabasedcouponpricer.hpp>
#include <qle/indexes/formulabasedindex.hpp>
#include <ql/cashflows/capflooredcoupon.hpp>
#include <ql/cashflows/cmscoupon.hpp>
#include <ql/cashflows/iborcoupon.hpp>
#include <ql/cashflows/lineartsrpricer.hpp>
#include <ql/currencies/america.hpp>
#include <ql/currencies/europe.hpp>
#include <ql/experimental/coupons/lognormalcmsspreadpricer.hpp>
#include <ql/indexes/ibor/euribor.hpp>
#include <ql/indexes/swap/euriborswap.hpp>
#include <ql/math/array.hpp>
#include <ql/math/comparison.hpp>
#include <ql/quotes/simplequote.hpp>
#include <ql/termstructures/volatility/equityfx/blackconstantvol.hpp>
#include <ql/termstructures/volatility/optionlet/constantoptionletvol.hpp>
#include <ql/termstructures/volatility/swaption/swaptionconstantvol.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <ql/time/calendars/target.hpp>
#include <ql/time/daycounters/actual360.hpp>
#include <qle/cashflows/quantocouponpricer.hpp>
#include <qle/termstructures/flatcorrelation.hpp>
#include <boost/make_shared.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/timer/timer.hpp>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (testCappedLiborCoupon)
	BOOST_AUTO_TEST_CASE (testCappedCmsCoupon)
	BOOST_AUTO_TEST_CASE (testCappedCmsSpreadCoupon)
	BOOST_AUTO_TEST_CASE (testQuantoLiborCoupon)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/4]

BOOST_AUTO_TEST_CASE

(

testCappedLiborCoupon

)

Definition at line 187 of file formulabasedcoupon.cpp.

                                            {
 
    BOOST_TEST_MESSAGE("Testing formula based coupons against capped Libor coupon...");
 
    TestData d;
 
    auto euribor6m = QuantLib::ext::make_shared<Euribor>(6 * Months, d.yts2);
 
    CompiledFormula formulaPlain = CompiledFormula(Size(0));                              // plain payoff
    CompiledFormula formulaCapped = min(CompiledFormula(Size(0)), CompiledFormula(0.03)); // capped ibor coupon, at 0.03
 
    auto indexPlain = QuantLib::ext::make_shared<FormulaBasedIndex>(
        "libor-family", std::vector<QuantLib::ext::shared_ptr<InterestRateIndex>>{euribor6m}, formulaPlain,
        euribor6m->fixingCalendar());
    auto indexCapped = QuantLib::ext::make_shared<FormulaBasedIndex>(
        "libor-family", std::vector<QuantLib::ext::shared_ptr<InterestRateIndex>>{euribor6m}, formulaCapped,
        euribor6m->fixingCalendar());
 
    auto undRef = QuantLib::ext::make_shared<IborCoupon>(Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                                 Date(23, February, 2029), 2, euribor6m, 1.0, 0.0, Date(), Date(),
                                                 Actual360(), false);
    auto cappedRef = QuantLib::ext::make_shared<CappedFlooredCoupon>(undRef, 0.03);
 
    QuantLib::ext::shared_ptr<QuantExt::FormulaBasedCoupon> und(
        new QuantExt::FormulaBasedCoupon(EURCurrency(), Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                         Date(23, February, 2029), 2, indexPlain, Date(), Date(), Actual360(), false));
    QuantLib::ext::shared_ptr<QuantExt::FormulaBasedCoupon> capped(
        new QuantExt::FormulaBasedCoupon(EURCurrency(), Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                         Date(23, February, 2029), 2, indexCapped, Date(), Date(), Actual360(), false));
 
    runTest(und, undRef, d.formulaPricerLn, d.blackPricerLn, "Plain Ibor Coupon, Lognormal", 0.05);
    runTest(und, undRef, d.formulaPricerSln, d.blackPricerSln, "Plain Ibor Coupon, ShiftedLN", 0.05);
    runTest(und, undRef, d.formulaPricerN, d.blackPricerN, "Plain Ibor Coupon, Normal", 0.05);
 
    runTest(capped, cappedRef, d.formulaPricerLn, d.blackPricerLn, "Capped Ibor Coupon, Lognormal", 0.05);
    runTest(capped, cappedRef, d.formulaPricerSln, d.blackPricerSln, "Capped Ibor Coupon, ShiftedLN", 0.05);
    runTest(capped, cappedRef, d.formulaPricerN, d.blackPricerN, "Capped Ibor Coupon, Normal", 0.05);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [2/4]

BOOST_AUTO_TEST_CASE

(

testCappedCmsCoupon

)

Definition at line 226 of file formulabasedcoupon.cpp.

                                          {
 
    BOOST_TEST_MESSAGE("Testing formula based coupons against capped CMS coupon...");
 
    TestData d;
 
    auto cms10y = QuantLib::ext::make_shared<EuriborSwapIsdaFixA>(10 * Years, d.yts2, d.yts2);
 
    CompiledFormula formulaPlain = CompiledFormula(Size(0));                              // plain payoff
    CompiledFormula formulaCapped = min(CompiledFormula(Size(0)), CompiledFormula(0.03)); // capped cms coupon, at 0.03
 
    auto indexPlain =
        QuantLib::ext::make_shared<FormulaBasedIndex>("cms-family", std::vector<QuantLib::ext::shared_ptr<InterestRateIndex>>{cms10y},
                                              formulaPlain, cms10y->fixingCalendar());
    auto indexCapped =
        QuantLib::ext::make_shared<FormulaBasedIndex>("cms-family", std::vector<QuantLib::ext::shared_ptr<InterestRateIndex>>{cms10y},
                                              formulaCapped, cms10y->fixingCalendar());
 
    auto undRef = QuantLib::ext::make_shared<CmsCoupon>(Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                                Date(23, February, 2029), 2, cms10y, 1.0, 0.0, Date(), Date(),
                                                Actual360(), false);
    auto cappedRef = QuantLib::ext::make_shared<CappedFlooredCoupon>(undRef, 0.03);
 
    QuantLib::ext::shared_ptr<QuantExt::FormulaBasedCoupon> und(
        new QuantExt::FormulaBasedCoupon(EURCurrency(), Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                         Date(23, February, 2029), 2, indexPlain, Date(), Date(), Actual360(), false));
    QuantLib::ext::shared_ptr<QuantExt::FormulaBasedCoupon> capped(
        new QuantExt::FormulaBasedCoupon(EURCurrency(), Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                         Date(23, February, 2029), 2, indexCapped, Date(), Date(), Actual360(), false));
 
    runTest(und, undRef, d.formulaPricerLn, d.cmsPricerLn, "Plain CMS Coupon, Lognormal", 0.05);
    runTest(und, undRef, d.formulaPricerSln, d.cmsPricerSln, "Plain CMS Coupon, ShiftedLN", 0.05);
    runTest(und, undRef, d.formulaPricerN, d.cmsPricerN, "Plain CMS Coupon, Normal", 0.05);
 
    // the replication model and the model in the formula coupon pricer are not identical,
    // so we can not check for identical results; there should be reaosonably close though,
    // check for 2bp difference
    runTest(capped, cappedRef, d.formulaPricerLn, d.cmsPricerLn, "Capped CMS Coupon, Lognormal", 2.0);
    runTest(capped, cappedRef, d.formulaPricerSln, d.cmsPricerSln, "Capped CMS Coupon, ShiftedLN", 2.0);
    runTest(capped, cappedRef, d.formulaPricerN, d.cmsPricerN, "Capped CMS Coupon, Normal", 2.0);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [3/4]

BOOST_AUTO_TEST_CASE

(

testCappedCmsSpreadCoupon

)

Definition at line 268 of file formulabasedcoupon.cpp.

                                                {
 
    BOOST_TEST_MESSAGE("Testing formula based coupons against capped CMS spread coupon...");
 
    TestData d;
 
    auto cms2y = QuantLib::ext::make_shared<EuriborSwapIsdaFixA>(2 * Years, d.yts2, d.yts2);
    auto cms10y = QuantLib::ext::make_shared<EuriborSwapIsdaFixA>(10 * Years, d.yts2, d.yts2);
    auto cms10y2y = QuantLib::ext::make_shared<SwapSpreadIndex>("cms10y2y", cms10y, cms2y);
 
    CompiledFormula formulaPlain = CompiledFormula(Size(1)) - CompiledFormula(Size(0)); // plain payoff
    CompiledFormula formulaCapped = min(CompiledFormula(Size(1)) - CompiledFormula(Size(0)),
                                        CompiledFormula(0.03)); // capped cms sp coupon, at 0.03
 
    auto indexPlain = QuantLib::ext::make_shared<FormulaBasedIndex>(
        "cmssp-family", std::vector<QuantLib::ext::shared_ptr<InterestRateIndex>>{cms2y, cms10y}, formulaPlain,
        cms10y2y->fixingCalendar());
    auto indexCapped = QuantLib::ext::make_shared<FormulaBasedIndex>(
        "cmssp-family", std::vector<QuantLib::ext::shared_ptr<InterestRateIndex>>{cms2y, cms10y}, formulaCapped,
        cms10y2y->fixingCalendar());
 
    auto undRef = QuantLib::ext::make_shared<CmsSpreadCoupon>(Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                                      Date(23, February, 2029), 2, cms10y2y, 1.0, 0.0, Date(), Date(),
                                                      Actual360(), false);
    auto cappedRef = QuantLib::ext::make_shared<CappedFlooredCoupon>(undRef, 0.03);
 
    QuantLib::ext::shared_ptr<QuantExt::FormulaBasedCoupon> und(
        new QuantExt::FormulaBasedCoupon(EURCurrency(), Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                         Date(23, February, 2029), 2, indexPlain, Date(), Date(), Actual360(), false));
    QuantLib::ext::shared_ptr<QuantExt::FormulaBasedCoupon> capped(
        new QuantExt::FormulaBasedCoupon(EURCurrency(), Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                         Date(23, February, 2029), 2, indexCapped, Date(), Date(), Actual360(), false));
 
    runTest(und, undRef, d.formulaPricerLn, d.cmsspPricerLn, "Plain CmsSp Coupon, Lognormal", 0.05);
    runTest(und, undRef, d.formulaPricerSln, d.cmsspPricerSln, "Plain CmsSp Coupon, ShiftedLN", 0.05);
    runTest(und, undRef, d.formulaPricerN, d.cmsspPricerN, "Plain CmsSp Coupon, Normal", 0.05);
 
    runTest(capped, cappedRef, d.formulaPricerLn, d.cmsspPricerLn, "Capped CmsSp Coupon, Lognormal", 0.05);
    runTest(capped, cappedRef, d.formulaPricerSln, d.cmsspPricerSln, "Capped CmsSp Coupon, ShiftedLN", 0.05);
    runTest(capped, cappedRef, d.formulaPricerN, d.cmsspPricerN, "Capped CmsSp Coupon, Normal", 0.05);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [4/4]

BOOST_AUTO_TEST_CASE

(

testQuantoLiborCoupon

)

Definition at line 310 of file formulabasedcoupon.cpp.

                                            {
 
    BOOST_TEST_MESSAGE("Testing formula based coupons against (capped) Quanto Libor coupon...");
 
    TestData d;
 
    auto euribor6m = QuantLib::ext::make_shared<Euribor>(6 * Months, d.yts2);
 
    CompiledFormula formulaPlain = CompiledFormula(Size(0));                              // plain payoff
    CompiledFormula formulaCapped = min(CompiledFormula(Size(0)), CompiledFormula(0.03)); // capped ibor coupon, at 0.03
 
    auto indexPlain = QuantLib::ext::make_shared<FormulaBasedIndex>(
        "libor-family", std::vector<QuantLib::ext::shared_ptr<InterestRateIndex>>{euribor6m}, formulaPlain,
        euribor6m->fixingCalendar());
    auto indexCapped = QuantLib::ext::make_shared<FormulaBasedIndex>(
        "libor-family", std::vector<QuantLib::ext::shared_ptr<InterestRateIndex>>{euribor6m}, formulaCapped,
        euribor6m->fixingCalendar());
 
    auto undRef = QuantLib::ext::make_shared<IborCoupon>(Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                                 Date(23, February, 2029), 2, euribor6m, 1.0, 0.0, Date(), Date(),
                                                 Actual360(), false);
    auto cappedRef = QuantLib::ext::make_shared<CappedFlooredCoupon>(undRef, 0.03);
 
    QuantLib::ext::shared_ptr<QuantExt::FormulaBasedCoupon> und(
        new QuantExt::FormulaBasedCoupon(USDCurrency(), Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                         Date(23, February, 2029), 2, indexPlain, Date(), Date(), Actual360(), false));
    QuantLib::ext::shared_ptr<QuantExt::FormulaBasedCoupon> capped(
        new QuantExt::FormulaBasedCoupon(USDCurrency(), Date(23, February, 2029), 10000.0, Date(23, February, 2028),
                                         Date(23, February, 2029), 2, indexCapped, Date(), Date(), Actual360(), false));
 
    runTest(und, undRef, d.formulaPricerUSDLn, d.blackQuantoPricerLn, "Plain Quanto Ibor Coupon, Lognormal", 0.05);
    runTest(und, undRef, d.formulaPricerUSDSln, d.blackQuantoPricerSln, "Plain Quanto Ibor Coupon, ShiftedLN", 0.05);
    runTest(und, undRef, d.formulaPricerUSDN, d.blackQuantoPricerN, "Plain Quanto Ibor Coupon, Normal", 0.05);
 
    runTest(capped, cappedRef, d.formulaPricerUSDLn, d.blackQuantoPricerLn, "Capped Quanto Ibor Coupon, Lognormal",
            0.05);
    runTest(capped, cappedRef, d.formulaPricerUSDSln, d.blackQuantoPricerSln, "Capped Quanto Ibor Coupon, ShiftedLN",
            0.05);
    runTest(capped, cappedRef, d.formulaPricerUSDN, d.blackQuantoPricerN, "Capped Quanto Ibor Coupon, Normal", 0.05);
}

Here is the call graph for this function: