Nektar::ScaledBlockMatrixUnitTests Namespace Reference

Functions
	BOOST_AUTO_TEST_CASE (TestMatrixVectorMultiplication)
	BOOST_AUTO_TEST_CASE (TestMultiplicationScaledBlock_1)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/2]

Nektar::ScaledBlockMatrixUnitTests::BOOST_AUTO_TEST_CASE

(

TestMatrixVectorMultiplication

)

Definition at line 45 of file TestScaledBlockMatrixOperations.cpp.

{
    typedef NekMatrix<double> InnerType;
    typedef NekMatrix<InnerType, ScaledMatrixTag> ScaleType;
 
    double m1_buf[] = {1.0 / 2.0, 6.0 / 2.0, 2.0 / 2.0,
                       7.0 / 2.0, 3.0 / 2.0, 8.0 / 2.0};
    double m2_buf[] = {4.0 / 2.0, 9.0 / 2.0, 5.0 / 2.0, 10.0 / 2.0};
    double m3_buf[] = {11.0 / 2.0, 16.0 / 2.0, 12.0 / 2.0,
                       17.0 / 2.0, 13.0 / 2.0, 18 / 2.0};
    double m4_buf[] = {14.0 / 2.0, 19.0 / 2.0, 15.0 / 2.0, 20.0 / 2.0};
 
    std::shared_ptr<InnerType> in_m1(new InnerType(2, 3, m1_buf));
    std::shared_ptr<InnerType> in_m2(new InnerType(2, 2, m2_buf));
    std::shared_ptr<InnerType> in_m3(new InnerType(2, 3, m3_buf));
    std::shared_ptr<InnerType> in_m4(new InnerType(2, 2, m4_buf));
 
    std::shared_ptr<ScaleType> m1(new ScaleType(2.0, in_m1));
    std::shared_ptr<ScaleType> m2(new ScaleType(2.0, in_m2));
    std::shared_ptr<ScaleType> m3(new ScaleType(2.0, in_m3));
    std::shared_ptr<ScaleType> m4(new ScaleType(2.0, in_m4));
 
    unsigned int rowCounts[] = {2, 2};
    unsigned int colCounts[] = {3, 2};
 
    typedef NekMatrix<ScaleType, BlockMatrixTag> BlockType;
 
    std::shared_ptr<BlockType> b(new BlockType(2, 2, rowCounts, colCounts));
    b->SetBlock(0, 0, m1);
    b->SetBlock(0, 1, m2);
    b->SetBlock(1, 0, m3);
    b->SetBlock(1, 1, m4);
 
    double rhs_buf[] = {10, 20, 30, 40, 50};
    NekVector<double> rhs(5, rhs_buf);
 
    NekVector<double> result = (*b) * rhs;
 
    double expected_buf[] = {550, 1300, 2050, 2800};
    NekVector<double> expected_result(4, expected_buf);
 
    BOOST_CHECK_EQUAL(expected_result, result);
}

BOOST_AUTO_TEST_CASE() [2/2]

Nektar::ScaledBlockMatrixUnitTests::BOOST_AUTO_TEST_CASE

(

TestMultiplicationScaledBlock_1

)

Definition at line 89 of file TestScaledBlockMatrixOperations.cpp.

