source: trunk/test/matrix_lookup_test.cc @ 1134

// $Id: matrix_lookup_test.cc 1134 2008-02-23 22:52:43Z peter $

/*
  Copyright (C) 2006 Jari Häkkinen, Peter Johansson

  This file is part of the yat library, http://trac.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of the
  License, or (at your option) any later version.

  The yat library 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
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "yat/utility/Matrix.h"
#include "yat/classifier/MatrixLookup.h"

#include <fstream>
#include <iostream>
#include <vector>

using namespace theplu::yat;

utility::Matrix matrix(size_t n);

int main(const int argc,const char* argv[])
{
  using namespace theplu::yat::classifier;

  std::ostream* error;
  if (argc>1 && argv[1]==std::string("-v"))
    error = &std::cerr;
  else {
    error = new std::ofstream("/dev/null");
    if (argc>1)
      std::cout << "lookup_test -v : for printing extra information\n";
  }
  bool ok = true;

  *error << "\nTesting MatrixLookup" << std::endl;
  *error << "MatrixLookup::MatrixLookup(const utility::Matrix& data)...";
  utility::Matrix gsl_m1(matrix(2));
  classifier::MatrixLookup m1(gsl_m1);
  if (m1.rows()!=gsl_m1.rows() || m1.columns()!=gsl_m1.columns() || 
      m1(0,0)!=gsl_m1(0,0) || m1(0,1)!=gsl_m1(0,1) || 
      m1(1,0)!=gsl_m1(1,0) || m1(1,1)!=gsl_m1(1,1) ) {
    ok =false;
    *error <<   "ERROR:" << std::endl;
  }
  else 
    *error << "Ok" << std::endl;

 
  *error << "MatrixLookup::MatrixLookup(const utility::Matrix&,\n" 
         << "                           const std::vector<size_t>&,\n"
         << "                           const std::vector<size_t>&)...";
  utility::Matrix gsl_m2(matrix(4));
  std::vector<size_t> index_odd;
  index_odd.push_back(1);
  index_odd.push_back(3);
  std::vector<size_t> index_even;
  index_even.push_back(2);
  index_even.push_back(0);
  
  classifier::MatrixLookup m2(gsl_m2,utility::Index(index_odd), 
                              utility::Index(index_even));
  if (m2.rows()!=2 || m2.columns()!=2 || 
      m2(0,0)!=gsl_m2(1,2) || m2(0,1)!=gsl_m2(1,0) || 
      m2(1,0)!=gsl_m2(3,2) || m2(1,1)!=gsl_m2(3,0) ) {
    ok =false;
    *error <<   "ERROR:" << std::endl;
  }
  else
    *error << "Ok" << std::endl;

  *error << "MatrixLookup::MatrixLookup(const utility::Matrix&,\n" 
         << "                           const std::vector<size_t>&,\n"
         << "                           const bool)...";
  std::vector<size_t> one(1,1);
  classifier::MatrixLookup m3(gsl_m2,utility::Index(one),true);
  if (m3.rows()!=1 || m3.columns()!=gsl_m2.columns() || m3(0,0)!=gsl_m2(1,0) || 
      m3(0,1)!=gsl_m2(1,1) || m3(0,2)!=gsl_m2(1,2) || m3(0,3)!=gsl_m2(1,3)) {
    ok =false;
    *error <<   "ERROR:" << std::endl;
    *error << "m3.rows(): " << m3.rows() << " expected 1" << std::endl; 
    *error << "m3.columns(): " << m3.columns() << " expected " 
           << gsl_m2.columns() << std::endl; 
  }
  else
    *error << "Ok" << std::endl;

  *error << "MatrixLookup::MatrixLookup(const MatrixLookup&)...";
  classifier::MatrixLookup m4(m2);
  if (m4.rows()!=m2.rows() || m4.columns()!=m2.rows() || m4(0,0)!=m2(0,0) || 
      m4(0,1)!=m2(0,1) || m4(1,0)!=m2(1,0) || m4(1,1)!=m2(1,1) ) {
    ok =false;
    *error <<   "ERROR:" << std::endl;
  }
  else
    *error << "Ok" << std::endl;

  *error << "MatrixLookup::MatrixLookup(const MatrixLookup& data\n" 
         << "                           const std::vector<size_t>&,\n"
         << "                           const std::vector<size_t>&)...";
  classifier::MatrixLookup m5(m2,utility::Index(one),utility::Index(one));
  if (m5.rows()!=1 || m5.columns()!=1 || m5(0,0)!=m2(1,1) ) {
    ok =false;
    *error <<   "ERROR:" << std::endl;
    *error << "MatrixLookup is " << m5(0,0) << " expected " << m2(1,1)
           << std::endl;
  }
  else
    *error << "Ok" << std::endl;
  
  *error << "MatrixLookup::MatrixLookup(const MatrixLookup&,\n" 
         << "                           const std::vector<size_t>&,\n"
         << "                           const bool)...";
  classifier::MatrixLookup m6(m2,utility::Index(one),true);
  if (m6.rows()!=1 || m6.columns()!=m2.columns() || m6(0,0)!=m2(1,0) || 
      m6(0,1)!=m2(1,1)) {
    ok =false;
    *error << "ERROR:" << std::endl;
  }
  else
    *error << "Ok" << std::endl;

  *error << "MatrixLookup::MatrixLookup(const size_t,const size_t,\n"
         << "                           const double)...";
  classifier::MatrixLookup m7(103,112,12);
  if (m7.rows()!=103 || m7.columns()!=112 || m7(0,0)!=12) {
    ok =false;
    *error << "ERROR:" << std::endl;
  }
  else
    *error << "Ok" << std::endl;


  *error << "MatrixLookup::training_data(const std::vector<size_t>)...";
  const classifier::MatrixLookup* TrnData =m2.training_data(utility::Index(one));
  if (TrnData->rows() != m2.rows() || TrnData->columns()!=one.size()){
    ok =false;
    *error << "ERROR:" << std::endl;
  }
  else
    *error << "Ok" << std::endl;
  delete TrnData;

  *error << "MatrixLookup::validation_data(const std::vector<size_t>,\n"
         << "                              const std::vector<size_t>)...";
  std::vector<size_t> val(23,2);
  const classifier::MatrixLookup* ValData = 
    m2.validation_data(utility::Index(one), utility::Index(val));
  if (ValData->rows() != m2.rows() || TrnData->columns()!=val.size()){
    ok =false;
    *error << "ERROR:" << std::endl;
  }
  else
    *error << "Ok" << std::endl;
  delete ValData;

  if (ok)
    *error << "Test Ok." << std::endl;
  if (error!=&std::cerr)
    delete error;
  return (ok ? 0 : -1);
}

utility::Matrix matrix(size_t n)
{
  utility::Matrix res(n,n);
  for (size_t i=0;i<n;i++)
    for (size_t j=0;j<n;j++)
      res(i,j)=10*i+j;
  return res;
}