Nektar::UnitTests Namespace Reference

Classes
class	PointTestClass
struct	TenD
class	TestPoint
class	VectorTestClass

Functions
double	ddot (int n, double *x, int incx, double *y, int incy)
	Dot product two vectors. More...
std::vector< double >	z (NPUPPER)
std::vector< double >	w (NPUPPER)
std::vector< double >	p (NPUPPER)
std::vector< double >	d (NPUPPER *NPUPPER)
std::vector< double >	q (NPUPPER *NPUPPER)
void	TestIntegral (std::function< void(double *, double *, int, double, double)> func, int o)
	Test integrals of Jacobi polynomials. More...
void	TestDifferentiation (std::function< void(double *, double *, int, double, double)> func, std::function< void(double *, double *, int, double, double)> funcD)
	Test derivatives using Gaussian quadrature. More...
void	TestInterpolation (std::function< void(double *, double *, int, double, double)> func, std::function< void(double *, double *, double *, int, int, double, double)> funcI)
	Evaluate interpolation using Gaussian quadrature. More...
void	TestIntegralMatrix (std::function< void(double *, double *, int, double, double)> func, std::function< void(double *, double *, int)> funcQ)
	BOOST_AUTO_TEST_CASE (TestGaussInt)
	BOOST_AUTO_TEST_CASE (TestGaussRadauM)
	BOOST_AUTO_TEST_CASE (TestGaussRadauP)
	BOOST_AUTO_TEST_CASE (TestGaussLobatto)
	BOOST_AUTO_TEST_CASE (TestGaussDiff)
	BOOST_AUTO_TEST_CASE (TestGaussRadauMDiff)
	BOOST_AUTO_TEST_CASE (TestGaussRadauPDiff)
	BOOST_AUTO_TEST_CASE (TestGaussLobattoDiff)
	BOOST_AUTO_TEST_CASE (TestGaussInterp)
	BOOST_AUTO_TEST_CASE (TestGaussRadauMInterp)
	BOOST_AUTO_TEST_CASE (TestGaussRadauPInterp)
	BOOST_AUTO_TEST_CASE (TestGaussLobattoInterp)
	BOOST_AUTO_TEST_CASE (TestGaussIntMatrix)
	BOOST_AUTO_TEST_CASE (TestGaussRadauMIntMatrix)
	BOOST_AUTO_TEST_CASE (TestGaussRadauPIntMatrix)
	BOOST_AUTO_TEST_CASE (TestGaussLobattoIntMatrix)
	BOOST_AUTO_TEST_CASE (TestGammaFraction)
	BOOST_AUTO_TEST_CASE (testNekMatrixConstruction)
	BOOST_AUTO_TEST_CASE (testNekMatrixBasicMath)
bool	operator== (const PointTestClass &lhs, const PointTestClass &rhs)
bool	operator!= (const PointTestClass &lhs, const PointTestClass &rhs)
void	test ()
	BOOST_AUTO_TEST_CASE (testNekPointConstruction)
bool	operator== (const VectorTestClass &lhs, const VectorTestClass &rhs)
bool	operator!= (const VectorTestClass &lhs, const VectorTestClass &rhs)
	BOOST_AUTO_TEST_CASE (TestNekVectorConstruction)
	BOOST_AUTO_TEST_CASE (TestNekVectorOperators)
	BOOST_AUTO_TEST_CASE (TestNekVectorArithmetic)
	BOOST_AUTO_TEST_CASE (TestNorms)
	BOOST_AUTO_TEST_CASE (TestMatrixVectorMultiply)
	BOOST_AUTO_TEST_CASE (TestVectorConstructorsWithSizeArguments)
void	RedirectCerrIfNeeded ()

Function Documentation

BOOST_AUTO_TEST_CASE() [1/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGammaFraction

)

Definition at line 324 of file TestPolylib.cpp.

{
    double a, c;
 
    using arrT = std::tuple<int, double, int, double>;
    std::vector<std::tuple<double, arrT, arrT>> ac = {
        {362880.0, std::make_tuple(10, 0.0, 0, 1.0),
         std::make_tuple(1, 0.0, 12, -2.0)},
        {30.0, std::make_tuple(4, 3., 5, 0.), std::make_tuple(5, 0., 7, 0.)},
        {21651.09375, std::make_tuple(7, 3.5, 5, 0.5),
         std::make_tuple(5, 0.5, 10, 0.5)},
        {97429.921875, std::make_tuple(10, 0.5, 5, -0.5),
         std::make_tuple(5, -0.5, 11, -0.5)},
        {2279.0625, std::make_tuple(10, -0.5, 5, 0.5),
         std::make_tuple(5, 0.5, 10, -0.5)},
        {639383.8623046875, std::make_tuple(10, 0.5, 0, 0.5),
         std::make_tuple(0, 0.5, 10, 0.5)},
        {5967498288235982848., std::make_tuple(100, 0., 90, 0.5),
         std::make_tuple(90, 0.5, 100, 0.)},
        {5618641603777298169856., std::make_tuple(200, 0., 191, -0.5),
         std::make_tuple(190, 0.5, 200, 0.)},
        {77396694214720029196288., std::make_tuple(200, 0., 190, 0.),
         std::make_tuple(190, 0., 200, 0.)}};
 
    for (auto &test : ac)
    {
        double a   = std::get<0>(test);
        arrT c1    = std::get<1>(test);
        arrT c2    = std::get<2>(test);
        double c1e = Polylib::gammaFracGammaF(std::get<0>(c1), std::get<1>(c1),
                                              std::get<2>(c1), std::get<3>(c1));
        double c2e = Polylib::gammaFracGammaF(std::get<0>(c2), std::get<1>(c2),
                                              std::get<2>(c2), std::get<3>(c2));
 
        BOOST_CHECK_SMALL(c1e / a - 1.0, EPS);
        BOOST_CHECK_SMALL(c2e * a - 1.0, EPS);
    }
 
    int Q = 2;
    for (double alpha = -0.5; alpha <= 150.; alpha += 0.5)
    {
        for (double beta = -0.5; beta <= 150.; beta += 0.5)
        {
            a = Polylib::gammaF(Q + alpha) / Polylib::gammaF(Q + beta);
            c = Polylib::gammaFracGammaF(Q, alpha, Q, beta) / a - 1.;
            BOOST_CHECK_SMALL(c, EPS);
        }
    }
}

References Nektar::LibUtilities::beta, EPS, Polylib::gammaF(), Polylib::gammaFracGammaF(), and test().

BOOST_AUTO_TEST_CASE() [2/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussDiff

)

Definition at line 264 of file TestPolylib.cpp.

{
    TestDifferentiation(Polylib::zwgj, Polylib::Dgj);
}

References Polylib::Dgj(), TestDifferentiation(), and Polylib::zwgj().

BOOST_AUTO_TEST_CASE() [3/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussInt

)

Definition at line 244 of file TestPolylib.cpp.

{
    TestIntegral(Polylib::zwgj, 0);
}

References TestIntegral(), and Polylib::zwgj().

BOOST_AUTO_TEST_CASE() [4/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussInterp

)

Definition at line 284 of file TestPolylib.cpp.

{
    TestInterpolation(Polylib::zwgj, Polylib::Imgj);
}

References Polylib::Imgj(), TestInterpolation(), and Polylib::zwgj().

BOOST_AUTO_TEST_CASE() [5/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussIntMatrix

)

Definition at line 304 of file TestPolylib.cpp.

{
    TestIntegralMatrix(Polylib::zwgj, Polylib::Qg);
}

References Polylib::Qg(), TestIntegralMatrix(), and Polylib::zwgj().

BOOST_AUTO_TEST_CASE() [6/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussLobatto

)

Definition at line 259 of file TestPolylib.cpp.

{
    TestIntegral(Polylib::zwglj, 2);
}

References TestIntegral(), and Polylib::zwglj().

BOOST_AUTO_TEST_CASE() [7/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussLobattoDiff

)

Definition at line 279 of file TestPolylib.cpp.

{
    TestDifferentiation(Polylib::zwglj, Polylib::Dglj);
}

References Polylib::Dglj(), TestDifferentiation(), and Polylib::zwglj().

BOOST_AUTO_TEST_CASE() [8/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussLobattoInterp

)

Definition at line 299 of file TestPolylib.cpp.

{
    TestInterpolation(Polylib::zwglj, Polylib::Imglj);
}

References Polylib::Imglj(), TestInterpolation(), and Polylib::zwglj().

BOOST_AUTO_TEST_CASE() [9/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussLobattoIntMatrix

)

Definition at line 319 of file TestPolylib.cpp.

{
    TestIntegralMatrix(Polylib::zwglj, Polylib::Qg);
}

References Polylib::Qg(), TestIntegralMatrix(), and Polylib::zwglj().

BOOST_AUTO_TEST_CASE() [10/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussRadauM

)

Definition at line 249 of file TestPolylib.cpp.

{
    TestIntegral(Polylib::zwgrjm, 1);
}

References TestIntegral(), and Polylib::zwgrjm().

BOOST_AUTO_TEST_CASE() [11/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussRadauMDiff

)

Definition at line 269 of file TestPolylib.cpp.

{
    TestDifferentiation(Polylib::zwgrjm, Polylib::Dgrjm);
}

References Polylib::Dgrjm(), TestDifferentiation(), and Polylib::zwgrjm().

BOOST_AUTO_TEST_CASE() [12/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussRadauMInterp

)

Definition at line 289 of file TestPolylib.cpp.

{
    TestInterpolation(Polylib::zwgrjm, Polylib::Imgrjm);
}

References Polylib::Imgrjm(), TestInterpolation(), and Polylib::zwgrjm().

BOOST_AUTO_TEST_CASE() [13/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussRadauMIntMatrix

)

Definition at line 309 of file TestPolylib.cpp.

{
    TestIntegralMatrix(Polylib::zwgrjm, Polylib::Qg);
}

References Polylib::Qg(), TestIntegralMatrix(), and Polylib::zwgrjm().

BOOST_AUTO_TEST_CASE() [14/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussRadauP

)

Definition at line 254 of file TestPolylib.cpp.

{
    TestIntegral(Polylib::zwgrjp, 1);
}

References TestIntegral(), and Polylib::zwgrjp().

BOOST_AUTO_TEST_CASE() [15/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussRadauPDiff

)

Definition at line 274 of file TestPolylib.cpp.

{
    TestDifferentiation(Polylib::zwgrjp, Polylib::Dgrjp);
}

References Polylib::Dgrjp(), TestDifferentiation(), and Polylib::zwgrjp().

BOOST_AUTO_TEST_CASE() [16/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussRadauPInterp

)

Definition at line 294 of file TestPolylib.cpp.

{
    TestInterpolation(Polylib::zwgrjp, Polylib::Imgrjp);
}

References Polylib::Imgrjp(), TestInterpolation(), and Polylib::zwgrjp().

BOOST_AUTO_TEST_CASE() [17/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestGaussRadauPIntMatrix

)

Definition at line 314 of file TestPolylib.cpp.

{
    TestIntegralMatrix(Polylib::zwgrjp, Polylib::Qg);
}

References Polylib::Qg(), TestIntegralMatrix(), and Polylib::zwgrjp().

BOOST_AUTO_TEST_CASE() [18/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestMatrixVectorMultiply

)

Definition at line 189 of file testNekVector.cpp.

{
    {
        // double matrix_buf[] = {1.0, 2.0, 3.0,
        //                    4.0, 5.0, 6.0,
        //                    7.0, 8.0, 9.0};
        double matrix_buf[] = {1.0, 4.0, 7.0, 2.0, 5.0, 8.0, 3.0, 6.0, 9.0};
        double vector_buf[] = {20.0, 30.0, 40.0};
 
        NekMatrix<double> m(3, 3, matrix_buf);
        NekVector<double> v(3, vector_buf);
        NekVector<double> result = m * v;
 
        double result_buf[] = {200.0, 470.0, 740.0};
        NekVector<double> expected_result(3, result_buf);
        BOOST_CHECK_EQUAL(result, expected_result);
        BOOST_CHECK_EQUAL(3u, result.GetDimension());
    }
 
    {
        // double matrix_buf[] = {1.0, 2.0, 3.0,
        //                    4.0, 5.0, 6.0,
        //                    7.0, 8.0, 9.0};
        double matrix_buf[] = {1.0, 4.0, 7.0, 2.0, 5.0, 8.0, 3.0, 6.0, 9.0};
        double vector_buf[] = {20.0, 30.0, 40.0};
 
        std::shared_ptr<NekMatrix<double>> m(
            new NekMatrix<double>(3, 3, matrix_buf));
        NekMatrix<NekMatrix<double>, ScaledMatrixTag> s(2.0, m);
        NekVector<double> v(3, vector_buf);
        NekVector<double> result = s * v;
 
        double result_buf[] = {400.0, 940.0, 1480.0};
        NekVector<double> expected_result(3, result_buf);
        BOOST_CHECK_EQUAL(result, expected_result);
        BOOST_CHECK_EQUAL(3u, result.GetDimension());
    }
 
    {
        // double m1_buf[] = {1.0, 2.0, 3.0, 4.0};
        // double m2_buf[] = {5.0, 6.0, 7.0, 8.0};
        // double m3_buf[] = {9.0, 10.0, 11.0, 12.0};
        double m1_buf[]     = {1.0, 3.0, 2.0, 4.0};
        double m2_buf[]     = {5.0, 7.0, 6.0, 8.0};
        double m3_buf[]     = {9.0, 11.0, 10.0, 12.0};
        double vector_buf[] = {20.0, 30.0};
 
        std::shared_ptr<NekMatrix<double>> m1(
            new NekMatrix<double>(2, 2, m1_buf));
        std::shared_ptr<NekMatrix<double>> m2(
            new NekMatrix<double>(2, 2, m2_buf));
        std::shared_ptr<NekMatrix<double>> m3(
            new NekMatrix<double>(2, 2, m3_buf));
 
        NekMatrix<NekMatrix<double>, BlockMatrixTag> b(3, 1, 2, 2);
        b.SetBlock(0, 0, m1);
        b.SetBlock(1, 0, m2);
        b.SetBlock(2, 0, m3);
 
        NekVector<double> v(2, vector_buf);
        NekVector<double> result = b * v;
 
        double result_buf[] = {80.0, 180.0, 280.0, 380.0, 480.0, 580.0};
        NekVector<double> expected_result(6, result_buf);
        BOOST_CHECK_EQUAL(result, expected_result);
        BOOST_CHECK_EQUAL(6u, result.GetDimension());
    }
 
    {
        double m_buf[]                         = {1, 4, 7, 2, 5, 8, 3, 6, 9};
        double v_buf[]                         = {10, 11, 12};
        double expected_result_buf[]           = {68, 167, 266};
        double expected_transpose_result_buf[] = {138, 171, 204};
 
        NekMatrix<double> m(3, 3, m_buf);
        NekVector<double> v_variable(3, v_buf);
        NekVector<double> v_constant(3, v_buf);
        NekVector<double> expected_result(3, expected_result_buf);
        NekVector<double> expected_transpose_result(
            3, expected_transpose_result_buf);
 
        NekVector<double> constantResult = m * v_constant;
        NekVector<double> variableResult = m * v_variable;
        BOOST_CHECK_EQUAL(variableResult, expected_result);
        BOOST_CHECK_EQUAL(constantResult, expected_result);
 
        m.Transpose();
        constantResult = m * v_constant;
        variableResult = m * v_variable;
        BOOST_CHECK_EQUAL(variableResult, expected_transpose_result);
        BOOST_CHECK_EQUAL(constantResult, expected_transpose_result);
 
        m.Transpose();
        constantResult = m * v_constant;
        variableResult = m * v_variable;
        BOOST_CHECK_EQUAL(variableResult, expected_result);
        BOOST_CHECK_EQUAL(constantResult, expected_result);
 
        NekMatrix<double> transposed = Transpose(m);
        constantResult               = transposed * v_constant;
        variableResult               = transposed * v_variable;
        BOOST_CHECK_EQUAL(variableResult, expected_transpose_result);
        BOOST_CHECK_EQUAL(constantResult, expected_transpose_result);
    }
 
    {
        double m_buf[]                         = {1, 4, 2, 5, 3, 6};
        double v_non_transposed_buf[]          = {10, 11, 12};
        double v_transposed_buf[]              = {20, 21};
        double expected_result_buf[]           = {68, 167};
        double expected_transpose_result_buf[] = {104, 145, 186};
 
        NekMatrix<double> m(2, 3, m_buf);
        NekVector<double> v_non_transposed_variable(3, v_non_transposed_buf);
        NekVector<double> v_non_transposed_constant(3, v_non_transposed_buf);
        NekVector<double> v_transposed_variable(2, v_transposed_buf);
        NekVector<double> v_transposed_constant(2, v_transposed_buf);
        NekVector<double> expected_result(2, expected_result_buf);
        NekVector<double> expected_transpose_result(
            3, expected_transpose_result_buf);
 
        NekVector<double> variableResult = m * v_non_transposed_variable;
        NekVector<double> constantResult = m * v_non_transposed_constant;
        BOOST_CHECK_EQUAL(variableResult, expected_result);
        BOOST_CHECK_EQUAL(constantResult, expected_result);
 
        m.Transpose();
        variableResult = m * v_transposed_variable;
        constantResult = m * v_transposed_constant;
        BOOST_CHECK_EQUAL(variableResult, expected_transpose_result);
        BOOST_CHECK_EQUAL(constantResult, expected_transpose_result);
 
        m.Transpose();
        variableResult = m * v_non_transposed_variable;
        constantResult = m * v_non_transposed_constant;
        BOOST_CHECK_EQUAL(variableResult, expected_result);
        BOOST_CHECK_EQUAL(constantResult, expected_result);
 
        NekMatrix<double> transposed = Transpose(m);
        variableResult               = transposed * v_transposed_variable;
        constantResult               = transposed * v_transposed_constant;
        BOOST_CHECK_EQUAL(variableResult, expected_transpose_result);
        BOOST_CHECK_EQUAL(constantResult, expected_transpose_result);
    }
}

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::Transpose().

