commodityschwartzmodel.cpp File Reference

#include "utilities.hpp"
#include "toplevelfixture.hpp"
#include <boost/test/unit_test.hpp>
#include <boost/make_shared.hpp>
#include <boost/test/data/test_case.hpp>
#include <ql/currencies/america.hpp>
#include <ql/math/interpolations/linearinterpolation.hpp>
#include <ql/math/optimization/levenbergmarquardt.hpp>
#include <ql/math/randomnumbers/rngtraits.hpp>
#include <ql/math/statistics/incrementalstatistics.hpp>
#include <ql/methods/montecarlo/multipathgenerator.hpp>
#include <ql/methods/montecarlo/pathgenerator.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/actualactual.hpp>
#include <ql/time/daycounters/thirty360.hpp>
#include <qle/methods/multipathgeneratorbase.hpp>
#include <qle/models/commodityschwartzmodel.hpp>
#include <qle/models/commodityschwartzparametrization.hpp>
#include <qle/processes/commodityschwartzstateprocess.hpp>
#include <qle/termstructures/pricecurve.hpp>
#include <fstream>
#include <iostream>
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/covariance.hpp>
#include <boost/accumulators/statistics/density.hpp>
#include <boost/accumulators/statistics/error_of_mean.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/variates/covariate.hpp>

Go to the source code of this file.

Functions
	BOOST_DATA_TEST_CASE (testMartingaleProperty, bdata::make(driftFreeState) *bdata::make(steps), driftFreeState, steps)

Variables
std::vector< bool >	driftFreeState { true, false }
std::vector< Size >	steps { 1, 52 }

Function Documentation

BOOST_DATA_TEST_CASE()

BOOST_DATA_TEST_CASE	(	testMartingaleProperty	,
		bdata::make(driftFreeState) *bdata::make(steps)	,
		driftFreeState	,
		steps
	)

Definition at line 111 of file commodityschwartzmodel.cpp.

                                            {
 
    //BOOST_AUTO_TEST_CASE(testMartingaleProperty) {
    
    BOOST_TEST_MESSAGE("Testing martingale property in the COM Schwartz model ...");
 
    CommoditySchwartzModelTestData data(driftFreeState);
    QuantLib::ext::shared_ptr<StochasticProcess> process = data.model->stateProcess();
    QL_REQUIRE(process != NULL, "process has null pointer!");
 
    Size n = 100000; // number of paths
    Size seed = 42; // rng seed
    Time t = 10.0;  // simulation horizon
    Time T = 20.0;  // forward price maturity
    //Size steps = 1; 
 
    TimeGrid grid(t, steps);
    LowDiscrepancy::rsg_type sg = LowDiscrepancy::make_sequence_generator(steps, seed);
    MultiPathGenerator<LowDiscrepancy::rsg_type> pg(process, grid, sg, false);
    //MultiPathGeneratorMersenneTwister pg(process, grid, seed, true);
 
    accumulator_set<double, stats<tag::mean, tag::variance, tag::error_of<tag::mean>>> acc_price, acc_state;
 
    Array state(1);
    for (Size j = 0; j < n; ++j) {
        Sample<MultiPath> path = pg.next();
        Size l = path.value[0].length() - 1;
        state[0] = path.value[0][l];
        Real price = data.model->forwardPrice(t, T, state);
        acc_price(price);
        acc_state(state[0]);
    }
 
    BOOST_TEST_MESSAGE("sigma = " << data.model->parametrization()->sigmaParameter());
    BOOST_TEST_MESSAGE("kappa = " << data.model->parametrization()->kappaParameter());
    BOOST_TEST_MESSAGE("samples = " << n);
    BOOST_TEST_MESSAGE("steps = " << steps);
    BOOST_TEST_MESSAGE("t = " << t);
    BOOST_TEST_MESSAGE("T = " << T);
    
    // Martingale test for F(t,T)
    {
        Real found = mean(acc_price);
        Real expected = data.parametrization->priceCurve()->price(T);
        Real error = error_of<tag::mean>(acc_price);
        
        BOOST_TEST_MESSAGE("Check that E[F(t,T)] = F(0,T)");
        BOOST_TEST_MESSAGE("Avg = " << found
                           << " +- " << error
                           << " vs expected " << expected);
        BOOST_TEST(fabs(found - expected) < error, "Martingale test failed for F(t,T) evolution, found " << found << ", expected " << expected);
    }
    
    // Martingale test for the state variable
    { 
        Real found = mean(acc_state);
        Real expected = 0;
        Real error = error_of<tag::mean>(acc_state);
 
        BOOST_TEST_MESSAGE("Check that the mean of the state variable is zero");
        BOOST_TEST_MESSAGE("Avg = " << found
                           << " +- " << error_of<tag::mean>(acc_state)
                           << " vs expected " << expected);
        BOOST_TEST(fabs(found - expected) < error, "Martingale test failed for the state variable, found " << found << ", expected " << expected);
    }
 
    // Variance test for the state variable, implicit in the first test above 
    {
        Real found = variance(acc_state);
        Real expected = data.parametrization->variance(t);
        // FIXME: What's the MC error here? I assume that the mean error is smaller than the error of variance estimate, so re-using it.
        Real error = error_of<tag::mean>(acc_state); 
 
        QuantLib::ext::shared_ptr<CommoditySchwartzStateProcess> stateProcess = QuantLib::ext::dynamic_pointer_cast<CommoditySchwartzStateProcess>(process);
        QL_REQUIRE(stateProcess, "state process is null");
        Real expected2 = stateProcess->variance(0.0, 0.0, t);
 
        // consistency check, should be identical
        BOOST_TEST(fabs(expected - expected2) < 1e-10, "Inconsistent state variable variance " << expected << " vs " << expected2);
                    
        BOOST_TEST_MESSAGE("Check that the variance of the state variable matches expectation");
        BOOST_TEST_MESSAGE("Var = " << found
                           << " +- " << error
                           << " vs expected " << expected);
        BOOST_TEST(fabs(found - expected2) < error,
                   "Simulated variance of the state variable does match expectation, found " << found << ", expected " << expected);
        
    }
    
} // testMartingaleProperty

Here is the call graph for this function:

Variable Documentation

driftFreeState

std::vector<bool> driftFreeState { true, false }

Definition at line 108 of file commodityschwartzmodel.cpp.

steps

std::vector<Size> steps { 1, 52 }

Definition at line 109 of file commodityschwartzmodel.cpp.