commodityspreadoption.cpp File Reference

#include "toplevelfixture.hpp"
#include <boost/test/unit_test.hpp>
#include <ql/currencies/america.hpp>
#include <ql/math/interpolations/linearinterpolation.hpp>
#include <ql/math/matrix.hpp>
#include <ql/pricingengines/blackformula.hpp>
#include <ql/settings.hpp>
#include <ql/termstructures/volatility/equityfx/blackconstantvol.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <ql/time/calendars/nullcalendar.hpp>
#include <qle/cashflows/commodityindexedcashflow.hpp>
#include <qle/instruments/commodityspreadoption.hpp>
#include <qle/pricingengines/commodityspreadoptionengine.hpp>
#include <qle/termstructures/pricecurve.hpp>
#include <qle/time/futureexpirycalculator.hpp>
#include <qle/termstructures/flatcorrelation.hpp>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (testCrossAssetFutureSpread)
	BOOST_AUTO_TEST_CASE (testCalendarSpread)
	BOOST_AUTO_TEST_CASE (testCalendarSpread2)
	BOOST_AUTO_TEST_CASE (testCalendarSpreadEdgeCase)
	BOOST_AUTO_TEST_CASE (testSpotAveragingSpreadOption)
	BOOST_AUTO_TEST_CASE (testSeasonedSpotAveragingSpreadOption)
	BOOST_AUTO_TEST_CASE (testFutureAveragingSpreadOption)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/7]

BOOST_AUTO_TEST_CASE

(

testCrossAssetFutureSpread

)

Definition at line 276 of file commodityspreadoption.cpp.

                                                 {
    Date today(5, Nov, 2022);
    Settings::instance().evaluationDate() = today;
 
    double strike = 1;
    double volBrentQuote = 0.3;
    double volWTIQuote = 0.35;
    double quantity = 1000.;
    double WTIspot = 100.;
    double WTINov = 104.;
    double WTIDec = 105.;
    double brentSpot = 101;
    double brentNov = 103;
    double brentDec = 106;
 
    Date novExpiry(30, Nov, 2022);
    Date decExpiry(31, Dec, 2022);
    Date exerciseDate(31, Dec, 2022);
 
    std::vector<Date> futureExpiryDates = {today, novExpiry, decExpiry};
    std::vector<Real> brentQuotes = {brentSpot, brentNov, brentDec};
    std::vector<Real> wtiQuotes = {WTIspot, WTINov, WTIDec};
 
    auto brentCurve = Handle<PriceTermStructure>(QuantLib::ext::make_shared<InterpolatedPriceCurve<Linear>>(
        today, futureExpiryDates, brentQuotes, Actual365Fixed(), USDCurrency()));
    auto wtiCurve = Handle<PriceTermStructure>(QuantLib::ext::make_shared<InterpolatedPriceCurve<Linear>>(
        today, futureExpiryDates, wtiQuotes, Actual365Fixed(), USDCurrency()));
 
    auto discount = Handle<YieldTermStructure>(
        QuantLib::ext::make_shared<FlatForward>(today, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.03)), Actual365Fixed()));
 
    auto brentVol = Handle<BlackVolTermStructure>(
        QuantLib::ext::make_shared<BlackConstantVol>(today, NullCalendar(), volBrentQuote, Actual365Fixed()));
    auto wtiVol = Handle<BlackVolTermStructure>(
        QuantLib::ext::make_shared<BlackConstantVol>(today, NullCalendar(), volWTIQuote, Actual365Fixed()));
 
    auto index1 = QuantLib::ext::make_shared<CommodityFuturesIndex>("BRENT_USD", decExpiry, NullCalendar(), brentCurve);
 
    auto index2 = QuantLib::ext::make_shared<CommodityFuturesIndex>("WTI_USD", decExpiry, NullCalendar(), wtiCurve);
 
    auto flow1 = QuantLib::ext::make_shared<CommodityIndexedCashFlow>(100, decExpiry, decExpiry, index1);
 
    auto flow2 = QuantLib::ext::make_shared<CommodityIndexedCashFlow>(100, decExpiry, decExpiry, index2);
 
    QuantLib::ext::shared_ptr<Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(exerciseDate);
 
    CommoditySpreadOption spreadOption(flow1, flow2, exercise, quantity, strike, Option::Call);
 
    for (const auto& rho : {-0.95, -0.5, -0.25, 0., 0.5, 0.75, 0.9, 0.95}) {
        Handle<CorrelationTermStructure> corr = Handle<CorrelationTermStructure>(ext::make_shared<FlatCorrelation>(0, NullCalendar(), rho, Actual365Fixed())); 
        auto engine = QuantLib::ext::make_shared<CommoditySpreadOptionAnalyticalEngine>(discount, brentVol, wtiVol, corr);
        spreadOption.setPricingEngine(engine);
        double npvMC = monteCarloPricing(brentDec, WTIDec, volBrentQuote, volWTIQuote, rho,
                                         discount->timeFromReference(exercise->lastDate()),
                                         discount->discount(exercise->lastDate()), strike) *
                       quantity;
        double npvKrik = spreadOption.NPV();
        BOOST_CHECK_CLOSE(npvKrik, npvMC, 1.);
    }
}

