Nektar::MatrixOperationTests Namespace Reference

Functions
	BOOST_AUTO_TEST_CASE (TestLhsFullRhsFull)
	BOOST_AUTO_TEST_CASE (TestComboExpression)
	BOOST_AUTO_TEST_CASE (TestLhsUpperTriangularRhsUpperTriangular)
	BOOST_AUTO_TEST_CASE (TestLhsLowerTriangularRhsLowerTriangular)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/4]

Nektar::MatrixOperationTests::BOOST_AUTO_TEST_CASE

(

TestComboExpression

)

Definition at line 156 of file TestNekMatrixOperations.cpp.

{
    {
        // double buf[] = {1.0, 2.0, 3.0, 4.0};
        double buf[] = {1.0, 3.0, 2.0, 4.0};
        SharedNekMatrixPtr inner1(new NekMatrix<NekDouble>(2, 2, buf));
        SharedNekMatrixPtr inner2(new NekMatrix<NekDouble>(2, 2, buf));
 
        DNekScalMat m1(2.0, inner1);
        DNekScalMat m2(3.0, inner2);
 
        (*inner1) * 2.0;
        2.0 * (*inner1);
        // DNekScalMat m3 = m1*2.0;
        NekMatrix<NekDouble> result = m1 + 1.0 / 6.0 * m2;
 
        BOOST_CHECK_EQUAL(result(0, 0), 2.5);
        BOOST_CHECK_EQUAL(result(0, 1), 5.0);
        BOOST_CHECK_EQUAL(result(1, 0), 7.5);
        BOOST_CHECK_EQUAL(result(1, 1), 10.0);
    }
 
    {
        double buf[] = {1.0, 2.0, 3.0, 4.0};
        SharedNekMatrixPtr inner1(new NekMatrix<NekDouble>(2, 2, buf));
        SharedNekMatrixPtr inner2(new NekMatrix<NekDouble>(2, 2, buf));
 
        std::shared_ptr<DNekScalMat> m1(new DNekScalMat(2.0, inner1));
        std::shared_ptr<DNekScalMat> m2(new DNekScalMat(3.0, inner2));
 
        (*m1) * 2.0;
 
        // BOOST_CHECK_EQUAL(result->GetValue(0,0), 2.0);
        // BOOST_CHECK_EQUAL(result->GetValue(0,1), 4.0);
        // BOOST_CHECK_EQUAL(result->GetValue(1,0), 6.0);
        // BOOST_CHECK_EQUAL(result->GetValue(1,1), 8.0);
    }
}

BOOST_AUTO_TEST_CASE() [2/4]

Nektar::MatrixOperationTests::BOOST_AUTO_TEST_CASE

(

TestLhsFullRhsFull

)

Definition at line 123 of file TestNekMatrixOperations.cpp.

{
    // double lhs_values[] = {2, 4, 6, 8,
    //                       10, 12, 14, 16,
    //                       18, 20, 22, 24,
    //                       26, 28, 30, 32};
    double lhs_values[] = {2, 10, 18, 26, 4, 12, 20, 28,
                           6, 14, 22, 30, 8, 16, 24, 32};
 
    std::shared_ptr<NekMatrix<NekDouble, StandardMatrixTag>> lhs1;
    std::shared_ptr<NekMatrix<NekMatrix<NekDouble>, ScaledMatrixTag>> lhs2;
    std::shared_ptr<NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag>> lhs3;
 
    GenerateFullMatrices(lhs_values, 2.0, lhs1, lhs2, lhs3);
    // double rhs_values[] = {4, 8, 12, 16,
    //                       20, 24, 28, 32,
    //                       36, 40, 44, 48,
    //                       52, 56, 60, 64};
    double rhs_values[] = {4,  20, 36, 52, 8,  24, 40, 56,
                           12, 28, 44, 60, 16, 32, 48, 64};
    std::shared_ptr<NekMatrix<NekDouble, StandardMatrixTag>> rhs1;
    std::shared_ptr<NekMatrix<NekMatrix<NekDouble>, ScaledMatrixTag>> rhs2;
    std::shared_ptr<NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag>> rhs3;
    GenerateFullMatrices(rhs_values, 2.0, rhs1, rhs2, rhs3);
 
    double result_values[16];
    std::transform(lhs_values, lhs_values + 16, rhs_values, result_values,
                   std::plus<NekDouble>());
    NekMatrix<NekDouble> result(4, 4, result_values);
 
    RunAllAddCombinations(*lhs1, *lhs2, *lhs3, *rhs1, *rhs2, *rhs3, result);
}

References Nektar::GenerateFullMatrices(), and Nektar::RunAllAddCombinations().

BOOST_AUTO_TEST_CASE() [3/4]

Nektar::MatrixOperationTests::BOOST_AUTO_TEST_CASE

(

TestLhsLowerTriangularRhsLowerTriangular

)

Definition at line 225 of file TestNekMatrixOperations.cpp.

{
}

BOOST_AUTO_TEST_CASE() [4/4]

Nektar::MatrixOperationTests::BOOST_AUTO_TEST_CASE

(

TestLhsUpperTriangularRhsUpperTriangular

)

Definition at line 195 of file TestNekMatrixOperations.cpp.

{
    // double lhs_values[] = {2, 4,  6,  8,
    //                          12, 14, 16,
    //                              22, 24,
    //                                  32};
    double lhs_values[] = {2, 4, 12, 6, 14, 22, 8, 16, 24, 32};
 
    std::shared_ptr<NekMatrix<NekDouble, StandardMatrixTag>> lhs1;
    std::shared_ptr<NekMatrix<NekMatrix<NekDouble>, ScaledMatrixTag>> lhs2;
    std::shared_ptr<NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag>> lhs3;
    GenerateUpperTriangularMatrices(lhs_values, 2.0, lhs1, lhs2, lhs3);
 
    // double rhs_values[] = {4,   8, 12, 16,
    //                           24, 28, 32,
    //                               44, 48,
    //                                   64};
    double rhs_values[] = {4, 8, 24, 12, 28, 44, 16, 32, 48, 64};
    std::shared_ptr<NekMatrix<NekDouble, StandardMatrixTag>> rhs1;
    std::shared_ptr<NekMatrix<NekMatrix<NekDouble>, ScaledMatrixTag>> rhs2;
    std::shared_ptr<NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag>> rhs3;
    GenerateUpperTriangularMatrices(rhs_values, 2.0, rhs1, rhs2, rhs3);
 
    double result_values[10];
    std::transform(lhs_values, lhs_values + 10, rhs_values, result_values,
                   std::plus<NekDouble>());
    NekMatrix<NekDouble, StandardMatrixTag> result(4, 4, result_values,
                                                   eUPPER_TRIANGULAR);
}

References Nektar::eUPPER_TRIANGULAR, and Nektar::GenerateUpperTriangularMatrices().