matrix_ij_test.cc

一个通用的数学库

// -*- c++ -*-
//
// Copyright 1997, 1998, 1999 University of Notre Dame.
// Authors: Andrew Lumsdaine, Jeremy G. Siek, Lie-Quan Lee
//
// This file is part of the Matrix Template Library
//
// You should have received a copy of the License Agreement for the
// Matrix Template Library along with the software;  see the
// file LICENSE.  If not, contact Office of Research, University of Notre
// Dame, Notre Dame, IN  46556.
//
// Permission to modify the code and to distribute modified code is
// granted, provided the text of this NOTICE is retained, a notice that
// the code was modified is included with the above COPYRIGHT NOTICE and
// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE
// file is distributed with the modified code.
//
// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.
// By way of example, but not limitation, Licensor MAKES NO
// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY
// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS
// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS
// OR OTHER RIGHTS.
//
//===========================================================================

#include "mtl/utils.h"
#include "mtl/matrix.h"
#include "matrix_test.h"

// matrix_attr.h is generated by make_and_test.pl and defines
// NUMTYPE, SHAPE, STORAGE, ORIEN, and TESTNAME
// you can create your own for testing purposes
#include "matrix_attr.h"


template <class Matrix>
bool const_operator_ij_test(const Matrix& A, std::string test_name, 
			    rectangle_tag)
{
  typedef typename mtl::matrix_traits<Matrix>::size_type Int;
  typedef typename mtl::matrix_traits<Matrix>::value_type T;
  Int i, j;
  T c = T(0);
  for (i = 0; i < A.nrows(); ++i)
    for (j = 0; j < A.ncols(); ++j) {
      c = c + T(1);
      if (A(i,j) != c) {
	std::cerr << "**** FAILED: ( const operator(i,j) ) "
	     << test_name.c_str() << " ****" << std::endl;
	std::cerr << "A(" << i << "," << j << ") = " << A(i,j) << std::endl;
	std::cerr << "c = " << c << std::endl;
	return false;
      }
    }
  return true;
}


template <class Matrix>
bool operator_ij_test(Matrix& A, std::string test_name, 
		      rectangle_tag)
{
  typedef typename mtl::matrix_traits<Matrix>::size_type Int;
  typedef typename mtl::matrix_traits<Matrix>::value_type T;
  Int i, j;
  T c = T(0);
  for (i = 0; i < A.nrows(); ++i)
    for (j = 0; j < A.ncols(); ++j) {
      c = c + T(1);
      A(i,j) = c;
    }

  c = 0;
  for (i = 0; i < A.nrows(); ++i)
    for (j = 0; j < A.ncols(); ++j) {
      c = c + T(1);
      if (A(i,j) != c) {
	std::cerr << "**** FAILED: ( operator(i,j) ) "
	     << test_name.c_str() << " ****" << std::endl;
#ifndef _MSVCPP_
	std::cerr << "A(" << i << "," << j << ") = " << A(i,j) << std::endl;
	std::cerr << "c = " << c << std::endl;
#endif
	return false;
      }
    }
  bool ret = const_operator_ij_test(A, test_name, rectangle_tag());
  if (ret) {
    std::cout << test_name.c_str() << " passed operator(i,j)" << std::endl;
    return true;
  } else
    return false;
}


template <class Matrix>
bool const_operator_ij_test(const Matrix& A, std::string test_name,
			    banded_tag)
{
  typedef typename mtl::matrix_traits<Matrix>::size_type Int;
  typedef typename mtl::matrix_traits<Matrix>::value_type T;
  Int i, j;
  int lo = A.sub();
  int up = A.super();
  T c = T(0);
  for (i = 0; i < A.nrows(); ++i) {
    Int first = MTL_MAX(0, int(i) - lo);
    Int last = MTL_MIN(int(A.ncols()), int(i) + up + 1);
    for (j = 0; j < A.ncols(); ++j) {
      if (j >= first && j < last) {
	c = c + T(1);
	if (A(i,j) != c) {
	  std::cerr << "**** FAILED: ( const operator(i,j) banded ) "
	       << test_name.c_str() << " ****" << std::endl;
#ifndef _MSVCPP_
	  std::cerr << "A(" << i << "," << j << ") = " << A(i,j) << std::endl;
	  std::cerr << "c = " << c << std::endl;
#endif
	  return false;
	}
      }
    }
  }
  return true;
}


template <class Matrix>
bool const_operator_ij_test(const Matrix& A, std::string test_name,
			    symmetric_tag)
{
  typedef typename mtl::matrix_traits<Matrix>::size_type Int;
  typedef typename mtl::matrix_traits<Matrix>::value_type T;
  Int i, j;
  int lo = A.sub();
  int up = A.super();
  for (i = 0; i < A.nrows(); ++i) {
    Int first = MTL_MAX(0, int(i) - lo);
    Int last = MTL_MIN(int(A.ncols()), int(i) + up + 1);
    for (j = 0; j < A.ncols(); ++j) {
      if (j >= first && j < last)
	if (A(i,j) != T(i + j)) {
	  std::cerr << "**** FAILED: ( const operator(i,j) symmetric )  "
	       << test_name.c_str() << " ****" << std::endl;
#ifndef _MSVCPP_
	  std::cerr << "A(" << i << "," << j << ") = " << A(i,j) << std::endl;
	  std::cerr << "correct = " << i + j << std::endl;
#endif
	  return false;
	}
    }
  }
  return true;
}