BOOST_AUTO_TEST_CASE() [2/7]

BOOST_AUTO_TEST_CASE

(

testCalendarSpread

)

Definition at line 337 of file commodityspreadoption.cpp.

                                         {
    Date today(5, Nov, 2022);
    Settings::instance().evaluationDate() = today;
 
    double strike = 1;
    double volBrent = 0.3;
    double rho = 0.9;
    double quantity = 1000.;
    double spot = 100.;
    double futureNov = 104.;
    Date futureNovExpiry(30, Nov, 2022);
    double futureDec = 105.;
    Date futureDecExpiry(31, Dec, 2022);
    Date exerciseDate(15, Nov, 2022);
    Date paymentDate(17, Nov, 2022);
 
    std::vector<Date> futureExpiryDates = {today, futureNovExpiry, futureDecExpiry};
    std::vector<Real> brentQuotes = {spot, futureNov, futureDec};
 
    auto brentCurve = Handle<PriceTermStructure>(QuantLib::ext::make_shared<InterpolatedPriceCurve<Linear>>(
        today, futureExpiryDates, brentQuotes, Actual365Fixed(), USDCurrency()));
 
    auto discount = Handle<YieldTermStructure>(
        QuantLib::ext::make_shared<FlatForward>(today, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.03)), Actual365Fixed()));
 
    auto vol1 = Handle<BlackVolTermStructure>(
        QuantLib::ext::make_shared<BlackConstantVol>(today, NullCalendar(), volBrent, Actual365Fixed()));
 
    auto index1 =
        QuantLib::ext::make_shared<CommodityFuturesIndex>("BRENT_DEC_USD", futureDecExpiry, NullCalendar(), brentCurve);
 
    auto index2 =
        QuantLib::ext::make_shared<CommodityFuturesIndex>("BRENT_NOV_USD", futureNovExpiry, NullCalendar(), brentCurve);
 
    auto flow1 = QuantLib::ext::make_shared<CommodityIndexedCashFlow>(100, futureDecExpiry, Date(31, Dec, 2022), index1);
 
    auto flow2 = QuantLib::ext::make_shared<CommodityIndexedCashFlow>(100, futureNovExpiry, Date(30, Nov, 2022), index2);
 
    QuantLib::ext::shared_ptr<Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(exerciseDate);
 
    CommoditySpreadOption spreadOption(flow1, flow2, exercise, quantity, strike, Option::Call, paymentDate);
 
    Handle<CorrelationTermStructure> corr =
        Handle<CorrelationTermStructure>(ext::make_shared<FlatCorrelation>(0, NullCalendar(), rho, Actual365Fixed())); 
 
    auto engine = QuantLib::ext::make_shared<CommoditySpreadOptionAnalyticalEngine>(discount, vol1, vol1, corr);
 
    spreadOption.setPricingEngine(engine);
 
    double kirkNpv = spreadOption.NPV();
    double mcNpv = quantity * monteCarloPricing(futureDec, futureNov, volBrent, volBrent, rho,
                                                discount->timeFromReference(exercise->lastDate()),
                                                discount->discount(paymentDate), strike);
 
    BOOST_CHECK_CLOSE(kirkNpv, mcNpv, 1);
}

