source: trunk/test/data_lookup_1d_test.cc @ 865

// $Id: data_lookup_1d_test.cc 865 2007-09-10 19:41:04Z peter $

/*
  Copyright (C) 2006 Jari Häkkinen, Markus Ringnér, Peter Johansson
  Copyright (C) 2007 Peter Johansson

  This file is part of the yat library, http://trac.thep.lu.se/trac/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/DataLookup1D.h"
#include "yat/classifier/MatrixLookup.h"
#include "yat/classifier/utility.h"


#include <cstdio>
#include <fstream>
#include <iostream>
#include <vector>
#include <cmath>

using namespace theplu::yat;

utility::matrix matrix(size_t n);
int end_test(std::ostream*, bool);

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";
  }
  

  *error << "Testing Lookup Classes" << std::endl;
  bool ok = true;

  

  if(!std::numeric_limits<double>::has_quiet_NaN) {
    *error << "Error: a compiler without quiet_NaN is used!\n"
     << "This will likely also mess up a lot of other yat tests\n"; 
    ok=false;
    return end_test(error,ok);
  }



  *error << "Testing DataLookup1D" << std::endl;
  utility::matrix gsl_m1(matrix(5));
  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);
  index_even.push_back(4);
  classifier::MatrixLookup m1(gsl_m1,index_odd,index_even);
  *error << gsl_m1 << std::endl << '\n';
  *error << m1 << std::endl;
  *error << "DataLookup1D::DataLookup1D(const MatrixLookup&\n"
         << "                           const size_t, const bool)...";
  classifier::DataLookup1D v1(m1,1, true);
  if (v1.size()!=m1.columns() || v1(0)!=m1(1,0) || 
      v1(1)!=m1(1,1) ) {
    ok =false;
    *error << "\nERROR" << std::endl;
    *error << "size: " << v1.size() << " expected " << m1.columns() << "\n" 
           << "v1(0): " << v1(0) << " expected " << m1(1,0) << "\n"
           << "v1(1): " << v1(1) << " expected " << m1(1,1) 
           << std::endl;
  }
  else
    *error << "Ok" << std::endl;

  *error << "DataLookup1D::DataLookup1D(const MatrixLookup&\n"
         << "                           const size_t, const bool false)...";
  classifier::DataLookup1D v2(m1,1,false);
  if (v2.size()!=m1.rows() || v2(0)!=m1(0,1) || v2(1)!=m1(1,1) ) {
    ok =false;
    *error << "\nERROR\n"
           << "size: " << v2.size() << " expected " << m1.rows() << "\n" 
           << "v2(0): " << v2(0) << " expected " << m1(0,1) << "\n"
           << "v2(1): " << v2(1) << " expected " << m1(1,1) 
           << std::endl;
  }
  else
    *error << "Ok" << std::endl;

  *error << "DataLookup1D::DataLookup1D(const DataLookup1D&)...";
  classifier::DataLookup1D v3(v2);
  if (v3.size()!=v2.size() || v3(0)!=v2(0) || v3(1)!=v2(1) ) {
    ok =false;
    *error << "\nERROR\n"
           << "size: " << v3.size() << " expected " << v2.size() << "\n" 
           << "v2(0): " << v3(0) << " expected " << v2(0) << "\n"
           << "v2(1): " << v3(1) << " expected " <<  v2(1)
           << std::endl;
  }
  else
    *error << "Ok" << std::endl;

  *error << "DataLookup1D::DataLookup1D(const size_t, const double)...";
  classifier::DataLookup1D v4(12,3);
  if (v4.size()!=12 || v4(10)!=3 ) {
    ok =false;
    *error << "\nERROR\n"
           << "size: " << v4.size() << " expected " << 12 << "\n" 
           << "v2(0): " << v4(10) << " expected " << 3 
           << std::endl;
  }
  else
    *error << "Ok" << std::endl;

  *error << "Testing that output from ostream operator for DataLookup1D"
         << " can be used by the utility::vector istream constructor...";

  // First with a vector with no missing values separated by ' '.
  std::ofstream my_out("data/tmp_test_datalookup1D.txt");
  my_out << v1;
  my_out.close();
  std::ifstream is("data/tmp_test_datalookup1D.txt");
  utility::vector v5(is);
  is.close();
  if (v5.size()!=v1.size() || v5(0)!=v1(0) || v5(1)!=v1(1) ||
      v5(2)!=v1(2)) {
    ok=false;
    *error << "\nERROR\n" << std::endl;
  }
  std::remove("data/tmp_test_datalookup1D.txt");
  
  // Second with a vector with a missing value separated by '\t'.
  gsl_m1(3,0)=std::numeric_limits<double>::quiet_NaN();
  classifier::DataLookup1D v6(m1,1, true);  
  my_out.open("data/tmp_test_datalookup1D.txt");
  char prev=my_out.fill('\t');
  my_out << v1;
  my_out.fill(prev);
  my_out.close();
  is.open("data/tmp_test_datalookup1D.txt");
  utility::vector v7(is,'\t');
  is.close();
  if (v7.size()!=v6.size() || !std::isnan(v7(1))) {
    ok=false;
    *error << "\nERROR\n"
           << "size: " << v7.size() << " expected " << v6.size() << "\n" 
           << "v7(1): " << v7(1) << " expected nan\n" 
           << std::endl;
  }
  std::remove("data/tmp_test_datalookup1D.txt");
  *error << "\n";

  DataLookup1D dl(v5);
  utility::vector v8;
  classifier::convert(dl, v8);
  if (!v5.equal(v8,0.0)) {
    ok = false;
    *error << "Error: Creating a DataLookup1D(utility::vector)\n"
           << "and classifier::convert(DataLookup, utility::vector)\n"
           << "does not give back original vector\n"
           << "orginal:      " << v5 << "\n"
           << "DataLookup1D: " << dl << "\n"
           << "final result: " << v8 << "\n"
           << std::endl;
  }

  return end_test(error,ok);
}

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;
}

int end_test(std::ostream* error, bool ok) 
{  
  if (ok)
    *error << "Ok." << std::endl;
  if (error!=&std::cerr)
    delete error;
  return (ok ? 0 : -1);
}