BOOST_AUTO_TEST_CASE() [19/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

testNekMatrixBasicMath

)

Definition at line 429 of file testNekMatrix.cpp.

{
    // Addition tests.
    {
        double buf[] = {1.0, 4.0, 7.0, 2.0, 5.0, 8.0, 3.0, 6.0, 9.0};
        NekMatrix<double> m1(3, 3, buf);
        NekMatrix<double> m2(3, 3, buf);
        NekMatrix<double> m3 = m1 + m2;
 
        for (unsigned int i = 0; i < 3; ++i)
        {
            for (unsigned int j = 0; j < 3; ++j)
            {
                BOOST_CHECK(m3(i, j) == buf[3 * j + i] + buf[3 * j + i]);
            }
        }
 
        NekMatrix<double> m4(3, 3, buf);
        NekMatrix<double> m5(3, 3, buf);
        NekMatrix<double> m6 = m4 + m5;
 
        for (unsigned int i = 0; i < 3; ++i)
        {
            for (unsigned int j = 0; j < 3; ++j)
            {
                BOOST_CHECK(m6(i, j) == buf[3 * j + i] + buf[3 * j + i]);
            }
        }
    }
    // Multiply
 
    {
        double buf1[] = {1, 4, 7, 2, 5, 8, 3, 6, 9};
        double buf2[] = {10, 15, 19, 11, 16, 20, 12, 17, 21};
        NekMatrix<double> lhs(3, 3, buf1);
        NekMatrix<double> rhs(3, 3, buf2);
 
        NekMatrix<double> result = lhs * rhs;
 
        BOOST_CHECK(result.GetRows() == 3);
        BOOST_CHECK(result.GetColumns() == 3);
 
        double epsilon = 1e-12;
        BOOST_CHECK_CLOSE(*result(0, 0), 97.0, epsilon);
        BOOST_CHECK_CLOSE(*result(0, 1), 103.0, epsilon);
        BOOST_CHECK_CLOSE(*result(0, 2), 109.0, epsilon);
 
        BOOST_CHECK_CLOSE(*result(1, 0), 229.0, epsilon);
        BOOST_CHECK_CLOSE(*result(1, 1), 244.0, epsilon);
        BOOST_CHECK_CLOSE(*result(1, 2), 259.0, epsilon);
 
        BOOST_CHECK_CLOSE(*result(2, 0), 361.0, epsilon);
        BOOST_CHECK_CLOSE(*result(2, 1), 385.0, epsilon);
        BOOST_CHECK_CLOSE(*result(2, 2), 409.0, epsilon);
    }
 
    {
        double buf1[] = {1, 4, 7, 2, 5, 8, 3, 6, 9};
        double buf2[] = {10, 15, 19, 11, 16, 20, 12, 17, 21, 14, 18, 22};
        NekMatrix<double> lhs(3, 3, buf1);
        NekMatrix<double> rhs(3, 4, buf2);
 
        NekMatrix<double> result = lhs * rhs;
 
        BOOST_CHECK(result.GetRows() == 3);
        BOOST_CHECK(result.GetColumns() == 4);
 
        double epsilon = 1e-12;
        BOOST_CHECK_CLOSE(*result(0, 0), 97.0, epsilon);
        BOOST_CHECK_CLOSE(*result(0, 1), 103.0, epsilon);
        BOOST_CHECK_CLOSE(*result(0, 2), 109.0, epsilon);
        BOOST_CHECK_CLOSE(*result(0, 3), 116.0, epsilon);
 
        BOOST_CHECK_CLOSE(*result(1, 0), 229.0, epsilon);
        BOOST_CHECK_CLOSE(*result(1, 1), 244.0, epsilon);
        BOOST_CHECK_CLOSE(*result(1, 2), 259.0, epsilon);
        BOOST_CHECK_CLOSE(*result(1, 3), 278.0, epsilon);
 
        BOOST_CHECK_CLOSE(*result(2, 0), 361.0, epsilon);
        BOOST_CHECK_CLOSE(*result(2, 1), 385.0, epsilon);
        BOOST_CHECK_CLOSE(*result(2, 2), 409.0, epsilon);
        BOOST_CHECK_CLOSE(*result(2, 3), 440.0, epsilon);
    }
 
    //
    //             // Transpose
    //
    //             // Determinant.
    //
    //             // Invert/Check for singularity.
    //
    //             // Eigenvalues/vectors
    //
    //             // Condition number wrt various norms.
    //
    //             // Various norm computations.
    //
    //             // LU Decomposition?  More appropriate in LinAlg?
}

BOOST_AUTO_TEST_CASE() [20/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

testNekMatrixConstruction

)

Definition at line 408 of file testNekMatrix.cpp.

{
    // Basic, dense matrix construction.
    {
        double buf[] = {1.0, 4.0,  7.0, 10.0, 2.0, 5.0,
                        8.0, 11.0, 3.0, 6.0,  9.0, 12.0};
        NekMatrix<double> dynamic_matrix(4, 3, buf);
 
        BOOST_CHECK(dynamic_matrix.GetRows() == 4);
        BOOST_CHECK(dynamic_matrix.GetColumns() == 3);
 
        for (unsigned int i = 0; i < 4; ++i)
        {
            for (unsigned int j = 0; j < 3; ++j)
            {
                BOOST_CHECK(dynamic_matrix(i, j) == buf[4 * j + i]);
            }
        }
    }
}