BOOST_AUTO_TEST_CASE() [3/7]

BOOST_AUTO_TEST_CASE

(

testCalendarSpread2

)

Definition at line 394 of file commodityspreadoption.cpp.

                                          {
    Date today(5, Nov, 2022);
    Settings::instance().evaluationDate() = today;
 
    double strike = 1;
    double volBrent = 0.3;
    double rho = 0.9;
    double quantity = 1000.;
    double spot = 100.;
    double futureNov = 104.;
    Date futureNovExpiry(30, Nov, 2022);
    double futureDec = 105.;
    Date futureDecExpiry(31, Dec, 2022);
    Date exerciseDate(31, Dec, 2022);
    Date paymentDate = exerciseDate;
    std::vector<Date> futureExpiryDates = {today, futureNovExpiry, futureDecExpiry};
    std::vector<Real> brentQuotes = {spot, futureNov, futureDec};
 
    auto brentCurve = Handle<PriceTermStructure>(QuantLib::ext::make_shared<InterpolatedPriceCurve<Linear>>(
        today, futureExpiryDates, brentQuotes, Actual365Fixed(), USDCurrency()));
 
    auto discount = Handle<YieldTermStructure>(
        QuantLib::ext::make_shared<FlatForward>(today, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.03)), Actual365Fixed()));
 
    auto vol1 = Handle<BlackVolTermStructure>(
        QuantLib::ext::make_shared<BlackConstantVol>(today, NullCalendar(), volBrent, Actual365Fixed()));
 
    auto index1 =
        QuantLib::ext::make_shared<CommodityFuturesIndex>("BRENT_DEC_USD", futureDecExpiry, NullCalendar(), brentCurve);
 
    auto index2 =
        QuantLib::ext::make_shared<CommodityFuturesIndex>("BRENT_NOV_USD", futureNovExpiry, NullCalendar(), brentCurve);
 
    auto flow1 = QuantLib::ext::make_shared<CommodityIndexedCashFlow>(100, futureDecExpiry, Date(31, Dec, 2022), index1);
 
    auto flow2 = QuantLib::ext::make_shared<CommodityIndexedCashFlow>(100, futureNovExpiry, Date(30, Nov, 2022), index2);
 
    QuantLib::ext::shared_ptr<Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(exerciseDate);
 
    CommoditySpreadOption spreadOption(flow1, flow2, exercise, quantity, strike, Option::Call, paymentDate);
 
    Handle<CorrelationTermStructure> corr =
        Handle<CorrelationTermStructure>(ext::make_shared<FlatCorrelation>(0, NullCalendar(), rho, Actual365Fixed())); 
 
    auto engine = QuantLib::ext::make_shared<CommoditySpreadOptionAnalyticalEngine>(discount, vol1, vol1, corr);
 
    spreadOption.setPricingEngine(engine);
    double kirkNpv = spreadOption.NPV();
 
    double volScalingFactor = std::min(
        std::sqrt(discount->timeFromReference(futureNovExpiry) / discount->timeFromReference(exercise->lastDate())),
        1.0);
 
    double mcNpv = quantity * monteCarloPricing(futureDec, futureNov, volBrent, volBrent * volScalingFactor, rho,
                                                discount->timeFromReference(paymentDate),
                                                discount->discount(exercise->lastDate()), strike);
    BOOST_CHECK_CLOSE(kirkNpv, mcNpv, 1);
}

BOOST_AUTO_TEST_CASE() [4/7]

BOOST_AUTO_TEST_CASE

(

testCalendarSpreadEdgeCase

)

