Line data    Source code

       1             : /*
       2             :  * File:   TestOpDCT3.cpp
       3             :  * Author: chung
       4             :  *
       5             :  * Created on Sep 16, 2015, 3:42:02 AM
       6             :  */
       7             : 
       8             : #include "TestOpDCT3.h"
       9             : #include "OpAdjoint.h"
      10             : #include <cmath>
      11             : 
      12             : void testOperatorLinearity(LinearOperator*);
      13             : 
      14           1 : CPPUNIT_TEST_SUITE_REGISTRATION(TestOpDCT3);
      15             : 
      16           3 : TestOpDCT3::TestOpDCT3() {
      17           3 : }
      18             : 
      19           6 : TestOpDCT3::~TestOpDCT3() {
      20           6 : }
      21             : 
      22           3 : void TestOpDCT3::setUp() {
      23           3 : }
      24             : 
      25           3 : void TestOpDCT3::tearDown() {
      26           3 : }
      27             : 
      28           1 : void TestOpDCT3::testCall() {
      29           1 :     const size_t n = 15;
      30           1 :     const size_t repeat = 50;
      31           1 :     const double tol = 1e-10;
      32             : 
      33           1 :     LinearOperator * op = new OpDCT3(n);
      34           1 :     _ASSERT_EQ(n, op->dimensionIn().first);
      35           1 :     _ASSERT_EQ(n, op->dimensionOut().first);
      36           1 :     Matrix *x = new Matrix();
      37           1 :     Matrix *y = new Matrix();
      38             :     
      39           1 :     _ASSERT_NOT(op->isSelfAdjoint());
      40             : 
      41          51 :     for (size_t q = 0; q < repeat; q++) {
      42          50 :         *x = MatrixFactory::MakeRandomMatrix(n, 1, 0.0, 10.0, Matrix::MATRIX_DENSE);
      43          50 :         *y = MatrixFactory::MakeRandomMatrix(n, 1, -3.0, 10.0, Matrix::MATRIX_DENSE);
      44             : 
      45          50 :         Matrix Tx = op->call(*x);
      46         100 :         Matrix Tstar_y = op->callAdjoint(*y);
      47             :         
      48             :         
      49         100 :         Matrix err = (*y) * Tx;
      50         100 :         Matrix temp = (*x) * Tstar_y;
      51          50 :         Matrix::add(err, -1.0, temp, 1.0);
      52             : 
      53          50 :         _ASSERT(std::abs(err.get(0, 0)) < tol);
      54          50 :     }
      55             : 
      56           1 :     delete op;
      57           1 :     delete x;
      58           1 :     delete y;
      59           1 : }
      60             : 
      61           2 : void testOperatorLinearity(LinearOperator* op) {
      62             : 
      63           2 :     double a = 10.0 * static_cast<double> (std::rand()) / static_cast<double> (RAND_MAX);
      64           2 :     double b = 10.0 * static_cast<double> (std::rand()) / static_cast<double> (RAND_MAX);
      65             : 
      66           2 :     Matrix x = MatrixFactory::MakeRandomMatrix(op->dimensionIn().first, op->dimensionIn().second, 0.0, 1.0);
      67           4 :     Matrix y = MatrixFactory::MakeRandomMatrix(op->dimensionIn().first, op->dimensionIn().second, 0.0, 1.0);
      68             : 
      69             :     // create z = ax + by
      70           4 :     Matrix z(x);
      71           2 :     Matrix::add(z, b, y, a);
      72             :     
      73           4 :     Matrix Tx = op->call(x);
      74           4 :     Matrix Ty = op->call(y);
      75             :     
      76             :     // create aTx + bTy
      77           4 :     Matrix T(Tx);
      78           2 :     Matrix::add(T, b, Ty, a);
      79             :     
      80           4 :     Matrix T2 = op->call(z);
      81             :     
      82           4 :     _ASSERT_EQ(T,T2);    
      83             :    
      84           2 : }
      85             : 
      86           1 : void TestOpDCT3::testLinearity() {
      87           1 :     const size_t n = 50;
      88           1 :     LinearOperator * op = new OpDCT3(n);
      89           1 :     _ASSERT_EQ(n, op->dimensionIn().first);
      90           1 :     _ASSERT_EQ(n, op->dimensionOut().first);
      91           1 :     testOperatorLinearity(op);
      92           1 :     delete op;
      93           1 : }
      94             : 
      95           1 : void TestOpDCT3::testAdjointLinearity() {
      96           1 :     const size_t n = 60;
      97           1 :     LinearOperator * op = new OpDCT3(n);
      98           1 :     _ASSERT_EQ(n, op->dimensionIn().first);
      99           1 :     _ASSERT_EQ(n, op->dimensionOut().first);
     100           1 :     LinearOperator *adj = new OpAdjoint(*op);
     101           1 :     _ASSERT_EQ(n, adj->dimensionIn().first);
     102           1 :     _ASSERT_EQ(n, adj->dimensionOut().first);
     103           1 :     testOperatorLinearity(adj);
     104           1 :     delete op;
     105           1 :     delete adj;
     106           4 : }