TestMatrix.cpp

/* This file is part of the BIAS library (Basic ImageAlgorithmS).

   Copyright (C) 2003-2009    (see file CONTACT for details)
   Multimediale Systeme der Informationsverarbeitung
   Institut fuer Informatik
   Christian-Albrechts-Universitaet Kiel
   
   
   BIAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 of the License, or
   (at your option) any later version.
   
   BIAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public License
   along with BIAS; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/** @file TestMatrix.cpp
 *  @ingroup g_tests
 *  @brief Test for Matrix class, unfinished
    @relates Matrix
    @author f. woelk 05/2008 (c) www.vision-n.de 
*/

#include <Base/Math/Matrix.hh>
#include <Base/Math/Vector.hh>
#include <Base/Debug/Exception.hh>

using namespace BIAS;
using namespace std;

/// macro testing if command has thrown an exception
#define SHOULD_THROW(command) \
{ \
  bool has_thrown = false; \
  try { command; } \
  catch ( BaseException b ) { has_thrown = true; } \
  if (!has_thrown) { \
    if (verbose) cout << #command << " was expected to throw an exception"\
                      <<", but it has not thrown. Test failed. \n"<<dst<<endl; \
    BIASABORT; \
  } \
}

const bool verbose = false;

// fills a matrix with a constant value
void Fill(const double val, Matrix<double> &src);

// fills a vector with a constant value
void Fill(const double val, Matrix<double> &src);

// test the different set methods of the Matrix class
void TestSet();

int main(int argc, char *argv[])
{
  TestSet();
  return 0;
}


void Fill(const double val, Matrix<double> &src)
{
  for (int r=0; r<src.num_rows(); r++)
    for (int c=0; c<src.num_cols(); c++)
      src[r][c] = val;
}


void Fill(const double val, Vector<double> &src)
{
  for (int r=0; r<src.size(); r++)
    src[r] = val;
}



void TestSet()
{
  Matrix<double> dst(5, 5), src_small(2, 2), src_big(6, 6);
  Vector<double> src_vec(3);
  
  // initialize the matrizes
  Fill(0., dst);
  Fill(2., src_small);
  Fill(6., src_big);
  Fill(3., src_vec);

  dst.Set(0, 0, src_small);
  if (verbose) cout << dst << endl;

  Fill(0., dst);
  dst.Set(1, 0, src_small);
  if (verbose) cout << dst << endl;

  Fill(0., dst);
  dst.Set(0, 1, src_small);
  if (verbose) cout << dst << endl;

  // set to bottom right corner
  Fill(0., dst);
  dst.Set(3, 3, src_small);
  if (verbose) cout << dst << endl;

  Fill(0., dst);
  dst.Set(1, 1, src_vec);
  if (verbose) cout << dst << endl;
  
  Fill(0., dst);
  dst.SetTranspose(1, 1, src_vec);
  if (verbose) cout << dst << endl;
 
  Fill(0., dst);
  dst.Set(2, 4, src_vec);
  if (verbose) cout << dst << endl;
  
  Fill(0., dst);
  dst.SetTranspose(4, 2, src_vec);
  if (verbose) cout << dst << endl;
  
  Fill(0., dst);
  SHOULD_THROW( dst.Set(0, 0, src_big) );
  // set out of range
  SHOULD_THROW( dst.Set(4, 0, src_small) );
  SHOULD_THROW( dst.Set(0, 4, src_small) );
  SHOULD_THROW( dst.Set(4, 4, src_small) );
  SHOULD_THROW( dst.Set(5, 5, src_small) );

  SHOULD_THROW( dst.Set(3, 3, src_vec) );
  SHOULD_THROW( dst.SetTranspose(3, 3, src_vec) );
  SHOULD_THROW( dst.Set(3, 4, src_vec) );
  SHOULD_THROW( dst.SetTranspose(4, 3, src_vec) );
}