randomvariable.cpp File Reference

#include "toplevelfixture.hpp"
#include <boost/test/unit_test.hpp>
#include <boost/test/data/test_case.hpp>
#include <qle/math/randomvariable.hpp>
#include <ql/time/date.hpp>
#include <ql/pricingengines/blackformula.hpp>
#include <boost/math/distributions/normal.hpp>
#include <iostream>
#include <iomanip>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (testFilter)
	BOOST_AUTO_TEST_CASE (testRandomVariable)
	BOOST_AUTO_TEST_CASE (testFunctions)
	BOOST_AUTO_TEST_CASE (testBlack)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/4]

BOOST_AUTO_TEST_CASE

(

testFilter

)

Definition at line 43 of file randomvariable.cpp.

                                 {
    BOOST_TEST_MESSAGE("Testing filter...");
 
    Filter f(100, false);
    BOOST_CHECK(f.deterministic());
 
    f.set(5, true);
    BOOST_CHECK(!f.deterministic());
    BOOST_CHECK_EQUAL(f[0], false);
    BOOST_CHECK_EQUAL(f[5], true);
    BOOST_CHECK_EQUAL(f[10], false);
 
    Filter g(100, true);
    Filter r = f && g;
    ;
    BOOST_CHECK_EQUAL(r[0], false);
    BOOST_CHECK_EQUAL(r[5], true);
 
    Filter h(100, false);
    r = f && h;
    BOOST_CHECK_EQUAL(r[0], false);
    BOOST_CHECK_EQUAL(r[5], false);
    BOOST_CHECK(r.deterministic());
 
    g.set(0, false);
    r = f && g;
    BOOST_CHECK_EQUAL(r[0], false);
    BOOST_CHECK_EQUAL(r[5], true);
 
    g.set(5, false);
    r = f && g;
    BOOST_CHECK_EQUAL(r[0], false);
    BOOST_CHECK_EQUAL(r[5], false);
 
    g.set(10, true);
    r = f || g;
    BOOST_CHECK_EQUAL(r[0], false);
    BOOST_CHECK_EQUAL(r[5], true);
    BOOST_CHECK_EQUAL(r[10], true);
 
    r = !r;
    BOOST_CHECK_EQUAL(r[0], true);
    BOOST_CHECK_EQUAL(r[5], false);
    BOOST_CHECK_EQUAL(r[10], false);
 
    Filter x(100, false), y(100, true);
    BOOST_CHECK((x && y).deterministic());
    BOOST_CHECK((x || y).deterministic());
    BOOST_CHECK((!x).deterministic());
 
    Filter z(200, false);
    BOOST_CHECK_THROW(x && z, QuantLib::Error);
    BOOST_CHECK_THROW(x || z, QuantLib::Error);
 
    BOOST_CHECK_THROW(r.at(100), QuantLib::Error);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [2/4]

BOOST_AUTO_TEST_CASE

(

testRandomVariable

)

Definition at line 100 of file randomvariable.cpp.

                                         {
    BOOST_TEST_MESSAGE("Testing random variable...");
 
    double tol = 1E-10;
 
    RandomVariable r(100, 1.0);
    BOOST_CHECK(r.deterministic());
 
    r.set(5, 2.0);
    BOOST_CHECK(!r.deterministic());
    BOOST_CHECK_CLOSE(r[0], 1.0, tol);
    BOOST_CHECK_CLOSE(r[5], 2.0, tol);
    BOOST_CHECK_CLOSE(r[10], 1.0, tol);
 
    RandomVariable s = r + r;
    BOOST_CHECK_CLOSE(s[0], 2.0, tol);
    BOOST_CHECK_CLOSE(s[5], 4.0, tol);
    BOOST_CHECK_CLOSE(s[10], 2.0, tol);
 
    RandomVariable x(100), y(100);
    BOOST_CHECK((x + y).deterministic());
    BOOST_CHECK((x - y).deterministic());
    BOOST_CHECK((x * y).deterministic());
    BOOST_CHECK((x / y).deterministic());
 
    x.set(5, 2.0);
    y.set(5, 2.0);
    Filter c = close_enough(x, y);
    for (Size i = 0; i < c.size(); ++i)
        BOOST_CHECK_EQUAL(c[i], true);
    BOOST_CHECK(close_enough_all(x, y));
 
    y.set(5, 3.0);
    c = close_enough(x, y);
    BOOST_CHECK(!c.deterministic());
    BOOST_CHECK_EQUAL(c[0], true);
    BOOST_CHECK_EQUAL(c[5], false);
 
    BOOST_CHECK_THROW(r.at(100), QuantLib::Error);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [3/4]

BOOST_AUTO_TEST_CASE

(

testFunctions

)

Definition at line 141 of file randomvariable.cpp.

                                    {
    BOOST_TEST_MESSAGE("Testing functions...");
 
    double tol = 1E-12;
    double x = 2.0, y = -2.0;
    RandomVariable X(1, x), Y(1, y);
    boost::math::normal_distribution<double> n;
 
    BOOST_CHECK_CLOSE((X + Y).at(0), x + y, tol);
    BOOST_CHECK_CLOSE((X - Y).at(0), x - y, tol);
    BOOST_CHECK_CLOSE((X * Y).at(0), x * y, tol);
    BOOST_CHECK_CLOSE((X / Y).at(0), x / y, tol);
 
    BOOST_CHECK_CLOSE((-X).at(0), -x, tol);
    BOOST_CHECK_CLOSE((QuantExt::abs(Y)).at(0), std::abs(y), tol);
    BOOST_CHECK_CLOSE((QuantExt::exp(X)).at(0), std::exp(x), tol);
    BOOST_CHECK_CLOSE((QuantExt::log(X)).at(0), std::log(x), tol);
    BOOST_CHECK_CLOSE((QuantExt::sqrt(X)).at(0), std::sqrt(x), tol);
 
    BOOST_CHECK_CLOSE((normalCdf(X)).at(0), boost::math::cdf(n, x), tol);
    BOOST_CHECK_CLOSE((normalPdf(X)).at(0), boost::math::pdf(n, x), tol);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [4/4]

BOOST_AUTO_TEST_CASE

(

testBlack

)

Definition at line 164 of file randomvariable.cpp.

                                {
    BOOST_TEST_MESSAGE("Testing black formula...");
 
    Option::Type type[4] = {Option::Call, Option::Call, Option::Put, Option::Put};
 
    RandomVariable omega(4), t(4), strike(4), forward(4), impliedVol(4);
 
    omega.set(0, 1.0);
    omega.set(1, 1.0);
    omega.set(2, -1.0);
    omega.set(3, -1.0);
 
    t.setAll(10.0);
 
    strike.set(0, 98.0);
    strike.set(1, 0.0);
    strike.set(2, 98.0);
    strike.set(3, 0.0);
 
    forward.setAll(100.0);
    impliedVol.setAll(0.2);
 
    RandomVariable res = black(omega, t, strike, forward, impliedVol);
 
    for (Size i = 0; i < 4; ++i) {
        BOOST_CHECK_CLOSE(res.at(i),
                          blackFormula(type[i], strike.at(i), forward.at(i), impliedVol.at(i) * std::sqrt(t.at(i))),
                          1E-12);
    }
}

Here is the call graph for this function: