source: trunk/test/matrix_lookup_weighted_test.cc @ 1797

// $Id: matrix_lookup_weighted_test.cc 1797 2009-02-12 18:07:10Z peter $

/*
  Copyright (C) 2008 Peter Johansson

  This file is part of the yat library, http://dev.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 3 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "Suite.h"

#include "yat/utility/MatrixWeighted.h"
#include "yat/classifier/MatrixLookupWeighted.h"

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

using namespace theplu::yat;

utility::MatrixWeighted matrix_weighted(size_t n);
bool compare(const classifier::MatrixLookupWeighted&,
             const utility::MatrixWeighted,
             const utility::Index& row_index,
             const utility::Index& col_index,
             test::Suite& suite);

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

  test::Suite suite(argc, argv);

  suite.err() << "\nTesting MatrixLookupWeighted" << std::endl;
  suite.err() << "  Testing\n" 
              << "  MatrixLookupWeighted(const utility::MatrixWeighted&,\n"
              << "                       const utility::Index& rows,\n"
              << "                       const utility::Index& columns); "
              << "...";
  utility::MatrixWeighted mw = matrix_weighted(10);
  std::vector<size_t> index;
  index.push_back(1);
  index.push_back(5);
  index.push_back(3);
  utility::Index row_index(5);
  utility::Index column_index(index);
  MatrixLookupWeighted mlw(mw, row_index, column_index);
  if (compare(mlw, mw, row_index, column_index, suite))
    suite.err() << "ok.\n";
  else
    suite.err() << "failed.\n";


  suite.err() << "  Testing\n" 
              << "  MatrixLookupWeighted(const utility::MatrixWeighted&); "
              << "...";
  MatrixLookupWeighted mlw2(mw);
  if (compare(mlw2, mw, utility::Index(mw.rows()), utility::Index(mw.columns()), 
              suite))
    suite.err() << "ok.\n";
  else
    suite.err() << "failed.\n";

  suite.err() << "  Testing\n" 
              << "  MatrixLookupWeighted(const MatrixLookupWeighted&); "
              << "...";
  MatrixLookupWeighted mlw3(mlw);
  if (compare(mlw3, mw, row_index, column_index, suite))
    suite.err() << "ok.\n";
  else
    suite.err() << "failed.\n";

  return suite.return_value();
}

bool compare(const classifier::MatrixLookupWeighted& mlw,
             const utility::MatrixWeighted mw,
             const utility::Index& row_index,
             const utility::Index& column_index,
             test::Suite& suite)
{
  bool ok=true;
  ok &= (mlw.rows() == row_index.size());
  ok &= (mlw.columns() == column_index.size());
  for (size_t i=0; i<mlw.rows() && ok; ++i) {
    for (size_t j=0; j<mlw.columns(); ++j) {
      ok &= (mlw(i,j) == mw(row_index[i], column_index[j]));
    }
  }
  suite.add(ok);
  return ok;
}


utility::MatrixWeighted matrix_weighted(size_t n)
{
  utility::MatrixWeighted res(n,n);
  for (size_t i=0;i<n;i++)
    for (size_t j=0;j<n;j++)
      res(i,j).data()=10*i+j;
  return res;
}