Definition at line 453 of file commodityspreadoption.cpp.

                                                 {
    // The short asset price is already fixed
    Date today(5, Dec, 2022);
    Settings::instance().evaluationDate() = today;
 
    double strike = 1;
    double volBrent = 0.3;
    double rho = 0.9;
    double quantity = 1000.;
    double spot = 100.;
    double futureNov = 104.;
    Date futureNovExpiry(30, Nov, 2022);
    double futureDec = 105.;
    Date futureDecExpiry(31, Dec, 2022);
    Date exerciseDate(31, Dec, 2022);
 
    std::vector<Date> futureExpiryDates = {today, futureDecExpiry};
    std::vector<Real> brentQuotes = {spot, futureDec};
 
    auto brentCurve = Handle<PriceTermStructure>(QuantLib::ext::make_shared<InterpolatedPriceCurve<Linear>>(
        today, futureExpiryDates, brentQuotes, Actual365Fixed(), USDCurrency()));
 
    auto discount = Handle<YieldTermStructure>(
        QuantLib::ext::make_shared<FlatForward>(today, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.03)), Actual365Fixed()));
 
    auto vol1 = Handle<BlackVolTermStructure>(
        QuantLib::ext::make_shared<BlackConstantVol>(today, NullCalendar(), volBrent, Actual365Fixed()));
 
    auto index1 =
        QuantLib::ext::make_shared<CommodityFuturesIndex>("BRENT_DEC_USD", futureDecExpiry, NullCalendar(), brentCurve);
 
    auto index2 =
        QuantLib::ext::make_shared<CommodityFuturesIndex>("BRENT_NOV_USD", futureNovExpiry, NullCalendar(), brentCurve);
 
    index2->addFixing(futureNovExpiry, futureNov);
 
    auto flow1 = QuantLib::ext::make_shared<CommodityIndexedCashFlow>(100, futureDecExpiry, Date(31, Dec, 2022), index1);
 
    auto flow2 = QuantLib::ext::make_shared<CommodityIndexedCashFlow>(100, futureNovExpiry, Date(30, Nov, 2022), index2);
 
    QuantLib::ext::shared_ptr<Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(exerciseDate);
 
    CommoditySpreadOption spreadOption(flow1, flow2, exercise, quantity, strike, Option::Call, exerciseDate);
 
    Handle<CorrelationTermStructure> corr =
        Handle<CorrelationTermStructure>(ext::make_shared<FlatCorrelation>(0, NullCalendar(), rho, Actual365Fixed())); 
 
    auto engine = QuantLib::ext::make_shared<CommoditySpreadOptionAnalyticalEngine>(discount, vol1, vol1, corr);
 
    spreadOption.setPricingEngine(engine);
    double kirkNpv = spreadOption.NPV();
 
    double bsNpv = quantity * blackFormula(QuantLib::Option::Call, strike + futureNov, futureDec,
                                           std::sqrt(vol1->blackVariance(futureDecExpiry, strike + futureNov)),
                                           discount->discount(exercise->lastDate()));
 
    BOOST_CHECK_CLOSE(kirkNpv, bsNpv, 1e-8);
}

BOOST_AUTO_TEST_CASE() [5/7]

BOOST_AUTO_TEST_CASE

(

testSpotAveragingSpreadOption

)

