blockmatrixinverse.cpp File Reference

#include <boost/test/unit_test.hpp>
#include <boost/test/data/test_case.hpp>
#include <qle/math/blockmatrixinverse.hpp>
#include "toplevelfixture.hpp"
#include <ql/math/comparison.hpp>
#include <ql/math/randomnumbers/mt19937uniformrng.hpp>
#include <boost/make_shared.hpp>
#include <boost/timer/timer.hpp>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (testSingleBlock)
	BOOST_AUTO_TEST_CASE (testTwoBlocks)
	BOOST_AUTO_TEST_CASE (testThreeBlocks)
	BOOST_AUTO_TEST_CASE (testFourBlocksBigMatrix)
	BOOST_AUTO_TEST_CASE (testTenBlocksBigMatrix)
	BOOST_AUTO_TEST_CASE (testSparseMatrix)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/6]

BOOST_AUTO_TEST_CASE

(

testSingleBlock

)

Definition at line 61 of file blockmatrixinverse.cpp.

                                      {
    BOOST_TEST_MESSAGE("Test block matrix inversion with single block matrix");
 
    // clang-format off
    std::vector<Real> data = { 1.0, 2.0, 2.0,
                               1.0, 1.0, 5.0,
                               -2.0, 0.5, 4.0 };
    // clang-format on
 
    Matrix m(3, 3);
    std::copy(data.begin(), data.end(), m.begin());
 
    std::vector<Size> indices = {3};
 
    Matrix res = blockMatrixInverse(m, indices);
    Matrix ex = inverse(m);
    check(res, ex);
} // testSingleBlock

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [2/6]

BOOST_AUTO_TEST_CASE

(

testTwoBlocks

)

Definition at line 80 of file blockmatrixinverse.cpp.

                                    {
    BOOST_TEST_MESSAGE("Test block matrix inversion with two blocks");
 
    // clang-format off
    std::vector<Real> data = { 1.0, 2.0, 2.0, 3.0,
                               1.0, 1.0, 5.0, 1.0,
                               -2.0, 0.5, 4.0, -2.0,
                               3.0, 1.0, -1.0, -1.0};
    // clang-format on
 
    Matrix m(4, 4);
    std::copy(data.begin(), data.end(), m.begin());
 
    std::vector<Size> indices = {2, 4};
 
    Matrix res = blockMatrixInverse(m, indices);
    Matrix ex = inverse(m);
    check(res, ex);
} // testTwoBlocks

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [3/6]

BOOST_AUTO_TEST_CASE

(

testThreeBlocks

)

Definition at line 100 of file blockmatrixinverse.cpp.

                                      {
    BOOST_TEST_MESSAGE("Test block matrix inversion with three blocks");
 
    // clang-format off
    std::vector<Real> data = { 1.0, 2.0, 2.0, 3.0,
                               1.0, 1.0, 5.0, 1.0,
                               -2.0, 0.5, 4.0, -2.0,
                               3.0, 1.0, -1.0, -1.0};
    // clang-format on
 
    Matrix m(4, 4);
    std::copy(data.begin(), data.end(), m.begin());
 
    std::vector<Size> indices = {1, 2, 4};
 
    Matrix res = blockMatrixInverse(m, indices);
    Matrix ex = inverse(m);
    check(res, ex);
} // testThreeBlocks

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [4/6]

BOOST_AUTO_TEST_CASE

(

testFourBlocksBigMatrix

)

Definition at line 120 of file blockmatrixinverse.cpp.

                                              {
    BOOST_TEST_MESSAGE("Test block matrix inversion with four blocks big matrix");
 
    Matrix m(300, 300, 0.0);
 
    std::vector<Size> indices = {50, 100, 280, 300};
 
    MersenneTwisterUniformRng mt(42);
    for (Size i = 0; i < indices.size(); ++i) {
        Size a0 = (i == 0 ? 0 : indices[i - 1]);
        Size a1 = indices[i];
        for (Size ii = a0; ii < a1; ++ii) {
            for (Size jj = a0; jj < a1; ++jj) {
                m[ii][jj] = mt.nextReal();
            }
        }
    }
 
    boost::timer::cpu_timer timer;
    Matrix res = blockMatrixInverse(m, indices);
    timer.stop();
    BOOST_TEST_MESSAGE("block matrix inversion: " << timer.elapsed().wall * 1e-6 << " ms");
    timer.start();
    Matrix ex = inverse(m);
    timer.stop();
    BOOST_TEST_MESSAGE("plain matrix inversion: " << timer.elapsed().wall * 1e-6 << " ms");
    check(res, ex);
} // testFourBlocksBigMatrix

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [5/6]

BOOST_AUTO_TEST_CASE

(

testTenBlocksBigMatrix

)

Definition at line 149 of file blockmatrixinverse.cpp.

                                             {
    BOOST_TEST_MESSAGE("Test block matrix inversion with ten blocks big matrix");
 
    Matrix m(500, 500, 0.0);
 
    std::vector<Size> indices = {30, 80, 130, 150, 200, 280, 370, 420, 430, 500};
 
    MersenneTwisterUniformRng mt(42);
    for (Size i = 0; i < indices.size(); ++i) {
        Size a0 = (i == 0 ? 0 : indices[i - 1]);
        Size a1 = indices[i];
        for (Size ii = a0; ii < a1; ++ii) {
            for (Size jj = a0; jj < a1; ++jj) {
                m[ii][jj] = mt.nextReal();
            }
        }
    }
 
    boost::timer::cpu_timer timer;
    Matrix res = blockMatrixInverse(m, indices);
    timer.stop();
    BOOST_TEST_MESSAGE("block matrix inversion: " << timer.elapsed().wall * 1e-6 << " ms");
    timer.start();
    Matrix ex = inverse(m);
    timer.stop();
    BOOST_TEST_MESSAGE("plain matrix inversion: " << timer.elapsed().wall * 1e-6 << " ms");
    check(res, ex);
} // testFourBlocksBigMatrix

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [6/6]

BOOST_AUTO_TEST_CASE

(

testSparseMatrix

)

Definition at line 178 of file blockmatrixinverse.cpp.

                                       {
    BOOST_TEST_MESSAGE("Test sparse matrix with two blocks");
 
    // clang-format off
    std::vector<Real> data = { 1.0, 2.0, 0.0, 3.0,
                               0.0, 1.0, 5.0, 0.0,
                               -2.0, 0.0, 4.0, -2.0,
                               3.0, 1.0, -1.0, -1.0};
    // clang-format on
 
    Matrix m(4, 4);
    std::copy(data.begin(), data.end(), m.begin());
 
    SparseMatrix sm(4, 4);
    for (Size i = 0; i < 4; ++i) {
        for (Size j = 0; j < 4; ++j) {
            Real tmp = data[i * 4 + j];
            if (!close_enough(tmp, 0.0))
                sm(i, j) = tmp;
        }
    }
 
    std::vector<Size> indices = {2, 4};
 
    SparseMatrix res = blockMatrixInverse(sm, indices);
    Matrix ex = inverse(m);
 
    Matrix res2(4, 4);
    for (Size i = 0; i < 4; ++i) {
        for (Size j = 0; j < 4; ++j) {
            res2[i][j] = res(i, j);
        }
    }
 
    check(res2, ex);
} // testSingleBlock

Here is the call graph for this function: