source: trunk/test/matrix_weighted_test.cc @ 2143

// $Id: matrix_weighted_test.cc 2143 2010-01-15 14:12:56Z peter $

/*
  Copyright (C) 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009 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/Matrix.h"
#include "yat/utility/MatrixWeighted.h"

#include <string>

using namespace theplu::yat;
using utility::MatrixWeighted;
void test_constructor_void(test::Suite& suite);
void test_constructor_const(test::Suite& suite);
void test_constructor_matrix(test::Suite& suite);
void test_concepts(test::Suite& suite);
void test_swap(test::Suite& suite);

int main(int argc, char* argv[])
{
  test::Suite suite(argc, argv);

  test_constructor_void(suite);
  test_constructor_const(suite);
  test_constructor_matrix(suite);
  test_swap(suite);
  test_concepts(suite);

  suite.return_value();
}


void test_concepts(test::Suite& suite)
{
  const MatrixWeighted const_m(2,2,0);
  MatrixWeighted mutable_m(2,2,0);
  // concept compiler tests
  suite.test_concept_container2d(const_m);
  suite.test_concept_mutable_container2d(mutable_m);
}


void test_constructor_const(test::Suite& suite)
{
  suite.err() << "testing MatrixWeighted(size_t, size_t , double, double)" 
              << std::endl;
  MatrixWeighted x(10, 20, 1.0, 0.92);
  suite.add(x.columns()==20);
  suite.add(x.rows()==10);
  for (size_t i=0; i<x.rows(); ++i)
    for (size_t j=0; j<x.columns(); ++j) {
      suite.add(suite.equal(x(i,j).data(),1.0));
      suite.add(suite.equal(x(i,j).weight(),0.92));
    }
}


void test_constructor_matrix(test::Suite& suite)
{
  suite.err() << "testing MatrixWeighted(const Matrix&)" << std::endl;
  utility::Matrix x(2,3,1.12);
  x(0,0)=0.93;
  utility::MatrixWeighted xw(x);
  if (x.columns()==xw.columns() && x.rows()==xw.rows()) {
    for (size_t i=0; i<xw.rows(); ++i)
      for (size_t j=0; j<xw.columns(); ++j) {
        suite.add(suite.equal(xw(i,j).data(), x(i,j)));
        suite.add(suite.equal(xw(i,j).weight(), 1.0));
      }
  }
  else {
    suite.add(false);
    suite.err() << "ERROR: sizes mismatch" << std::endl;
    suite.err() << "  MatrixWeighted is " << xw.rows() << " x " << xw.columns()
                << std::endl;
    suite.err() << "  expected " << x.rows() << " x " << x.columns()
                << std::endl;
  }
  
}


void test_constructor_void(test::Suite& suite)
{
  MatrixWeighted x;
  suite.add(x.columns()==0);
  suite.add(x.rows()==0);
}

void test_swap(test::Suite& suite)
{
  MatrixWeighted x(3,10);
  MatrixWeighted y(0,0);
  x.swap(y);
  suite.add(x.columns()==0);
  suite.add(x.rows()==0);
  suite.add(y.columns()==10);
  suite.add(y.rows()==3);
}