source: trunk/test/nni_test.cc @ 710

// $Id: nni_test.cc 710 2006-12-20 22:08:25Z jari $

/*
  Copyright (C) The authors contributing to this file.

  This file is part of the yat library, http://lev.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/FileUtil.h"
#include "yat/utility/matrix.h"
#include "yat/utility/kNNI.h"
#include "yat/utility/WeNNI.h"

#include <cmath>
#include <iostream>
#include <fstream>
#include <string>

using namespace theplu::yat;

void check_file_access(std::string& str)
{
  utility::FileUtil file(str);
  if (file.access_rights(str,"r")) {
    std::cerr << "test_nni: Cannot access file " << str << std::endl;
    exit(-1);
  }
}

int main(const int argc,const char* argv[])
{
  bool print = (argc>1 && argv[1]==std::string("-p"));
  bool ok = true;
  uint neighbours=3;
  std::string knni_data("data/knni_matrix.data");
  std::string knni_result("data/knni_result.data");
  std::string knni_weight("data/knni_weight.data");
  std::string wenni_data("data/knni_matrix.data");
  std::string wenni_result("data/wenni_result.data");
  std::string wenni_weight("data/wenni_weight.data");
  check_file_access(knni_data);
  check_file_access(knni_result);
  check_file_access(knni_weight);
  check_file_access(wenni_data);
  check_file_access(wenni_result);
  check_file_access(wenni_weight);

  // test kNNI
  std::ifstream data_stream(knni_data.c_str());
  std::ifstream weight_stream(knni_weight.c_str());
  utility::matrix data(data_stream);
  utility::matrix weight(weight_stream);
  utility::kNNI knni(data,weight,neighbours);
  knni.estimate();
  std::ifstream control_stream(knni_result.c_str());
  utility::matrix control(control_stream);
  control-=knni.imputed_data();
  // Jari, should we use GSL defined round off errors? Anyway, the
  // hardcoded number below should be changed.
  double error_bound = 5e-13;
  for (unsigned int i=0; i<control.rows(); i++)
    for (unsigned int j=0; j<control.columns(); j++)
      if (fabs(control(i,j))>error_bound) {
        if (print)
          std::cerr << "kNNI FAILED, error on row " << i << " and " 
                    << "column " << j << " is " << fabs(control(i,j))
                    << ". Expected less than " << error_bound << std::endl;
        ok=false; // calculation result out of accepted error bounds
      }
      else
        if (!((control(i,j)==control(i,j)))) {
          if (print)
            std::cerr << "kNNI FAILED, nan (not a number) " 
                      << "encountered in test on row " << i
                      << " and column " << j << std::endl;
          ok =false; // calucaltion error detected
        }
  control_stream.close();
  data_stream.close();
  weight_stream.close();

  // test WeNNI
  data_stream.open(wenni_data.c_str());
  data=utility::matrix(data_stream);
  weight_stream.open(wenni_weight.c_str());
  weight=utility::matrix(weight_stream);
  utility::WeNNI wenni(data,weight,neighbours);
  wenni.estimate();
  control_stream.open(wenni_result.c_str());
  control=utility::matrix(control_stream);
  control-=wenni.imputed_data();
  for (unsigned int i=0; i<control.rows(); i++)
    for (unsigned int j=0; j<control.columns(); j++)
      // Jari, should we use GSL defined round off errors? Anyway, the
      // hardcoded number below should be changed.
      if (fabs(control(i,j))>error_bound) {
        if (print)
          std::cerr << "WeNNI FAILED, error on row " << i << " and " 
                    << "column " << j << " is " << fabs(control(i,j))
                    << ". Expected less than " << error_bound << std::endl;
        ok=false; // calculation result out of accepted error bounds
      }
      else
        if (!((control(i,j)==control(i,j)))) {
          if (print) 
            std::cerr << "WeNNI FAILED, nan (not a number) " 
                      << "encountered in test on row " << i
                      << " and column " << j << std::endl;
          ok=false; // calucaltion error detected
        }
  control_stream.close();
  data_stream.close();
  weight_stream.close();

  // test WeNNI with binary weights
  data_stream.open(knni_data.c_str());
  data=utility::matrix(data_stream);
  weight_stream.open(knni_weight.c_str());
  weight=utility::matrix(weight_stream);
  utility::WeNNI wenni2(data,weight,neighbours);
  wenni2.estimate();
  control_stream.open(knni_result.c_str());
  control=utility::matrix(control_stream);
  control-=wenni2.imputed_data();
  for (unsigned int i=0; i<control.rows(); i++)
    for (unsigned int j=0; j<control.columns(); j++)
      // Jari, should we use GSL defined round off errors? Anyway, the
      // hardcoded number below should be changed.
      if (fabs(control(i,j))>error_bound) {
        if (print)
          std::cerr << "WeNNI binary weight test FAILED.\nError on row " << i
                    << " and column " << j << " is " << fabs(control(i,j))
                    << ". Expected less than " << error_bound << std::endl;
        ok=false; // calculation result out of accepted error bounds
      }
      else
        if (!((control(i,j)==control(i,j)))) {
          if (print) 
            std::cerr << "WeNNI binary wieght test FAILED.\n"
                      << "nan (not a number) encountered in test on row " << i
                      << " and column " << j << std::endl;
          ok=false; // calucaltion error detected
        }
  control_stream.close();
  data_stream.close();
  weight_stream.close();

  return (ok ? 0 : -1);
}