multilegoption.cpp File Reference

#include <boost/test/unit_test.hpp>
#include <test/toplevelfixture.hpp>
#include <qle/pricingengines/mcmultilegoptionengine.hpp>
#include <qle/models/crossassetmodel.hpp>
#include <qle/models/fxbsconstantparametrization.hpp>
#include <qle/pricingengines/analyticcclgmfxoptionengine.hpp>
#include <qle/pricingengines/numericlgmmultilegoptionengine.hpp>
#include <ql/cashflows/simplecashflow.hpp>
#include <ql/currencies/america.hpp>
#include <ql/currencies/europe.hpp>
#include <ql/indexes/ibor/euribor.hpp>
#include <ql/instruments/swaption.hpp>
#include <ql/pricingengines/swap/discountingswapengine.hpp>
#include <ql/quotes/simplequote.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <ql/time/calendars/target.hpp>
#include <ql/time/daycounters/actual360.hpp>
#include <ql/time/daycounters/thirty360.hpp>
#include <boost/timer/timer.hpp>

Go to the source code of this file.

Functions
	BOOST_FIXTURE_TEST_CASE (testBermudanSwaption, BermudanTestData)
	BOOST_AUTO_TEST_CASE (testFxOption)

Function Documentation

BOOST_FIXTURE_TEST_CASE()

BOOST_FIXTURE_TEST_CASE	(	testBermudanSwaption	,
		BermudanTestData
	)

Definition at line 100 of file multilegoption.cpp.

                                                                {
 
    BOOST_TEST_MESSAGE("Testing pricing of bermudan swaption as multi leg option vs numeric swaption engine");
 
    auto multiLegOption = QuantLib::ext::make_shared<MultiLegOption>(
        std::vector<Leg>{underlying->leg(0), underlying->leg(1)}, std::vector<bool>{true, false},
        std::vector<Currency>{EURCurrency(), EURCurrency()}, exercise);
 
    auto lgm_p = QuantLib::ext::make_shared<IrLgm1fPiecewiseConstantHullWhiteAdaptor>(EURCurrency(), yts, stepTimes_a, sigmas_a,
                                                                              stepTimes_a, kappas_a);
 
    auto xasset = Handle<CrossAssetModel>(
        QuantLib::ext::make_shared<CrossAssetModel>(std::vector<QuantLib::ext::shared_ptr<Parametrization>>{lgm_p}));
    auto lgm = QuantLib::ext::make_shared<LinearGaussMarkovModel>(lgm_p);
 
    auto swaptionEngineLgm = QuantLib::ext::make_shared<NumericLgmSwaptionEngine>(lgm, 7.0, 16, 7.0, 32);
    auto swapEngine = QuantLib::ext::make_shared<DiscountingSwapEngine>(yts);
 
    auto mcMultiLegOptionEngine = QuantLib::ext::make_shared<McMultiLegOptionEngine>(
        xasset, SobolBrownianBridge, SobolBrownianBridge, 25000, 0, 42, 42, 4, LsmBasisSystem::Monomial);
 
    underlying->setPricingEngine(swapEngine);
    swaption->setPricingEngine(swaptionEngineLgm);
    Real npvUnd0 = underlying->NPV();
    Real npv0 = swaption->NPV();
    BOOST_TEST_MESSAGE("npv (numeric lgm swaption engine): underlying = " << npvUnd0 << ", option = " << npv0);
 
    boost::timer::cpu_timer timer;
    multiLegOption->setPricingEngine(mcMultiLegOptionEngine);
    Real npvUnd1 = multiLegOption->result<Real>("underlyingNpv");
    Real npv1 = multiLegOption->NPV();
    timer.stop();
    BOOST_TEST_MESSAGE("npv (multi leg option engine)    : underlying = "
                       << npvUnd1 << ", option = " << npv1 << ", timing " << timer.elapsed().wall * 1e-6 << " ms");
 
    BOOST_CHECK_SMALL(std::abs(npvUnd0 - npvUnd1), 1.0E-4);
    BOOST_CHECK_SMALL(std::abs(npv0 - npv1), 1.0E-4);
 
} // testBermudanSwaption