BOOST_AUTO_TEST_CASE() [21/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

testNekPointConstruction

)

Definition at line 103 of file testNekPoint.cpp.

{
    using namespace Nektar;
 
    // Test the constructors on a numeric type.
    {
        NekPoint<double> p1;
        BOOST_CHECK(p1.x() == 0.0);
        BOOST_CHECK(p1.y() == 0.0);
        BOOST_CHECK(p1.z() == 0.0);
 
        NekPoint<double> p3(p1);
        BOOST_CHECK(p1 == p3);
    }
 
    // Now test it on an arbitrary type.
    {
        NekPoint<PointTestClass> p1;
        BOOST_CHECK(p1.x() == PointTestClass(0));
        BOOST_CHECK(p1.y() == PointTestClass(0));
        BOOST_CHECK(p1.z() == PointTestClass(0));
 
        BOOST_CHECK(p1.x() == PointTestClass());
        BOOST_CHECK(p1.y() == PointTestClass());
        BOOST_CHECK(p1.z() == PointTestClass());
 
        NekPoint<PointTestClass> p3(p1);
        BOOST_CHECK(p1 == p3);
    }
}

References Nektar::NekPoint< data_type >::x(), Nektar::NekPoint< data_type >::y(), and Nektar::NekPoint< data_type >::z().

BOOST_AUTO_TEST_CASE() [22/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestNekVectorArithmetic

)

Definition at line 174 of file testNekVector.cpp.

{
}

BOOST_AUTO_TEST_CASE() [23/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestNekVectorConstruction

)

Definition at line 94 of file testNekVector.cpp.

{
    // Test the constructors on a numeric type.
    {
        NekVector<double> p1(10, 2.7);
        BOOST_CHECK(p1.GetDimension() == 10);
        for (unsigned int i = 0; i < p1.GetDimension(); ++i)
        {
            BOOST_CHECK(p1(i) == 2.7);
            BOOST_CHECK(p1[i] == 2.7);
        }
 
        NekVector<double> p2(1, 0.0);
        BOOST_CHECK(p2.GetDimension() == 1);
        BOOST_CHECK(p2(0) == 0.0);
 
        NekVector<double> p3(p1);
        BOOST_CHECK(p3.GetDimension() == 10);
        for (unsigned int i = 0; i < p3.GetDimension(); ++i)
        {
            BOOST_CHECK(p3(i) == 2.7);
            BOOST_CHECK(p3[i] == 2.7);
        }
 
        p2 = p3;
        BOOST_CHECK(p2.GetDimension() == 10);
        for (unsigned int i = 0; i < p2.GetDimension(); ++i)
        {
            BOOST_CHECK_EQUAL(p2(i), 2.7);
            BOOST_CHECK_EQUAL(p2[i], 2.7);
        }
    }
}

References Nektar::NekVector< DataType >::GetDimension().

BOOST_AUTO_TEST_CASE() [24/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestNekVectorOperators

)

Definition at line 128 of file testNekVector.cpp.

{
    NekVector<double> v1(3, 1.0);
    v1(0) = 1.1;
    v1(1) = 1.2;
    v1(2) = 1.3;
 
    BOOST_CHECK(v1(0) == 1.1);
    BOOST_CHECK(v1(1) == 1.2);
    BOOST_CHECK(v1(2) == 1.3);
 
    v1[0] = 1.4;
    v1[1] = 1.5;
    v1[2] = 1.6;
 
    BOOST_CHECK(v1[0] == 1.4);
    BOOST_CHECK(v1[1] == 1.5);
    BOOST_CHECK(v1[2] == 1.6);
 
    v1.x() = 1.7;
    v1.y() = 1.8;
    v1.z() = 1.9;
 
    BOOST_CHECK(v1[0] == 1.7);
    BOOST_CHECK(v1[1] == 1.8);
    BOOST_CHECK(v1[2] == 1.9);
 
    BOOST_CHECK(v1.x() == 1.7);
    BOOST_CHECK(v1.y() == 1.8);
    BOOST_CHECK(v1.z() == 1.9);
 
    NekVector<double> v2(3, 1.0);
    v2.x() = 1.7;
    v2.y() = 1.8;
    v2.z() = 1.9;
 
    BOOST_CHECK(v1 == v2);
    BOOST_CHECK(!(v1 != v2));
 
    NekVector<double> v3(4, 2.0);
    BOOST_CHECK(v3 != v1);
 
    NekVector<double> v4(3, 0.0);
    BOOST_CHECK(v4 != v1);
}

References Nektar::NekVector< DataType >::x(), Nektar::NekVector< DataType >::y(), and Nektar::NekVector< DataType >::z().

BOOST_AUTO_TEST_CASE() [25/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestNorms

)

Definition at line 178 of file testNekVector.cpp.

{
    double vals[] = {1, -2, 3};
    NekVector<double> v(3, vals);
 
    double epsilon = 1e-11;
    BOOST_CHECK_EQUAL(v.L1Norm(), 1.0 + 2.0 + 3.0);
    BOOST_CHECK_CLOSE(v.L2Norm(), sqrt(1.0 + 4.0 + 9.0), epsilon);
    BOOST_CHECK_EQUAL(v.InfinityNorm(), 3);
}

References Nektar::NekVector< DataType >::InfinityNorm(), Nektar::NekVector< DataType >::L1Norm(), Nektar::NekVector< DataType >::L2Norm(), and tinysimd::sqrt().

BOOST_AUTO_TEST_CASE() [26/26]

Nektar::UnitTests::BOOST_AUTO_TEST_CASE

(

TestVectorConstructorsWithSizeArguments

)

Definition at line 335 of file testNekVector.cpp.

{
    {
        double buf[] = {1.0, 2.0, 3.0, 4.0};
        Array<OneD, double> a(4, buf);
        NekVector<double> b(3, a);
 
        BOOST_CHECK_EQUAL(b.GetRows(), 3u);
        BOOST_CHECK_EQUAL(b.GetDimension(), 3u);
        BOOST_CHECK_EQUAL(b[0], 1.0);
        BOOST_CHECK_EQUAL(b[1], 2.0);
        BOOST_CHECK_EQUAL(b[2], 3.0);
 
        NekVector<double>::iterator iter = b.begin();
        BOOST_CHECK_EQUAL(*iter, 1.0);
        ++iter;
        BOOST_CHECK_EQUAL(*iter, 2.0);
        ++iter;
        BOOST_CHECK_EQUAL(*iter, 3.0);
        ++iter;
        BOOST_CHECK(iter == b.end());
    }
 
    {
        double buf[] = {1.0, 2.0, 3.0, 4.0};
        Array<OneD, const double> a(4, buf);
        NekVector<double> b(3, a);
 
        BOOST_CHECK_EQUAL(b.GetRows(), 3u);
        BOOST_CHECK_EQUAL(b.GetDimension(), 3u);
        BOOST_CHECK_EQUAL(b[0], 1.0);
        BOOST_CHECK_EQUAL(b[1], 2.0);
        BOOST_CHECK_EQUAL(b[2], 3.0);
 
        NekVector<double>::iterator iter = b.begin();
        BOOST_CHECK_EQUAL(*iter, 1.0);
        ++iter;
        BOOST_CHECK_EQUAL(*iter, 2.0);
        ++iter;
        BOOST_CHECK_EQUAL(*iter, 3.0);
        ++iter;
        BOOST_CHECK(iter == b.end());
    }
 
    {
        double buf[] = {1.0, 2.0, 3.0, 4.0};
        Array<OneD, double> a(4, buf);
        NekVector<double> b(3, a, eWrapper);
 
        BOOST_CHECK_EQUAL(b.GetRows(), 3u);
        BOOST_CHECK_EQUAL(b.GetDimension(), 3u);
        BOOST_CHECK_EQUAL(b[0], 1.0);
        BOOST_CHECK_EQUAL(b[1], 2.0);
        BOOST_CHECK_EQUAL(b[2], 3.0);
 
        NekVector<double>::iterator iter = b.begin();
        BOOST_CHECK_EQUAL(*iter, 1.0);
        ++iter;
        BOOST_CHECK_EQUAL(*iter, 2.0);
        ++iter;
        BOOST_CHECK_EQUAL(*iter, 3.0);
        ++iter;
        BOOST_CHECK(iter == b.end());
 
        b[0] = 5.0;
        BOOST_CHECK_EQUAL(b[0], a[0]);
    }
}

