Algorythms/Orthogonal Polynomials/TEST/OrthPolTEST.cpp

#include <gtest/gtest.h>
#include "modules/OrthPol.cpp"
#include "ExplicitExpressions.h"

class OrthPolTest : public testing::Test {};

// Test that OrthPol returns correct values if x=0
TEST_F(OrthPolTest, ChebPolZeroCase) {
   double zero = 0.0;
   for (int i=0; i<=50; ++i) 
   {

      std::vector<double> res = OrthPol(1, i, 0);
      if (i % 2 == 1)
      {
        EXPECT_DOUBLE_EQ(res[0], zero) << "Chebyshev polinom of the first kind " << i << "th-order are not equal 0";
        EXPECT_DOUBLE_EQ(res[1], pow(-1.0, (i-1)/2)*i) << "Derivative of Chebyshev polinom of the first kind " << i << "th-order are not equal "<< i << "*(-1)^" << (i-1)/2;
      }
      else
      {
        EXPECT_DOUBLE_EQ(res[0], pow(-1.0, i/2)) << "Chebyshev polinom of the first kind " << i << "th-order are not equal (-1)^" << i/2;
        EXPECT_DOUBLE_EQ(res[1], zero) << "Derivative of Chebyshev polinom of the first kind " << i << "th-order are not equal 0";
      }
   }
   for (int i=0; i<=50; ++i) 
   {
      std::vector<double> res = OrthPol(2, i, 0);
      if (i % 2 == 1)
      {
        EXPECT_DOUBLE_EQ(res[0], zero) << "Chebyshev polinom of the second kind " << i << "th-order are not equal 0";
        EXPECT_DOUBLE_EQ(res[1], pow(-1.0, (i-1)/2)*(i+1)) << "Derivative of Chebyshev polinom of the second kind " << i << "th-order are not equal "<< (i+1) << "*(-1)^" << (i-1)/2;
      }
      else
      {
        EXPECT_DOUBLE_EQ(res[0], pow(-1.0, i/2)) << "Chebyshev polinom of the second kind " << i << "th-order are not equal (-1)^" << i/2;
        EXPECT_DOUBLE_EQ(res[1], zero) << "Derivative of Chebyshev polinom of the second kind " << i << "th-order are not equal 0";
      }
   }
}

// Test that OrthPol returns correct values if x=+-1
TEST_F(OrthPolTest, ChebPolOneCase) {
   for (int i=0; i<=50; ++i) 
   {
    std::vector<double> res = OrthPol(1, i, 1);
    EXPECT_DOUBLE_EQ(res[0], 1) << "Chebyshev polinom of the first kind " << i << "th-order are not equal " << 1;
    EXPECT_DOUBLE_EQ(res[1], pow(i, 2)) << "Derivative of Chebyshev polinom of the first kind " << i << "th-order are not equal "<< pow(i, 2);

    res = OrthPol(2, i, 1);
    EXPECT_DOUBLE_EQ(res[0], i+1) << "Chebyshev polinom of the second kind " << i << "th-order are not equal " << i+1;
    EXPECT_DOUBLE_EQ(res[1], i*(i+1)*(i+2)/3) << "Derivative of Chebyshev polinom of the first kind " << i << "th-order are not equal "<< i*(i+1)*(i+2)/3;

    res = OrthPol(1, i, -1);
    EXPECT_DOUBLE_EQ(res[0], pow(-1, i)) << "Chebyshev polinom of the first kind " << i << "th-order are not equal " << pow(-1, i);
    EXPECT_DOUBLE_EQ(res[1], pow(-1, i-1) * pow(i, 2)) << "Derivative of Chebyshev polinom of the first kind " << i << "th-order are not equal "<< pow(-1, i-1) * pow(i, 2);

    res = OrthPol(2, i, -1);
    EXPECT_DOUBLE_EQ(res[0], pow(-1, i)*(i+1)) << "Chebyshev polinom of the first kind " << i << "th-order are not equal " << pow(-1, i)*(i+1);
    EXPECT_DOUBLE_EQ(res[1], pow(-1, i+1) * (i*(i+1)*(i+2)/3)) << "Derivative of Chebyshev polinom of the first kind " << i << "th-order are not equal "<< pow(-1, i+1) * (i*(i+1)*(i+2)/3);
   }
}

TEST_F(OrthPolTest, ExplicitExprChebyshevCase){
    double x = -1; // the left boundary
    double length = 2; //the length of the segmment
    double step = 0.2;
    std::vector<double> res_rec;
    double res_expl;
    for (int i=0; i <= static_cast<int>(length / step); ++i)
    {
        for (int j=0; j <= 20; ++j)
        {
            res_rec = OrthPol(1, j, x);
            res_expl = ExplicitExpressionCheb(1, j, x);
            if (res_rec[0] != 0.0)
            {
                EXPECT_NEAR(1, res_expl / res_rec[0], EPS_CHEB);
            }
            else
            {
                EXPECT_NEAR(res_rec[0], res_expl, EPS_CHEB);
            }

            res_rec = OrthPol(2, j, x);
            res_expl = ExplicitExpressionCheb(2, j, x);
            if (res_rec[0] != 0.0)
            {
                EXPECT_NEAR(1, res_expl / res_rec[0], EPS_CHEB);
            }
            else
            {
                EXPECT_NEAR(res_rec[0], res_expl, EPS_CHEB);
            }

        }
        x += step;
    }
}

TEST_F(OrthPolTest, ExplicitExprLaguerreCase){
    double x = -10; // the left boundary
    double length = 20; //the length of the segmment
    double step = 0.5;
    std::vector<double> res_rec;
    double res_expl;
    for (int i=0; i <= static_cast<int>(length / step); ++i)
    {
        for (int j=0; j <= 20; ++j)
        {
            res_rec = OrthPol(3, j, x);
            res_expl = ExplicitExpressionLaguerre(j, x);
            if (res_rec[0] != 0.0)
            {
                EXPECT_NEAR(1, res_expl / res_rec[0], EPS_LAG);
            }
            else
            {
                EXPECT_NEAR(res_rec[0], res_expl, EPS_LAG);
            }
        }
        x += step;
    }
}

TEST_F(OrthPolTest, ExplicitExprHermiteCase){
    double x = -10; // the left boundary
    double length = 20; //the length of the segmment
    double step = 0.5;
    std::vector<double> res_rec;
    double res_expl;
    for (int i=0; i <= static_cast<int>(length / step); ++i)
    {
        for (int j=0; j <= 20; ++j)
        {
            res_rec = OrthPol(4, j, x);
            res_expl = ExplicitExpressionHermite(j, x);
            if (res_rec[0] != 0.0)
            {
                EXPECT_NEAR(1, res_expl / res_rec[0], EPS_HERM);
            }
            else
            {
                EXPECT_NEAR(res_rec[0], res_expl, EPS_HERM);
            }
        }
        x += step;
    }
}

int main(int argc, char **argv) {
  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}