template <class Matrix>
bool operator_ij_test(Matrix& A, std::string test_name,
		      banded_tag)
{
  typedef typename mtl::matrix_traits<Matrix>::size_type Int;
  typedef typename mtl::matrix_traits<Matrix>::value_type T;
  Int i, j;
  int lo = A.sub();
  int up = A.super();
  T c = T(0);
  // JGS, going with a symmetric test matrix
  for (i = 0; i < A.nrows(); ++i) {
    Int first = MTL_MAX(0, int(i) - lo);
    Int last = MTL_MIN(int(A.ncols()), int(i) + up + 1);
    for (j = 0; j < A.ncols(); ++j)
      if (j >= first && j < last) {
	c = c + T(1);
	A(i,j) = c;
      }
  }
  c = 0;
  for (i = 0; i < A.nrows(); ++i) {
    Int first = MTL_MAX(0, int(i) - lo);
    Int last = MTL_MIN(int(A.ncols()), int(i) + up + 1);
    for (j = 0; j < A.ncols(); ++j) {
      if (j >= first && j < last) {
	c = c + T(1);
	if (A(i,j) != c) {
	  std::cerr << "**** FAILED: ( operator(i,j) banded ) "
	       << test_name.c_str() << " ****" << std::endl;
#if !defined(_MSVCPP_)
	  std::cerr << "A(" << i << "," << j << ") = " << A(i,j) << std::endl;
	  std::cerr << "c = " << c << std::endl;
#endif
	  return false;
	}
      }
    }
  }
  bool ret = const_operator_ij_test(A, test_name, banded_tag());
  if (ret) {
    std::cout << test_name.c_str() << " passed operator(i,j) banded" << std::endl;
    return true;
  } else
    return false;
}


template <class Matrix>
bool operator_ij_test(Matrix& A, std::string test_name,
		      symmetric_tag)
{
  typedef typename mtl::matrix_traits<Matrix>::size_type Int;
  typedef typename mtl::matrix_traits<Matrix>::value_type T;
  Int i, j;
  int lo = A.sub();
  int up = A.super();
  for (i = 0; i < A.nrows(); ++i) {
    Int first = MTL_MAX(0, int(i) - lo);
    Int last = MTL_MIN(int(A.ncols()), int(i) + up + 1);
    for (j = 0; j < A.ncols(); ++j)
      if (j >= first && j < last)
	A(i,j) = T(i + j);
  }
  for (i = 0; i < A.nrows(); ++i) {
    Int first = MTL_MAX(0, int(i) - lo);
    Int last = MTL_MIN(int(A.ncols()), int(i) + up + 1);
    for (j = 0; j < A.ncols(); ++j) {
      if (j >= first && j < last) {
	if (A(i,j) != T(i + j)) {
	  std::cerr << "**** FAILED: ( operator(i,j) ) symmetric "
	       << test_name.c_str() << " ****" << std::endl;
#if !defined(_MSVCPP_)
	  std::cerr << "A(" << i << "," << j << ") = " << A(i,j) << std::endl;
	  std::cerr << "correct = " << i + j << std::endl;
#endif
	  return false;
	}
      }
    }
  }
  bool ret = const_operator_ij_test(A, test_name, symmetric_tag());
  if (ret) {
    std::cout << test_name.c_str() << " passed operator(i,j) symmetric " << std::endl;
    return true;
  } else
    return false;
}


template <class Matrix>
bool operator_ij_test(Matrix& A, std::string test_name) {
  typedef typename mtl::matrix_traits<Matrix>::shape Shape;
  return operator_ij_test(A, test_name, Shape());
}


template <class Matrix>
void
do_test(Matrix& A, std::string test_name)
{
  using namespace mtl;

  typedef typename mtl::matrix_traits<Matrix>::value_type T;
  typedef typename mtl::matrix_traits<Matrix>::size_type Int;

  iterator_fill(A);

  operator_ij_test(A, test_name);
}


int
main(int argc, char* argv[])
{
  if (argc < 5) {
    std::cerr << "matrix_test <M> <N> <SUB> <SUPER>" << std::endl;
    return -1;
  }

  using namespace mtl;
  using std::string;

  const int M = atoi(argv[1]);
  const int N = atoi(argv[2]);
  const int SUB = atoi(argv[3]);
  const int SUP = atoi(argv[4]);

  std::cout << "M: " << M << " N: " << N 
       << " SUB: " << SUB << " SUPER: " << SUP << std::endl;

  typedef matrix<NUMTYPE, SHAPE, STORAGE, ORIEN>::type Matrix;

  string test_name = TESTNAME;
  Matrix* a = 0;

  create_and_run(M, N, SUB, SUP, test_name, a, Matrix::shape());

  return 0;
}