References Nektar::NekVector< DataType >::begin(), Nektar::NekVector< DataType >::end(), Nektar::eWrapper, Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRows().

d()

std::vector< double > Nektar::UnitTests::d

(

NPUPPER *

NPUPPER

)

Referenced by CellMLToNektar.translators.ConfigurationStore::_find_transmembrane_currents_from_voltage_ode(), Nektar::SpatialDomains::GeomFactors::Adjoint(), Nektar::MemoryManager< DataType >::AllocateSharedPtrD(), Nektar::AsString(), Nektar::ScaledMatrixUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::SolverUtils::DiffusionIP::CalcTraceNumFlux(), Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Nektar::SharedArrayUnitTests::CheckAddresses(), Nektar::MultiRegions::ExpList::CreateCollections(), Nektar::SpatialDomains::MeshGraphIOXml::CreateCompositeOrdering(), Nektar::FieldUtils::Field::CreateExp(), Nektar::MMFDiffusion::DoOdeRhs(), Arpack::Dseupd(), Lapack::Dsterf(), Nektar::SolverUtils::DriverSteadyState::EvalEV_ScalarSFD(), EvaluateTangent(), Nektar::LibUtilities::Interpolator::FindNeighbours(), Nektar::LibUtilities::Interpolator::FindNNeighbours(), Nektar::PulseWaveSystem::GetCommArray(), Nektar::NavierStokesCFE::GetDivCurlSquared(), Nektar::SpatialDomains::MeshGraph::GetElementsFromEdge(), Nektar::LibUtilities::FieldIO::GetFileType(), Nektar::UnsteadyDiffusion::GetFluxVector(), Nektar::CompressibleFlowSystem::GetFluxVector(), GetInterfaces_wrapper(), Nektar::VariableConverter::GetInternalEnergy(), Nektar::SolverUtils::FilterLagrangianPoints::GetPhysicsData(), Nektar::NavierStokesCFE::GetViscousFluxBilinearFormKernel(), Nektar::NavierStokesCFE::GetViscousFluxVectorConservVar(), Nektar::NavierStokesCFE::GetViscousSymmtrFluxConservVar(), Nektar::NonlinearPeregrine::LaitoneSolitaryWave(), main(), Nektar::NekMatrix< DataType, StandardMatrixTag >::NekMatrix(), Nektar::FieldUtils::OutputVtk::OutputFromExpLowOrder(), Nektar::FieldUtils::OutputVtk::OutputFromExpLowOrderMultiBlock(), Nektar::SolverUtils::FilterLagrangianPoints::OutputSamplePoints(), Nektar::SolverUtils::EvaluatePoints::Pack2Int(), Nektar::SolverUtils::EvaluatePoints::Pack3Int(), Nektar::LibUtilities::SessionReader::ParseCommandLineArguments(), Nektar::FieldUtils::ProcessGrad::ParserOptions(), Polylib::polycoeffs(), PolyFit(), PolyInterp(), Nektar::SpatialDomains::MeshGraph::ReadExpansionInfo(), Nektar::PulseWaveSystem::SetUpDomainInterfaceBCs(), Nektar::PulseWaveSystem::SetUpDomainInterfaces(), Nektar::SpatialDomains::MeshGraph::SetUpExpansionInfoMap(), Nektar::Matrix< DataType >::SetValue(), Nektar::NekMatrix< DataType, StandardMatrixTag >::SetValue(), boost::python::converter::shared_ptr_to_python(), Nektar::SolverUtils::StatLagrangianPoints::StatLagrangianPoints(), Nektar::LocalRegions::Expansion::StdDerivBaseOnTraceMat(), TestDifferentiation(), TestInterpolation(), Polylib::TriQL(), Nektar::SolverUtils::EvaluatePoints::unPack2Int(), Nektar::SolverUtils::EvaluatePoints::unPack3Int(), Nektar::Collections::Helmholtz_IterPerExp::UpdateFactors(), Nektar::SolverUtils::StatLagrangianPoints::v_AssignPoint(), Nektar::LibUtilities::NodalTetElec::v_CalculatePoints(), Nektar::SpatialDomains::RefRegionCylinder::v_Contains(), Nektar::SpatialDomains::RefRegionParallelogram::v_Contains(), Nektar::PulseWaveSystem::v_DoInitialise(), Nektar::SpatialDomains::HexGeom::v_GenGeomFactors(), Nektar::SpatialDomains::PrismGeom::v_GenGeomFactors(), Nektar::SpatialDomains::QuadGeom::v_GenGeomFactors(), Nektar::SpatialDomains::TriGeom::v_GenGeomFactors(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::SolverUtils::StatLagrangianPoints::v_GetCoords(), Nektar::LibUtilities::NodalTriElec::v_GetI(), Nektar::LibUtilities::NodalTriEvenlySpaced::v_GetI(), Nektar::LibUtilities::NodalTriFekete::v_GetI(), Nektar::LibUtilities::NodalPrismElec::v_GetI(), Nektar::LibUtilities::NodalPrismEvenlySpaced::v_GetI(), Nektar::LibUtilities::NodalTetElec::v_GetI(), Nektar::LibUtilities::NodalTetEvenlySpaced::v_GetI(), Nektar::LibUtilities::PolyEPoints::v_GetI(), Nektar::MultiRegions::ExpList::v_GetNormals(), Nektar::SolverUtils::StatLagrangianPoints::v_GetPhysics(), Nektar::SolverUtils::FilterLagrangianPoints::v_Initialise(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::SolverUtils::StatLagrangianPoints::v_OutputData(), Nektar::FieldUtils::InputFld::v_Process(), Nektar::FieldUtils::ProcessCreateExp::v_Process(), Nektar::FieldUtils::ProcessMRF::v_Process(), Nektar::SolverUtils::StatLagrangianPoints::v_ReSize(), Nektar::SolverUtils::StatLagrangianPoints::v_SetCoords(), Nektar::SolverUtils::StatLagrangianPoints::v_SetPhysics(), Nektar::NekMatrix< DataType, StandardMatrixTag >::v_SetValue(), and Nektar::SolverUtils::StatLagrangianPoints::v_TimeAdvance().

ddot()

double Nektar::UnitTests::ddot	(	int	n,
		double *	x,
		int	incx,
		double *	y,
		int	incy
	)

Dot product two vectors.

Definition at line 55 of file TestPolylib.cpp.

{
    double sum = 0.0;
 
    while (n--)
    {
        sum += (*x) * (*y);
        x += incx;
        y += incy;
    }
 
    return sum;
}

Referenced by TestDifferentiation(), TestIntegral(), TestIntegralMatrix(), and TestInterpolation().

operator!=() [1/2]

bool Nektar::UnitTests::operator!=	(	const PointTestClass &	lhs,
		const PointTestClass &	rhs
	)

Definition at line 76 of file testNekPoint.cpp.

{
    return !(lhs == rhs);
}

operator!=() [2/2]

bool Nektar::UnitTests::operator!=	(	const VectorTestClass &	lhs,
		const VectorTestClass &	rhs
	)

Definition at line 84 of file testNekVector.cpp.

{
    return !(lhs == rhs);
}

operator==() [1/2]

bool Nektar::UnitTests::operator==	(	const PointTestClass &	lhs,
		const PointTestClass &	rhs
	)

Definition at line 71 of file testNekPoint.cpp.

{
    return lhs.value() == rhs.value();
}

References Nektar::UnitTests::PointTestClass::value().

operator==() [2/2]

bool Nektar::UnitTests::operator==	(	const VectorTestClass &	lhs,
		const VectorTestClass &	rhs
	)

Definition at line 79 of file testNekVector.cpp.

{
    return lhs.value() == rhs.value();
}

References Nektar::UnitTests::VectorTestClass::value().

p()

std::vector< double > Nektar::UnitTests::p

(

NPUPPER

)

Referenced by test(), TestDifferentiation(), TestIntegral(), TestIntegralMatrix(), and TestInterpolation().

q()

std::vector< double > Nektar::UnitTests::q

(

NPUPPER *

NPUPPER

)

Referenced by Nektar::LibUtilities::FractionalInTimeIntegrationScheme::advanceSandbox(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::FieldUtils::ProcessInterpPoints::calcCp0(), Nektar::FieldUtils::ProcessInterpPtsToPts::calcCp0(), Polylib::chri1(), EvaluateTangent(), Nektar::LibUtilities::Basis::GenBasis(), Nektar::Collections::CoalescedGeomData::GetDerivFactorsInterLeave(), Nektar::Collections::CoalescedGeomData::GetJacInterLeave(), Nektar::StdRegions::StdPrismExp::GetMode(), Nektar::LibUtilities::FractionalInTimeIntegrationScheme::integralClassInitialize(), Nektar::LibUtilities::FractionalInTimeIntegrationScheme::integralContribution(), main(), MappingEVids(), Nektar::FieldUtils::MatSymEVals(), Nektar::LibUtilities::SessionReader::MergeDoc(), Nektar::SolverUtils::EvaluatePoints::Pack3Int(), Nektar::LibUtilities::FractionalInTimeIntegrationScheme::talbotQuadrature(), TestIntegralMatrix(), Nektar::LibUtilities::FractionalInTimeIntegrationScheme::timeAdvance(), Nektar::SolverUtils::EvaluatePoints::unPack3Int(), Nektar::LibUtilities::FractionalInTimeIntegrationScheme::updateStage(), Nektar::Collections::LinearAdvectionDiffusionReaction_MatrixFree::UpdateVarcoeffs(), Nektar::StdRegions::StdHexExp::v_GetBoundaryMap(), Nektar::StdRegions::StdPrismExp::v_GetBoundaryMap(), Nektar::StdRegions::StdPyrExp::v_GetBoundaryMap(), Nektar::StdRegions::StdHexExp::v_GetEdgeInteriorToElementMap(), Nektar::StdRegions::StdHexExp::v_GetInteriorMap(), Nektar::StdRegions::StdPrismExp::v_GetInteriorMap(), Nektar::StdRegions::StdPyrExp::v_GetInteriorMap(), Nektar::StdRegions::StdPrismExp::v_GetTraceCoeffMap(), Nektar::StdRegions::StdPyrExp::v_GetTraceCoeffMap(), Nektar::StdRegions::StdHexExp::v_GetTraceInteriorToElementMap(), Nektar::StdRegions::StdPrismExp::v_GetTraceInteriorToElementMap(), Nektar::StdRegions::StdPyrExp::v_GetTraceInteriorToElementMap(), Nektar::StdRegions::StdHexExp::v_GetVertexMap(), Nektar::FieldUtils::ProcessQualityMetric::v_Process(), Nektar::SpatialDomains::MeshGraphIOXml::v_WriteQuads(), and Nektar::SpatialDomains::MeshGraphIOXmlCompressed::v_WriteQuads().

RedirectCerrIfNeeded()

void Nektar::UnitTests::RedirectCerrIfNeeded

(

)

Definition at line 41 of file util.cpp.

{
    if (!ErrorUtil::HasCustomErrorStream())
    {
        static std::ofstream out("out.txt", std::ios::out);
        ErrorUtil::SetErrorStream(out);
    }
}

References Nektar::ErrorUtil::HasCustomErrorStream(), and Nektar::ErrorUtil::SetErrorStream().

Referenced by Nektar::SharedArrayUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::DiagonalMatrixStoragePolicyUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::LowerTriangularStoragePolicyUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::SymmetricMatrixStoragePolicyUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::UpperTriangularUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::FullMatrixStoragePolicyUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::BandedMatrixStoragePolicyUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::MatrixUnitTests::BOOST_AUTO_TEST_CASE(), and Nektar::ConsistentObjectAccessUnitTests::BOOST_AUTO_TEST_CASE().

test()

void Nektar::UnitTests::test

(

)

Definition at line 92 of file testNekPoint.cpp.

{
    TestPoint p;
    TestPoint p1(p);
}

References p().

Referenced by Nektar::VariableSizedNekVectorUnitTests::BOOST_AUTO_TEST_CASE(), BOOST_AUTO_TEST_CASE(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_sort(), OUTPUT(), and Nektar::FieldUtils::InputNek5000::v_Process().

TestDifferentiation()

void Nektar::UnitTests::TestDifferentiation ( std::function< void(double *, double *, int, double, double)>  func, std::function< void(double *, double *, int, double, double)>  funcD  )

inline

Test derivatives using Gaussian quadrature.

This routine evaluates the deriatives

\[ \frac{d}{dx}(x^n) = nx^{n-1} \]

using \( -0.5 \leq \alpha,\beta \leq 5 \) and using \( N \) points where \( N \) lies between NPLOWER and NPUPPER. Tolerance is taken using the EPS value.

Definition at line 116 of file TestPolylib.cpp.

{
    double alpha = -0.5;
    while (alpha <= 5.0)
    {
        double beta = -0.5;
        while (beta <= 5.0)
        {
            for (int np = NPLOWER; np <= NPUPPER; ++np)
            {
                func(&z[0], &w[0], np, alpha, beta);
                funcD(&d[0], &z[0], np, alpha, beta);
                for (int n = 2; n < np - 1; ++n)
                {
                    for (int i = 0; i < np; ++i)
                    {
                        p[i] = pow(z[i], n);
                    }
 
                    double sum = 0.0;
 
                    for (int i = 0; i < np; ++i)
                    {
                        sum += fabs(ddot(np, &d[0] + i, np, &p[0], 1) -
                                    n * pow(z[i], n - 1));
                    }
                    sum /= np;
 
                    BOOST_CHECK_SMALL(sum, EPS);
                }
            }
            beta += 0.5;
        }
        alpha += 0.5;
    }
}

References Nektar::LibUtilities::beta, d(), ddot(), EPS, NPLOWER, NPUPPER, p(), w(), and z().

Referenced by BOOST_AUTO_TEST_CASE().

TestIntegral()

void Nektar::UnitTests::TestIntegral ( std::function< void(double *, double *, int, double, double)>  func, int  o  )

inline

Test integrals of Jacobi polynomials.

This routine evaluates the integral

\[ \int_{-1}^1 (1-x)^\alpha (1+x)^\beta P_n^{\alpha,\beta} dx = 0 \]

using \( -0.5 \leq \alpha,\beta \leq 5 \) and using \( N \) points where \( N \) lies between NPLOWER and NPUPPER. Tolerance is taken using the EPS value.

Definition at line 81 of file TestPolylib.cpp.

{
    double alpha = -0.5;
    while (alpha <= 5.0)
    {
        double beta = -0.5;
        while (beta <= 5.0)
        {
            for (int np = NPLOWER; np <= NPUPPER; ++np)
            {
                func(&z[0], &w[0], np, alpha, beta);
                for (int n = 2; n < 2 * np - 1 - o; ++n)
                {
                    Polylib::jacobfd(np, &z[0], &p[0], nullptr, n, alpha, beta);
                    double sum = ddot(np, &w[0], 1, &p[0], 1);
                    BOOST_CHECK_SMALL(sum, EPS);
                }
            }
 
            beta += 0.5;
        }
 
        alpha += 0.5;
    }
}

References Nektar::LibUtilities::beta, ddot(), EPS, Polylib::jacobfd(), NPLOWER, NPUPPER, p(), w(), and z().

Referenced by BOOST_AUTO_TEST_CASE().

TestIntegralMatrix()

void Nektar::UnitTests::TestIntegralMatrix ( std::function< void(double *, double *, int, double, double)>  func, std::function< void(double *, double *, int)>  funcQ  )

inline

Definition at line 205 of file TestPolylib.cpp.

{
    double alpha = -0.5;
    while (alpha <= 5.0)
    {
        double beta = -0.5;
        while (beta <= 5.0)
        {
            for (int np = NPLOWER; np <= NPUPPER; ++np)
            {
                func(&z[0], &w[0], np, alpha, beta);
                funcQ(&q[0], &z[0], np);
                for (int n = 2; n < np - 1; ++n)
                {
                    for (int i = 0; i < np; ++i)
                    {
                        p[i] = pow(z[i], n);
                    }
 
                    double sum = 0.0;
 
                    for (int i = 0; i < np; ++i)
                    {
                        sum += fabs(ddot(np, &q[0] + i * np, 1, &p[0], 1) -
                                    pow(z[i], n + 1) / (n + 1));
                    }
                    sum /= np;
 
                    BOOST_CHECK_SMALL(sum, EPS);
                }
            }
            beta += 0.5;
        }
        alpha += 0.5;
    }
}

References Nektar::LibUtilities::beta, ddot(), EPS, NPLOWER, NPUPPER, p(), q(), w(), and z().

Referenced by BOOST_AUTO_TEST_CASE().

TestInterpolation()

void Nektar::UnitTests::TestInterpolation ( std::function< void(double *, double *, int, double, double)>  func, std::function< void(double *, double *, double *, int, int, double, double)>  funcI  )

inline

Evaluate interpolation using Gaussian quadrature.

This routine evaluates the interpolation of \( z^n \) to \( x^n \), where \( z \) are the quadrature zeros and \( x \) are the equispaced points

\[ x_n = \frac{2n}{N-1} - 1, \quad 0\leq n\leq N, \]

using \( -0.5 \leq \alpha,\beta \leq 5 \) and using \( N \) points where \( N \) lies between NPLOWER and NPUPPER. Tolerance is taken using the EPS value.

Definition at line 165 of file TestPolylib.cpp.

{
    double alpha = -0.5;
    while (alpha <= 5.0)
    {
        double beta = -0.5;
        while (beta <= 5.0)
        {
            for (int np = NPLOWER; np <= NPUPPER; ++np)
            {
                func(&z[0], &w[0], np, alpha, beta);
                for (int n = 2; n < np - 1; ++n)
                {
                    for (int i = 0; i < np; ++i)
                    {
                        w[i] = 2.0 * i / (double)(np - 1) - 1.0;
                        p[i] = pow(z[i], n);
                    }
                    funcI(&d[0], &z[0], &w[0], np, np, alpha, beta);
 
                    double sum = 0.0;
                    for (int i = 0; i < np; ++i)
                    {
                        sum += fabs(ddot(np, &d[0] + i, np, &p[0], 1) -
                                    pow(w[i], n));
                    }
                    sum /= np;
 
                    BOOST_CHECK_SMALL(sum, EPS);
                }
            }
            beta += 0.5;
        }
        alpha += 0.5;
    }
}

References Nektar::LibUtilities::beta, d(), ddot(), EPS, NPLOWER, NPUPPER, p(), w(), and z().

Referenced by BOOST_AUTO_TEST_CASE().

w()

std::vector< double > Nektar::UnitTests::w

(

NPUPPER

)

Referenced by Nektar::SolverUtils::DriverParareal::ApplyWindowing(), Nektar::MultiRegions::GlobalLinSysDirectFull::AssembleFullMatrix(), Nektar::VmathSIMDUnitTests::BOOST_AUTO_TEST_CASE(), sha1::calc(), Nektar::SolverUtils::DriverParareal::CopyConvergedCheckPoints(), Cutrepetitions(), Vmath::Ddot(), Nektar::LibUtilities::NekLinSysIterGMRES::DoArnoldi(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoArnoldi(), Nektar::LibUtilities::NekLinSysIterGMRES::DoGmresRestart(), Nektar::LibUtilities::NekLinSysIterGMRESLoc::DoGmresRestart(), Vmath::Dot(), Vmath::Dot2(), Lapack::Dsbev(), Lapack::Dspev(), Nektar::MultiRegions::DisContField::FindPeriodicTraces(), Nektar::LibUtilities::Basis::GenBasis(), Nektar::NavierStokesImplicitCFE::GetdFlux_dQx_3D(), Nektar::NavierStokesImplicitCFE::GetdFlux_dQy_3D(), Nektar::NavierStokesImplicitCFE::GetdFlux_dQz_3D(), Nektar::NavierStokesImplicitCFE::GetdFlux_dU_3D(), Nektar::LibUtilities::Points< DataT >::GetZW(), Nektar::LibUtilities::Basis::GetZW(), Nektar::L2Norm(), main(), MappingEVids(), Orderfunctionx(), PolyFit(), PolyInterp(), Nektar::LibUtilities::H5::DataSet::Read(), Nektar::FieldUtils::Iso::Smooth(), Nektar::LibUtilities::FractionalInTimeIntegrationScheme::talbotQuadrature(), TestDifferentiation(), TestIntegral(), TestIntegralMatrix(), TestInterpolation(), Nektar::MultiRegions::GlobalLinSysDirectStaticCond::v_AssembleSchurComplement(), Nektar::LibUtilities::NodalPrismElec::v_CalculateWeights(), Nektar::LibUtilities::NodalPrismEvenlySpaced::v_CalculateWeights(), Nektar::LibUtilities::NodalTetElec::v_CalculateWeights(), Nektar::LibUtilities::NodalTetEvenlySpaced::v_CalculateWeights(), Nektar::LibUtilities::NodalTriElec::v_CalculateWeights(), Nektar::LibUtilities::NodalTriEvenlySpaced::v_CalculateWeights(), Nektar::LibUtilities::NodalTriFekete::v_CalculateWeights(), Nektar::LibUtilities::PolyEPoints::v_CalculateWeights(), Nektar::SolverUtils::DriverParareal::v_Execute(), Nektar::SolverUtils::DriverPFASST::v_Execute(), Nektar::StdRegions::StdPointExp::v_IProductWRTBase(), Nektar::StdRegions::StdSegExp::v_IProductWRTBase(), Nektar::StdRegions::StdSegExp::v_IProductWRTBase_SumFac(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_L2(), Nektar::FentonKarma::v_Update(), Vmath::Vstvpp(), Vmath::SIMD::Vvtvm(), Vmath::Vvtvm(), Vmath::SIMD::Vvtvp(), Vmath::Vvtvp(), Vmath::SIMD::Vvtvvtm(), Vmath::Vvtvvtm(), Vmath::SIMD::Vvtvvtp(), Vmath::Vvtvvtp(), Polylib::zwgj(), Polylib::zwgk(), Polylib::zwglj(), Polylib::zwgrjm(), Polylib::zwgrjp(), Polylib::zwlk(), and Polylib::zwrk().

z()

std::vector< double > Nektar::UnitTests::z

(

NPUPPER

)

Referenced by Nektar::MMFAdvection::AdvectionBellPlane(), Nektar::MMFAdvection::AdvectionBellSphere(), Nektar::SolverUtils::UnsteadySystem::AppendOutput1D(), Vmath::Assmb(), Nektar::StdRegions::StdExpansion::BaryEvaluate(), Nektar::VmathSIMDUnitTests::BOOST_AUTO_TEST_CASE(), CheckTetRotation(), Polylib::chri1(), Polylib::Dgj(), Polylib::Dglj(), Polylib::Dgrjm(), Polylib::Dgrjp(), Arpack::Dneupd(), Nektar::MMFDiffusion::DoOdeRhs(), Lapack::Dsbev(), Arpack::Dseupd(), Lapack::Dspev(), Equation_Evaluate2(), Equation_Evaluate3(), Equation_Evaluate4(), Equation_Evaluate5(), Nektar::LibUtilities::Interpreter::ExpressionEvaluator::Evaluate(), Nektar::LibUtilities::Interpreter::Evaluate(), Nektar::LibUtilities::Equation::Evaluate(), Nektar::MMFMaxwell::EvaluateCoriolis(), Nektar::MMFSWE::EvaluateCoriolisForZonalFlow(), Nektar::CompressibleFlowSystem::EvaluateIsentropicVortex(), Nektar::MMFSWE::EvaluateStandardCoriolis(), Nektar::MMFSWE::EvaluateWaterDepth(), Nektar::MultiRegions::DisContField::FindPeriodicTraces(), Vmath::SIMD::Gathr(), Vmath::Gathr(), Nektar::MMFMaxwell::GaussianPulse(), Nektar::LibUtilities::Basis::GenBasis(), Nektar::MMFMaxwell::GenerateSigmaPML(), Nektar::LocalRegions::PointExp::GetCoords(), Nektar::SolverUtils::EvaluatePoints::GetDefaultValue(), Nektar::SpatialDomains::MeshGraph::GetElementsContainingPoint(), Nektar::CompressibleFlowSystem::GetExactRinglebFlow(), Nektar::MultiRegions::ExpList::GetExpIndex(), Nektar::SpatialDomains::TriGeom::GetFaceOrientation(), Nektar::SpatialDomains::QuadGeom::GetFaceOrientation(), Nektar::LibUtilities::Points< DataT >::GetI(), GetNewVertexLocation(), Nektar::StdRegions::StdNodalPrismExp::GetNodalPoints(), Nektar::StdRegions::StdNodalTetExp::GetNodalPoints(), Nektar::LibUtilities::Points< DataT >::GetPoints(), Nektar::LibUtilities::Points< DataT >::GetZW(), Nektar::LibUtilities::Basis::GetZW(), Polylib::hgj(), Polylib::hglj(), Polylib::hgrjm(), Polylib::hgrjp(), Polylib::ImagBesselComp(), Interpreter_Evaluate2(), Interpreter_Evaluate3(), Nektar::MMFSWE::IsolatedMountainFlow(), Polylib::jacobd(), Polylib::jacobfd(), Polylib::Jacobz(), Polylib::JacZeros(), Polylib::laginterp(), Polylib::laginterpderiv(), main(), MappingEVids(), Nektar::FieldUtils::MappingIdealToRef(), Nektar::MMFDiffusion::Morphogenesis(), MoveOutsidePointsfixedxpos(), MoveOutsidePointsNnormpos(), Nektar::LibUtilities::NodalPrismEvenlySpaced::NodalPointReorder3d(), Nektar::LibUtilities::NodalTetEvenlySpaced::NodalPointReorder3d(), OUTPUT(), Nektar::FieldUtils::OutputVtk::OutputFromExpLowOrder(), Nektar::FieldUtils::OutputVtk::OutputFromExpLowOrderMultiBlock(), Nektar::LibUtilities::EulerExponentialTimeIntegrationScheme::phi_function(), Nektar::MMFDiffusion::PlanePhiWave(), Polylib::polycoeffs(), Nektar::MMFMaxwell::Printout_SurfaceCurrent(), Polylib::Qg(), Nektar::MMFSWE::RossbyWave(), Vmath::Scatr(), Nektar::IncNavierStokes::SetUpWomersley(), Nektar::MMFSWE::SteadyZonalFlow(), Vmath::Svtsvtp(), Vmath::Svtvm(), Vmath::Svtvp(), Nektar::MMFDiffusion::TestCubeProblem(), TestDifferentiation(), TestIntegral(), TestIntegralMatrix(), TestInterpolation(), Nektar::MMFMaxwell::TestMaxwellSphere(), Nektar::MMFDiffusion::TestPlaneProblem(), Nektar::MMFSWE::TestVorticityComputation(), Polylib::TriQL(), Nektar::MMFSWE::UnstableJetFlow(), Nektar::MMFSWE::UnsteadyZonalFlow(), Nektar::FilterMovingBody::UpdateForce(), Nektar::IsentropicVortexBC::v_Apply(), Nektar::LibUtilities::NodalPrismEvenlySpaced::v_CalculatePoints(), Nektar::LibUtilities::NodalTetEvenlySpaced::v_CalculatePoints(), Nektar::LibUtilities::PolyEPoints::v_CalculateWeights(), Nektar::MultiRegions::PreconditionerBlock::v_DoPreconditioner(), Nektar::MultiRegions::PreconditionerLowEnergy::v_DoPreconditioner(), Nektar::MMFMaxwell::v_DoSolve(), Nektar::MultiRegions::DisContField3DHomogeneous2D::v_EvaluateBoundaryConditions(), Nektar::SolverUtils::DriverArpack::v_Execute(), Nektar::SpatialDomains::Geometry2D::v_FindDistance(), Nektar::SolverUtils::MMFSystem::v_GenerateSummary(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList3DHomogeneous2D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_GetCoords(), Nektar::MultiRegions::ExpList2DHomogeneous2D::v_GetCoords(), Nektar::LibUtilities::NodalPrismElec::v_GetI(), Nektar::LibUtilities::NodalPrismEvenlySpaced::v_GetI(), Nektar::LibUtilities::NodalTetElec::v_GetI(), Nektar::LibUtilities::NodalTetEvenlySpaced::v_GetI(), Nektar::SpatialDomains::Geometry2D::v_GetLocCoords(), Nektar::SolverUtils::FilterLagrangianPoints::v_Initialise(), Nektar::FilterElectrogram::v_Initialise(), DummyEquationSystem::v_InitObject(), Nektar::StdRegions::StdSegExp::v_Integral(), Nektar::StdRegions::StdPointExp::v_IProductWRTBase(), Nektar::MMFSWE::v_LinfError(), Nektar::FieldUtils::OutputTecplot::v_OutputFromExp(), Nektar::FieldUtils::ProcessFieldFromString::v_Process(), Nektar::MultiRegions::ExpList2DHomogeneous1D::v_WriteVtkPieceHeader(), Nektar::MultiRegions::ExpList3DHomogeneous1D::v_WriteVtkPieceHeader(), Vmath::SIMD::Vadd(), Vmath::Vadd(), Vmath::Vdiv(), Vmath::SIMD::Vmul(), Vmath::Vmul(), Vmath::Vstvpp(), Vmath::Vsub(), Vmath::SIMD::Vvtvm(), Vmath::Vvtvm(), Vmath::SIMD::Vvtvp(), Vmath::Vvtvp(), Vmath::SIMD::Vvtvvtm(), Vmath::Vvtvvtm(), Vmath::SIMD::Vvtvvtp(), Vmath::Vvtvvtp(), Nektar::NonlinearPeregrine::WallBoundaryContVariables(), Nektar::SpatialDomains::Movement::WriteMovement(), Polylib::zwgj(), Polylib::zwgk(), Polylib::zwglj(), Polylib::zwgrjm(), Polylib::zwgrjp(), Polylib::zwlk(), and Polylib::zwrk().