blackswaptionenginedeltagamma.cpp File Reference

#include "toplevelfixture.hpp"
#include <boost/test/unit_test.hpp>
#include <qle/pricingengines/blackswaptionenginedeltagamma.hpp>
#include <ql/indexes/ibor/euribor.hpp>
#include <ql/instruments/makevanillaswap.hpp>
#include <ql/pricingengines/swaption/blackswaptionengine.hpp>
#include <ql/quotes/simplequote.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <ql/termstructures/yield/piecewisezerospreadedtermstructure.hpp>
#include <boost/make_shared.hpp>
#include <boost/timer/timer.hpp>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (testNpvDeltasGammaVegas)

Function Documentation

BOOST_AUTO_TEST_CASE()

BOOST_AUTO_TEST_CASE

(

testNpvDeltasGammaVegas

)

Definition at line 342 of file blackswaptionenginedeltagamma.cpp.

                                              {
 
    TestData d;
 
    QuantLib::ext::shared_ptr<PricingEngine> engineLn0 =
        QuantLib::ext::make_shared<BlackSwaptionEngine>(d.discountCurve, Handle<Quote>(d.lnVol));
    QuantLib::ext::shared_ptr<PricingEngine> engineSln0 =
        QuantLib::ext::make_shared<BlackSwaptionEngine>(d.discountCurve, Handle<Quote>(d.slnVol), Actual365Fixed(), d.slnShift);
    QuantLib::ext::shared_ptr<PricingEngine> engineN0 =
        QuantLib::ext::make_shared<BachelierSwaptionEngine>(d.discountCurve, Handle<Quote>(d.nVol));
 
    QuantLib::ext::shared_ptr<PricingEngine> engineLn =
        QuantLib::ext::make_shared<BlackSwaptionEngineDeltaGamma>(d.discountCurve, Handle<Quote>(d.lnVol), Actual365Fixed(),
                                                          0.0, d.pillarTimes, d.pillarTimes, d.pillarTimes, true, true);
    QuantLib::ext::shared_ptr<PricingEngine> engineSln = QuantLib::ext::make_shared<BlackSwaptionEngineDeltaGamma>(
        d.discountCurve, Handle<Quote>(d.slnVol), Actual365Fixed(), d.slnShift, d.pillarTimes, d.pillarTimes,
        d.pillarTimes, true, true);
    QuantLib::ext::shared_ptr<PricingEngine> engineN =
        QuantLib::ext::make_shared<BachelierSwaptionEngineDeltaGamma>(d.discountCurve, Handle<Quote>(d.nVol), Actual365Fixed(),
                                                              d.pillarTimes, d.pillarTimes, d.pillarTimes, true, true);
 
    performTest(d, engineLn0, engineLn, false, 0.0, "lognormal model, payer");
    performTest(d, engineSln0, engineSln, false, 0.0, "shifted lognormal model, payer");
    performTest(d, engineN0, engineN, false, 0.0, "normal model, payer");
 
    performTest(d, engineLn0, engineLn, true, 0.0, "lognormal model, receiver");
    performTest(d, engineSln0, engineSln, true, 0.0, "shifted lognormal model, receiver");
    performTest(d, engineN0, engineN, true, 0.0, "normal model, receiver");
 
    // the tests with non-zero spread fail, fix it later in the engine, for now we check for zero spreads there
 
    // performTest(d, engineLn0, engineLn, false, 0.01, "lognormal model, payer, spread");
    // performTest(d, engineSln0, engineSln, false, 0.01, "shifted lognormal model, payer, spread");
    // performTest(d, engineN0, engineN, false, 0.01, "normal model, payer, spread");
 
    // performTest(d, engineLn0, engineLn, true, 0.01, "lognormal model, receiver, spread");
    // performTest(d, engineSln0, engineSln, true, 0.01, "shifted lognormal model, receiver, spread");
    // performTest(d, engineN0, engineN, true, 0.01, "normal model, receiver, spread");
 
    BOOST_CHECK(true);
}