BOOST_AUTO_TEST_CASE()

BOOST_AUTO_TEST_CASE

(

testFxOption

)

Definition at line 140 of file multilegoption.cpp.

                                   {
 
    BOOST_TEST_MESSAGE("Testing pricing of fx option as multi leg option vs analytic engine");
 
    SavedSettings backup;
    Date refDate(12, January, 2015);
    Settings::instance().evaluationDate() = refDate;
 
    auto yts_eur = Handle<YieldTermStructure>(QuantLib::ext::make_shared<FlatForward>(refDate, 0.02, Actual365Fixed()));
    auto yts_usd = Handle<YieldTermStructure>(QuantLib::ext::make_shared<FlatForward>(refDate, 0.03, Actual365Fixed()));
 
    auto lgm_eur_p = QuantLib::ext::make_shared<IrLgm1fConstantParametrization>(EURCurrency(), yts_eur, 0.01, 0.01);
    auto lgm_usd_p = QuantLib::ext::make_shared<IrLgm1fConstantParametrization>(USDCurrency(), yts_usd, 0.01, 0.01);
 
    Handle<Quote> fxspot(QuantLib::ext::make_shared<SimpleQuote>(0.9));
 
    auto fx_p = QuantLib::ext::make_shared<FxBsConstantParametrization>(USDCurrency(), fxspot, 0.15);
 
    Matrix corr(3, 3);
    // clang-format off
    corr[0][0] = 1.0; corr[0][1] = 0.2; corr[0][2] = 0.5;
    corr[1][0] = 0.2; corr[1][1] = 1.0; corr[1][2] = 0.4;
    corr[2][0] = 0.5; corr[2][1] = 0.4; corr[2][2] = 1.0;
    // clang-format on
 
    auto xasset = Handle<CrossAssetModel>(QuantLib::ext::make_shared<CrossAssetModel>(
        std::vector<QuantLib::ext::shared_ptr<Parametrization>>{lgm_eur_p, lgm_usd_p, fx_p}, corr));
 
    Date exDate(12, January, 2020);
    auto exercise = QuantLib::ext::make_shared<EuropeanExercise>(exDate);
    auto fxOption =
        QuantLib::ext::make_shared<VanillaOption>(QuantLib::ext::make_shared<PlainVanillaPayoff>(Option::Call, 0.8), exercise);
 
    Leg usdFlow, eurFlow;
    usdFlow.push_back(QuantLib::ext::make_shared<SimpleCashFlow>(1.0, exDate + 1));
    eurFlow.push_back(QuantLib::ext::make_shared<SimpleCashFlow>(-0.8, exDate + 1));
 
    auto multiLegOption =
        QuantLib::ext::make_shared<MultiLegOption>(std::vector<Leg>{eurFlow, usdFlow}, std::vector<bool>{false, false},
                                           std::vector<Currency>{EURCurrency(), USDCurrency()}, exercise);
 
    auto analyticFxOptionEngine = QuantLib::ext::make_shared<AnalyticCcLgmFxOptionEngine>(*xasset, 0);
    fxOption->setPricingEngine(analyticFxOptionEngine);
    Real npv0 = fxOption->NPV();
    BOOST_TEST_MESSAGE("npv (analytic cclgm fx option engine): " << npv0);
 
    // for european options there is no traning phase actually
    auto mcMultiLegOptionEngine = QuantLib::ext::make_shared<McMultiLegOptionEngine>(
        xasset, SobolBrownianBridge, SobolBrownianBridge, 25000, 0, 42, 42, 4, LsmBasisSystem::Monomial);
 
    multiLegOption->setPricingEngine(mcMultiLegOptionEngine);
    boost::timer::cpu_timer timer;
    Real npv1 = multiLegOption->NPV();
    timer.stop();
    BOOST_TEST_MESSAGE("npv (multi leg option engine)        : " << npv1 << ", timing " << timer.elapsed().wall * 1e-6
                                                                 << " ms");
 
    BOOST_CHECK_SMALL(std::abs(npv1 - npv0), 1.0E-4);
 
} // testFxOption