Definition at line 512 of file commodityspreadoption.cpp.

                                                    {
    Date today(31, Oct, 2022);
    Settings::instance().evaluationDate() = today;
 
    double strike = 1;
    double volBrentQuote = 0.3;
    double volWTIQuote = 0.35;
    double quantity = 1000.;
    double WTIspot = 100.;
    double WTINov = 104.;
    double WTIDec = 105.;
    double brentSpot = 101;
    double brentNov = 103;
    double brentDec = 106;
 
    Date novExpiry(30, Nov, 2022);
    Date decExpiry(31, Dec, 2022);
    Date exerciseDate(31, Dec, 2022);
 
    std::vector<Date> futureExpiryDates = {today, novExpiry, decExpiry};
    std::vector<Real> brentQuotes = {brentSpot, brentNov, brentDec};
    std::vector<Real> wtiQuotes = {WTIspot, WTINov, WTIDec};
 
    auto brentCurve = Handle<PriceTermStructure>(QuantLib::ext::make_shared<InterpolatedPriceCurve<Linear>>(
        today, futureExpiryDates, brentQuotes, Actual365Fixed(), USDCurrency()));
    auto wtiCurve = Handle<PriceTermStructure>(QuantLib::ext::make_shared<InterpolatedPriceCurve<Linear>>(
        today, futureExpiryDates, wtiQuotes, Actual365Fixed(), USDCurrency()));
 
    auto discount = Handle<YieldTermStructure>(
        QuantLib::ext::make_shared<FlatForward>(today, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.03)), Actual365Fixed()));
 
    auto brentVol = Handle<BlackVolTermStructure>(
        QuantLib::ext::make_shared<BlackConstantVol>(today, NullCalendar(), volBrentQuote, Actual365Fixed()));
    auto wtiVol = Handle<BlackVolTermStructure>(
        QuantLib::ext::make_shared<BlackConstantVol>(today, NullCalendar(), volWTIQuote, Actual365Fixed()));
 
    auto index1 = QuantLib::ext::make_shared<CommoditySpotIndex>("BRENT_USD", NullCalendar(), brentCurve);
 
    auto index2 = QuantLib::ext::make_shared<CommoditySpotIndex>("WTI_USD", NullCalendar(), wtiCurve);
 
    auto flow1 = QuantLib::ext::make_shared<CommodityIndexedAverageCashFlow>(quantity, Date(1, Dec, 2022), Date(31, Dec, 2022),
                                                                     Date(31, Dec, 2022), index1, NullCalendar());
 
    auto flow2 = QuantLib::ext::make_shared<CommodityIndexedAverageCashFlow>(quantity, Date(1, Dec, 2022), Date(31, Dec, 2022),
                                                                     Date(31, Dec, 2022), index2, NullCalendar());
 
    QuantLib::ext::shared_ptr<Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(exerciseDate);
 
    CommoditySpreadOption spreadOption(flow1, flow2, exercise, quantity, strike, Option::Call);
 
    Real df = discount->discount(exercise->lastDate());
 
    for (const auto& rho : {-0.9, -0.75, -0.5, -0.25, 0., 0.25, 0.5, 0.75, 0.9}) {
 
        Handle<CorrelationTermStructure> corr = Handle<CorrelationTermStructure>(
            ext::make_shared<FlatCorrelation>(0, NullCalendar(), rho, Actual365Fixed())); 
        auto engine = QuantLib::ext::make_shared<CommoditySpreadOptionAnalyticalEngine>(discount, brentVol, wtiVol, corr);
        spreadOption.setPricingEngine(engine);
        double npvMC = quantity * monteCarloPricingSpotAveraging(flow1, *brentCurve, *brentVol, flow2, *wtiCurve,
                                                                 *wtiVol, rho, strike, df);
        double npvKirk = spreadOption.NPV();
        BOOST_CHECK_CLOSE(npvKirk, npvMC, 1);
    }
}

BOOST_AUTO_TEST_CASE() [6/7]

BOOST_AUTO_TEST_CASE

(

testSeasonedSpotAveragingSpreadOption

)

Definition at line 577 of file commodityspreadoption.cpp.

                                                            {
    Date today(10, Nov, 2022);
    Settings::instance().evaluationDate() = today;
 
    double strike = 1;
    double volBrentQuote = 0.3;
    double volWTIQuote = 0.35;
    double quantity = 1000.;
    double WTIspot = 100.;
    double WTINov = 103.;
    double WTIDec = 105.;
    double brentSpot = 100;
    double brentNov = 104;
    double brentDec = 106;
 
    Date novExpiry(30, Nov, 2022);
    Date decExpiry(31, Dec, 2022);
    Date exerciseDate(30, Nov, 2022);
 
    std::vector<Date> futureExpiryDates = {today, novExpiry, decExpiry};
    std::vector<Real> brentQuotes = {brentSpot, brentNov, brentDec};
    std::vector<Real> wtiQuotes = {WTIspot, WTINov, WTIDec};
 
    vector<Date> fixingDates;
 
    vector<Real> fixingValuesBrent;
    vector<Real> fixingValuesWTI;
 
    for (int i = 1; i <= 10; ++i) {
        fixingDates.push_back(Date(i, Nov, 2022));
        fixingValuesBrent.push_back(100 + i / 10.);
        fixingValuesWTI.push_back(100 - i / 10.);
    }
 
    auto brentCurve = Handle<PriceTermStructure>(QuantLib::ext::make_shared<InterpolatedPriceCurve<Linear>>(
        today, futureExpiryDates, brentQuotes, Actual365Fixed(), USDCurrency()));
    auto wtiCurve = Handle<PriceTermStructure>(QuantLib::ext::make_shared<InterpolatedPriceCurve<Linear>>(
        today, futureExpiryDates, wtiQuotes, Actual365Fixed(), USDCurrency()));
 
    auto discount = Handle<YieldTermStructure>(
        QuantLib::ext::make_shared<FlatForward>(today, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.03)), Actual365Fixed()));
 
    auto brentVol = Handle<BlackVolTermStructure>(
        QuantLib::ext::make_shared<BlackConstantVol>(today, NullCalendar(), volBrentQuote, Actual365Fixed()));
    auto wtiVol = Handle<BlackVolTermStructure>(
        QuantLib::ext::make_shared<BlackConstantVol>(today, NullCalendar(), volWTIQuote, Actual365Fixed()));
 
    auto index1 = QuantLib::ext::make_shared<CommoditySpotIndex>("BRENT_USD", NullCalendar(), brentCurve);
 
    auto index2 = QuantLib::ext::make_shared<CommoditySpotIndex>("WTI_USD", NullCalendar(), wtiCurve);
 
    index1->addFixings(fixingDates.begin(), fixingDates.end(), fixingValuesBrent.begin());
    index2->addFixings(fixingDates.begin(), fixingDates.end(), fixingValuesWTI.begin());
 
    auto flow1 = QuantLib::ext::make_shared<CommodityIndexedAverageCashFlow>(quantity, Date(1, Nov, 2022), Date(30, Nov, 2022),
                                                                     Date(30, Nov, 2022), index1, NullCalendar());
 
    auto flow2 = QuantLib::ext::make_shared<CommodityIndexedAverageCashFlow>(quantity, Date(1, Nov, 2022), Date(30, Nov, 2022),
                                                                     Date(30, Nov, 2022), index2, NullCalendar());
 
    QuantLib::ext::shared_ptr<Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(exerciseDate);
 
    Real df = discount->discount(exercise->lastDate());
 
    for (const auto& rho : {-0.9, -0.75, -0.5, -0.25, 0., 0.25, 0.5, 0.75, 0.9}) {
        CommoditySpreadOption spreadOption(flow1, flow2, exercise, quantity, strike, Option::Call);
 
        Handle<CorrelationTermStructure> corr = Handle<CorrelationTermStructure>(
            ext::make_shared<FlatCorrelation>(0, NullCalendar(), rho, Actual365Fixed())); 
        auto engine = QuantLib::ext::make_shared<CommoditySpreadOptionAnalyticalEngine>(discount, brentVol, wtiVol, corr);
        spreadOption.setPricingEngine(engine);
        double npvMC = quantity * monteCarloPricingSpotAveraging(flow1, *brentCurve, *brentVol, flow2, *wtiCurve,
                                                                 *wtiVol, rho, strike, df);
        double npvKirk = spreadOption.NPV();
        BOOST_CHECK_CLOSE(npvKirk, npvMC, 1);
 
    }
 
    for (const auto& rho : {0.85}) {
        for (const auto& strike : {0.5, 1., 1.5, 2.0, 2.5}) {
            CommoditySpreadOption spreadOption(flow1, flow2, exercise, quantity, strike, Option::Call);
 
            Handle<CorrelationTermStructure> corr = Handle<CorrelationTermStructure>(
                ext::make_shared<FlatCorrelation>(0, NullCalendar(), rho, Actual365Fixed())); 
            auto engine = QuantLib::ext::make_shared<CommoditySpreadOptionAnalyticalEngine>(discount, brentVol, wtiVol, corr);
            spreadOption.setPricingEngine(engine);
            double npvMC = quantity * monteCarloPricingSpotAveraging(flow1, *brentCurve, *brentVol, flow2, *wtiCurve,
                                                                     *wtiVol, rho, strike, df);
            double npvKirk = spreadOption.NPV();
            BOOST_CHECK_CLOSE(npvKirk, npvMC, 1);
        }
    }
}

BOOST_AUTO_TEST_CASE() [7/7]

BOOST_AUTO_TEST_CASE

(

testFutureAveragingSpreadOption

)

