source: trunk/test/kernel_lookup_test.cc @ 1134

// $Id: kernel_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/DataLookup1D.h"
#include "yat/classifier/KernelLookup.h"
#include "yat/classifier/Kernel_SEV.h"
#include "yat/classifier/MatrixLookup.h"
#include "yat/classifier/PolynomialKernelFunction.h"

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

using namespace theplu::yat;

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 KernelLookup" << std::endl;
  utility::Matrix data_core(1,5);
  for (size_t i=0; i<data_core.columns(); i++)
    data_core(0,i)=i;
  classifier::MatrixLookup data(data_core);
  classifier::PolynomialKernelFunction kf;
  classifier::Kernel_SEV kernel(data,kf);

  *error << "KernelLookup::KernelLookup(const Kernel&)...";
  classifier::KernelLookup k1(kernel);
  if (k1.rows()!=kernel.size() || k1.columns()!=kernel.size()) {
    ok =false;
    *error <<   "ERROR:" << std::endl;
    *error << "Dimensions do not agree." << std::endl;
  }
  else {
    for (size_t i=0; i<k1.rows(); i++) 
      for (size_t j=0; j<k1.columns(); j++) 
        if (k1(i,j)!=kernel(i,j)) {
          ok =false;
          *error << "ERROR:\n"
                 << "KernelLookup::KernelLookup(const Kernel& data)"
                 << std::endl;
          *error << "k(" << i << "," << j << ") is " << k1(i,j) 
                 << "expected " << kernel(i,j) << std::endl;
        }
    if (ok)
      *error << "Ok." << std::endl;
  }

  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);
  *error << "KernelLookup::KernelLookup(const Kernel&,\n"
         << "                           const vector<size_t>&,\n"
         << "                           const vector<size_t>&)...";
  classifier::KernelLookup k2(kernel,utility::Index(index_odd),
                              utility::Index(index_even));
  if (k2.rows()!=index_odd.size() || k2.columns()!=index_even.size()) {
    ok =false;
    *error << "ERROR:" << std::endl;
    *error << "Dimensions do not agree." << std::endl;
  }
  for (size_t i=0; i<k2.rows(); i++) 
    for (size_t j=0; j<k2.columns(); j++) 
      if (k2(i,j)!=kernel(index_odd[i],index_even[j])) {
        ok =false;
        *error << "ERROR:\n"
               << "KernelLookup::KernelLookup(const Kernel& data)"
               << std::endl;
        *error << "k(" << i << "," << j << ") is " << k2(i,j) 
               << "expected " << kernel(index_odd[i],index_even[j]) << std::endl;
      }
  if (ok)
    *error << "Ok." << std::endl;
  
  *error << "KernelLookup::KernelLookup(const KernelLookup&,\n"
         << "                           const vector<size_t>&,\n"
         << "                           const vector<size_t>&)...";
  std::vector<size_t> one(1,1);
  classifier::KernelLookup k3(k2,utility::Index(one),utility::Index(one));
  if (k3.rows()!=one.size() || k3.columns()!=one.size()) {
    ok =false;
    *error <<   "ERROR:" << std::endl;
    *error << "Dimensions do not agree." << std::endl;
  }
  else if (k3(0,0)!=k2(1,1)){
    ok = false;
    *error << "ERROR:\n k3(0,0) found to be " << k3(0,0) 
           << " expected " << k2(1,1) << std::endl;
  }
  else
    *error << "Ok." << std::endl;

  *error << "KernelLookup::KernelLookup(const KernelLookup&)...";
  classifier::KernelLookup k4(k2);
  if (k4.rows()!=k2.rows() || k4.columns()!=k2.columns()) {
    ok =false;
    *error <<   "ERROR:" << std::endl;
    *error << "Dimensions do not agree." << std::endl;
    *error << "Dimension: rows " << k4.rows() << " columns " << k4.columns()
           << "\nOriginal: rows " << k2.rows() << " columns " << k2.columns()
           << std::endl;
  }
  else {
    for (size_t i=0; i<k4.rows(); i++) 
      for (size_t j=0; j<k4.columns(); j++) 
        if (k4(i,j)!=k2(i,j)) {
          ok =false;
          *error << "ERROR:\n"
                 << "KernelLookup::KernelLookup(const KernelLookup&)"
                 << std::endl;
          *error << "k(" << i << "," << j << ") is " << k4(i,j) 
                 << "expected " << k2(i,j) << std::endl;
        }
  }
  
  KernelLookup k5(k1,utility::Index(index_even),utility::Index(index_even));
  std::vector<size_t> index5;
  index5.push_back(0);
  index5.push_back(2);
  const KernelLookup* k6 = k5.training_data(utility::Index(index5)); 
  for (size_t s=0; s<k6->rows(); s++) 
    for (size_t t=0; t<k6->rows(); t++) 
      ok = ok && ((*k6)(s,t)==(*k6)(t,s));


  if (ok)
    *error << "Ok." << std::endl;

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