{
    typedef NekMatrix<double> InnerType;
    typedef NekMatrix<InnerType, BlockMatrixTag> BlockType;
 
    double m_00_buf[] = {3, 1, 5, 5};
    double m_01_buf[] = {2, 4, 4, 1, 1, 3};
    double m_02_buf[] = {3, 1, 2, 2, 4, 1, 4, 2};
 
    double m_10_buf[] = {1, 3, 5, 1, 4, 2};
    double m_11_buf[] = {4, 4, 1, 1, 1, 4, 5, 5, 3};
    double m_12_buf[] = {5, 2, 1, 2, 3, 1, 1, 3, 1, 4, 1, 1};
 
    double m_20_buf[] = {3, 1, 4, 2, 5, 1, 4, 2};
    double m_21_buf[] = {4, 5, 2, 4, 4, 2, 3, 5, 2, 2, 5, 3};
    double m_22_buf[] = {3, 4, 3, 1, 2, 1, 2, 4, 4, 5, 2, 3, 5, 4, 1, 1};
 
    double m_30_buf[] = {2, 2, 1, 4, 5, 5};
    double m_31_buf[] = {1, 1, 3, 2, 1, 2, 3, 3, 2};
    double m_32_buf[] = {3, 1, 3, 1, 2, 2, 4, 2, 5, 5, 1, 1};
 
    std::shared_ptr<InnerType> m00(new InnerType(2, 2, m_00_buf));
    std::shared_ptr<InnerType> m01(new InnerType(2, 3, m_01_buf));
    std::shared_ptr<InnerType> m02(new InnerType(2, 4, m_02_buf));
 
    std::shared_ptr<InnerType> m10(new InnerType(3, 2, m_10_buf));
    std::shared_ptr<InnerType> m11(new InnerType(3, 3, m_11_buf));
    std::shared_ptr<InnerType> m12(new InnerType(3, 4, m_12_buf));
 
    std::shared_ptr<InnerType> m20(new InnerType(4, 2, m_20_buf));
    std::shared_ptr<InnerType> m21(new InnerType(4, 3, m_21_buf));
    std::shared_ptr<InnerType> m22(new InnerType(4, 4, m_22_buf));
 
    std::shared_ptr<InnerType> m30(new InnerType(3, 2, m_30_buf));
    std::shared_ptr<InnerType> m31(new InnerType(3, 3, m_31_buf));
    std::shared_ptr<InnerType> m32(new InnerType(3, 4, m_32_buf));
 
    unsigned int rowCounts[] = {2, 3, 4, 3};
    unsigned int colCounts[] = {2, 3, 4};
 
    BlockType b(4, 3, rowCounts, colCounts);
    b.SetBlock(0, 0, m00);
    b.SetBlock(0, 1, m01);
    b.SetBlock(0, 2, m02);
    b.SetBlock(1, 0, m10);
    b.SetBlock(1, 1, m11);
    b.SetBlock(1, 2, m12);
    b.SetBlock(2, 0, m20);
    b.SetBlock(2, 1, m21);
    b.SetBlock(2, 2, m22);
    b.SetBlock(3, 0, m30);
    b.SetBlock(3, 1, m31);
    b.SetBlock(3, 2, m32);
 
    Array<OneD, unsigned int> arrayRowCounts(4, rowCounts);
    Array<OneD, unsigned int> arrayColCounts(3, colCounts);
    BlockType b_initializedWithArray(arrayRowCounts, arrayColCounts);
    b_initializedWithArray.SetBlock(0, 0, m00);
    b_initializedWithArray.SetBlock(0, 1, m01);
    b_initializedWithArray.SetBlock(0, 2, m02);
    b_initializedWithArray.SetBlock(1, 0, m10);
    b_initializedWithArray.SetBlock(1, 1, m11);
    b_initializedWithArray.SetBlock(1, 2, m12);
    b_initializedWithArray.SetBlock(2, 0, m20);
    b_initializedWithArray.SetBlock(2, 1, m21);
    b_initializedWithArray.SetBlock(2, 2, m22);
    b_initializedWithArray.SetBlock(3, 0, m30);
    b_initializedWithArray.SetBlock(3, 1, m31);
    b_initializedWithArray.SetBlock(3, 2, m32);
 
    double rhs_buf[] = {4, 2, 5, 5, 3, 1, 3, 2, 3};
    NekVector<double> rhs(9, rhs_buf);
 
    NekVector<double> result  = b * rhs;
    NekVector<double> result1 = b_initializedWithArray * rhs;
 
    double expected_buf[] = {84, 63, 71, 80, 67, 100, 76, 80, 88, 69, 51, 67};
    NekVector<double> expected_result(12, expected_buf);
 
    BOOST_CHECK_EQUAL(expected_result, result);
    BOOST_CHECK_EQUAL(expected_result, result1);
}