Definition at line 671 of file commodityspreadoption.cpp.

                                                      {
    Date today(31, Oct, 2022);
    Settings::instance().evaluationDate() = today;
 
    double strike = 1;
    double volBrentQuote = 0.3;
    double volWTIQuote = 0.35;
    double quantity = 1000.;
    double WTIspot = 100.;
    double WTINov = 104.;
    double WTIDec = 105.;
    double brentSpot = 101;
    double brentNov = 103;
    double brentDec = 106;
 
    Date novExpiry(30, Nov, 2022);
    Date decExpiry(31, Dec, 2022);
    Date exerciseDate(31, Dec, 2022);
 
    std::vector<Date> futureExpiryDates = {today, novExpiry, decExpiry};
    std::vector<Real> brentQuotes = {brentSpot, brentNov, brentDec};
    std::vector<Real> wtiQuotes = {WTIspot, WTINov, WTIDec};
 
    auto feCalc = ext::make_shared<MockUpExpiryCalculator>();
 
    auto brentCurve = Handle<PriceTermStructure>(QuantLib::ext::make_shared<InterpolatedPriceCurve<Linear>>(
        today, futureExpiryDates, brentQuotes, Actual365Fixed(), USDCurrency()));
    auto wtiCurve = Handle<PriceTermStructure>(QuantLib::ext::make_shared<InterpolatedPriceCurve<Linear>>(
        today, futureExpiryDates, wtiQuotes, Actual365Fixed(), USDCurrency()));
 
    auto discount = Handle<YieldTermStructure>(
        QuantLib::ext::make_shared<FlatForward>(today, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(0.03)), Actual365Fixed()));
 
    auto brentVol = Handle<BlackVolTermStructure>(
        QuantLib::ext::make_shared<BlackConstantVol>(today, NullCalendar(), volBrentQuote, Actual365Fixed()));
    auto wtiVol = Handle<BlackVolTermStructure>(
        QuantLib::ext::make_shared<BlackConstantVol>(today, NullCalendar(), volWTIQuote, Actual365Fixed()));
 
    auto index1 = QuantLib::ext::make_shared<CommodityFuturesIndex>("BRENT_USD", novExpiry, NullCalendar(), brentCurve);
 
    auto index2 = QuantLib::ext::make_shared<CommodityFuturesIndex>("WTI_USD", novExpiry, NullCalendar(), wtiCurve);
 
    auto flow1 = QuantLib::ext::make_shared<CommodityIndexedAverageCashFlow>(quantity, Date(1, Dec, 2022), Date(31, Dec, 2022),
                                                                     Date(31, Dec, 2022), index1, NullCalendar(), 0.0,
                                                                     1.0, true, 0, 0, feCalc);
 
    auto flow2 = QuantLib::ext::make_shared<CommodityIndexedAverageCashFlow>(quantity, Date(1, Dec, 2022), Date(31, Dec, 2022),
                                                                     Date(31, Dec, 2022), index2, NullCalendar(), 0.0,
                                                                     1.0, true, 0, 0, feCalc);
 
    QuantLib::ext::shared_ptr<Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(exerciseDate);
 
    CommoditySpreadOption spreadOption(flow1, flow2, exercise, quantity, strike, Option::Call);
 
    Real df = discount->discount(exercise->lastDate());
 
    for (const auto& rho : {-0.9, -0.75, -0.5, -0.25, 0., 0.25, 0.5, 0.75, 0.9}) {
 
        Handle<CorrelationTermStructure> corr = Handle<CorrelationTermStructure>(
            ext::make_shared<FlatCorrelation>(0, NullCalendar(), rho, Actual365Fixed())); 
        auto engine = QuantLib::ext::make_shared<CommoditySpreadOptionAnalyticalEngine>(discount, brentVol, wtiVol, corr);
        spreadOption.setPricingEngine(engine);
        double npvMC = quantity * monteCarloPricingFutureAveraging(flow1, *brentCurve, *brentVol, flow2, *wtiCurve,
                                                                   *wtiVol, rho, strike, df);
        double npvKirk = spreadOption.NPV();
        BOOST_CHECK_CLOSE(npvKirk, npvMC, 1);
    }
}