FastMatrixMath_test.cc File Reference

Tests the classes in SimpleFits.h. More...

#include <cmath>
#include <limits>
#include <array>
#include <algorithm>
#include <random>
#include <string>
#include <iostream>
#include "boost/test/unit_test.hpp"
#include "lardata/Utilities/FastMatrixMathHelper.h"

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   ( FastMatrixMath_test )

Functions
constexpr unsigned int	static_sqrt (unsigned int n)
template<typename Array >
void	PrintMatrix (std::ostream &out, Array const &m, std::string name="Matrix")
template<typename Array >
void	CheckSymmetric (Array const &m)
template<typename Array >
void	CheckInverse (Array const &a, Array const &a_inv)
template<typename Array >
void	MatrixTest (Array const &mat)
template<typename Array >
void	MatrixTest (Array const &mat, typename Array::value_type det)
template<typename Array >
void	SymmetricMatrixTest (Array const &mat)
template<typename Array >
void	SymmetricMatrixTest (Array const &mat, typename Array::value_type det)
template<typename T >
void	TestMatrix2x2 ()
template<typename T >
void	TestSymmetricMatrix2x2 ()
template<typename T >
void	TestMatrix3x3_1 ()
template<typename T >
void	TestMatrix3x3_2 ()
template<typename T >
void	TestSymmetricMatrix3x3 ()
template<typename T >
void	TestMatrix4x4_1 ()
template<typename T >
void	TestMatrix4x4_2 ()
template<typename T , unsigned int Dim>
void	TestMatrix_N (unsigned int N=100)
template<typename T , unsigned int Dim>
void	TestNullMatrix ()
template<typename T >
void	TestSymmetricMatrix4x4 ()
	BOOST_AUTO_TEST_CASE (Matrix2x2RealTest)
	BOOST_AUTO_TEST_CASE (Matrix3x3RealTest)
	BOOST_AUTO_TEST_CASE (Matrix4x4RealTest)

Detailed Description

Tests the classes in SimpleFits.h.

Author

Gianluca Petrillo (petri.nosp@m.llo@.nosp@m.fnal..nosp@m.gov)

Date

20141229

Version

1.0

See also

SimpleFits.h

See http://www.boost.org/libs/test for the Boost test library home page.

Timing: not given yet

Definition in file FastMatrixMath_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( FastMatrixMath_test )

Definition at line 38 of file FastMatrixMath_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

Matrix2x2RealTest

)

Definition at line 415 of file FastMatrixMath_test.cc.

                                        {
  TestMatrix2x2<double>();
  TestSymmetricMatrix2x2<double>();

  TestMatrix_N<double, 2>();
  TestNullMatrix<double, 2>();
}

BOOST_AUTO_TEST_CASE

(

Matrix3x3RealTest

)

Definition at line 423 of file FastMatrixMath_test.cc.

                                        {
  TestMatrix3x3_1<double>();
  TestMatrix3x3_2<double>();
  TestSymmetricMatrix3x3<double>();

  TestMatrix_N<double, 3>();
  TestNullMatrix<double, 3>();
}

BOOST_AUTO_TEST_CASE

(

Matrix4x4RealTest

)

Definition at line 432 of file FastMatrixMath_test.cc.

                                        {
  TestMatrix4x4_1<double>();
  TestMatrix4x4_2<double>();
  TestSymmetricMatrix4x4<double>();

  TestMatrix_N<double, 4>();
  TestNullMatrix<double, 4>();
}

template<typename Array >

void CheckInverse	(	Array const &	a,
		Array const &	a_inv
	)

Definition at line 92 of file FastMatrixMath_test.cc.

                                                      {

  const size_t Dim = size_t(std::sqrt(a.size()));
  using Data_t = typename Array::value_type;

  BOOST_TEST(a.size() == a_inv.size());

  for (size_t r = 0; r < Dim; ++r) {
    for (size_t c = 0; c < Dim; ++c) {
      Data_t v = 0.;
      for (size_t k = 0; k < Dim; ++k) {
        v += a[r * Dim + k] * a_inv[k * Dim + c];
      } // for
      if (r == c) BOOST_TEST(v == Data_t(1), 0.01% tolerance());
      else        BOOST_TEST(v == 0, 1e-5% tolerance());
    } // for column
  } // for row

} // CheckInverse()

template<typename Array >

void CheckSymmetric

(

Array const &

m

)

Definition at line 81 of file FastMatrixMath_test.cc.

                                    {
  const size_t Dim = size_t(std::sqrt(m.size()));

  for (size_t r = 1; r < Dim; ++r)
    for (size_t c = r + 1; c < Dim; ++c)
      BOOST_TEST(m[r * Dim + c] == m[r * Dim + c], 0.001% tolerance());

} // CheckSymmetric()

template<typename Array >

void MatrixTest

(

Array const &

mat

)

Definition at line 114 of file FastMatrixMath_test.cc.

                                  {

  using Data_t = typename Array::value_type;

  constexpr unsigned int Dim = static_sqrt(std::tuple_size<Array>::value);
  static_assert((Dim >= 1) && (Dim <= 4), "Dimension not supported");

  using FastMatrixOperations
    = lar::util::details::FastMatrixOperations<Data_t, Dim>;

  Array mat_inv = FastMatrixOperations::InvertMatrix(mat);
  PrintMatrix(std::cout, mat_inv, "Alleged inverse matrix");
  CheckInverse(mat, mat_inv);

} // MatrixTest()

template<typename Array >

void MatrixTest	(	Array const &	mat,
		typename Array::value_type	det
	)

Definition at line 132 of file FastMatrixMath_test.cc.

                                                                {

  using Data_t = typename Array::value_type;

  constexpr unsigned int Dim = static_sqrt(std::tuple_size<Array>::value);
  static_assert((Dim >= 1) && (Dim <= 4), "Dimension not supported");

  using FastMatrixOperations
    = lar::util::details::FastMatrixOperations<Data_t, Dim>;

  const Data_t my_det = FastMatrixOperations::Determinant(mat);
  BOOST_TEST(my_det == det, 1e-4% tolerance());

  if (std::isnormal(det)) {
    Array mat_inv = FastMatrixOperations::InvertMatrix(mat, det);
    PrintMatrix(std::cout, mat_inv, "Alleged inverse matrix");
    CheckInverse(mat, mat_inv);
  }
} // MatrixTest()

template<typename Array >

void PrintMatrix	(	std::ostream &	out,
		Array const &	m,
		std::string	name = "Matrix"
	)

Definition at line 63 of file FastMatrixMath_test.cc.

{
#ifdef FASTMATRIXMATH_TEST_DEBUG
  const size_t Dim = size_t(std::sqrt(m.size()));

  out << name << " " << Dim << "x" << Dim << ":";
  for (size_t r = 0; r < Dim; ++r) {
    out << "\n |";
    for (size_t c = 0; c < Dim; ++c)
      out << " " << m[r * Dim + c];
    out << " |";
  } // for
  out << std::endl;
#endif // FASTMATRIXMATH_TEST_DEBUG
} // PrintMatrix()

constexpr unsigned int static_sqrt

(

unsigned int

n

)

Definition at line 50 of file FastMatrixMath_test.cc.

                                                   {
  // too lazy to copy sqrt from Stroustrup
  return
    ((n ==  1)? 1:
    ((n ==  4)? 2:
    ((n ==  9)? 3:
    ((n == 16)? 4:
    std::numeric_limits<unsigned int>::max()))));
} // static_sqrt()

template<typename Array >

void SymmetricMatrixTest

(

Array const &

mat

)

Definition at line 154 of file FastMatrixMath_test.cc.

                                           {

  using Data_t = typename Array::value_type;

  constexpr unsigned int Dim = static_sqrt(std::tuple_size<Array>::value);
  static_assert((Dim >= 1) && (Dim <= 4), "Dimension not supported");

  using FastMatrixOperations
    = lar::util::details::FastMatrixOperations<Data_t, Dim>;

  CheckSymmetric(mat);

  Array mat_inv = FastMatrixOperations::InvertSymmetricMatrix(mat);
  PrintMatrix(std::cout, mat_inv, "Alleged inverse matrix");
  CheckInverse(mat, mat_inv);
  CheckSymmetric(mat_inv);
} // SymmetricMatrixTest()

template<typename Array >

void SymmetricMatrixTest	(	Array const &	mat,
		typename Array::value_type	det
	)

Definition at line 174 of file FastMatrixMath_test.cc.

                                                                         {

  using Data_t = typename Array::value_type;

  constexpr unsigned int Dim = static_sqrt(std::tuple_size<Array>::value);
  static_assert((Dim >= 1) && (Dim <= 4), "Dimension not supported");

  using FastMatrixOperations
    = lar::util::details::FastMatrixOperations<Data_t, Dim>;

  const Data_t my_det = FastMatrixOperations::Determinant(mat);
  BOOST_TEST(my_det == det, 1e-4% tolerance());

  if (std::isnormal(det)) {
    Array mat_inv = FastMatrixOperations::InvertSymmetricMatrix(mat, det);
    PrintMatrix(std::cout, mat_inv, "Alleged inverse matrix");
    CheckInverse(mat, mat_inv);
    CheckSymmetric(mat_inv);
  }
} // SymmetricMatrixTest()

template<typename T >

void TestMatrix2x2

(

)

Definition at line 198 of file FastMatrixMath_test.cc.

                     {
  using Data_t = T;
  constexpr unsigned int Dim = 2; // we are testing 2x2 matrices

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<Data_t, Dim*Dim> matrix = {{
    Data_t(2), Data_t(3),
    Data_t(4), Data_t(1)
  }}; // matrix
  const Data_t true_det = Data_t(-10);

  PrintMatrix(std::cout, matrix, "Matrix");
  MatrixTest(matrix, true_det);
} // TestMatrix2x2()

template<typename T >

void TestMatrix3x3_1

(

)

Definition at line 235 of file FastMatrixMath_test.cc.

                       {

  using Data_t = T;
  constexpr unsigned int Dim = 3; // we are testing 3x3 matrices

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<Data_t, Dim*Dim> matrix = {{
    Data_t(2), Data_t(0), Data_t(3),
    Data_t(0), Data_t(3), Data_t(0),
    Data_t(4), Data_t(0), Data_t(1),
  }}; // matrix
  const Data_t true_det = Data_t(-30);

  PrintMatrix(std::cout, matrix, "Matrix");
  MatrixTest(matrix, true_det);

} // TestMatrix3x3_1()

template<typename T >

void TestMatrix3x3_2

(

)

Definition at line 256 of file FastMatrixMath_test.cc.

                       {

  using Data_t = T;
  constexpr unsigned int Dim = 3; // we are testing 3x3 matrices

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<Data_t, Dim*Dim> matrix = {{
    Data_t(2), Data_t(4), Data_t(3),
    Data_t(0), Data_t(3), Data_t(0),
    Data_t(4), Data_t(0), Data_t(1),
  }}; // matrix
  const Data_t true_det = Data_t(-30);

  PrintMatrix(std::cout, matrix, "Matrix");
  MatrixTest(matrix, true_det);

} // TestMatrix3x3_2()

template<typename T >

void TestMatrix4x4_1

(

)

Definition at line 299 of file FastMatrixMath_test.cc.

                       {

  using Data_t = T;
  constexpr unsigned int Dim = 4; // we are testing 4x4 matrices

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<Data_t, Dim*Dim> matrix = {{
    Data_t(2), Data_t(0), Data_t(3), Data_t(0),
    Data_t(0), Data_t(3), Data_t(0), Data_t(6),
    Data_t(4), Data_t(0), Data_t(1), Data_t(0),
    Data_t(0), Data_t(2), Data_t(0), Data_t(7)
  }}; // matrix
  const Data_t true_det = Data_t(-90);

  PrintMatrix(std::cout, matrix, "Matrix");
  MatrixTest(matrix, true_det);

} // TestMatrix4x4_1()

template<typename T >

void TestMatrix4x4_2

(

)

Definition at line 321 of file FastMatrixMath_test.cc.

                       {

  using Data_t = T;
  constexpr unsigned int Dim = 4; // we are testing 4x4 matrices

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<Data_t, Dim*Dim> matrix = {{
    Data_t(2), Data_t(0), Data_t(3), Data_t(0),
    Data_t(5), Data_t(3), Data_t(0), Data_t(6),
    Data_t(4), Data_t(0), Data_t(1), Data_t(0),
    Data_t(3), Data_t(2), Data_t(0), Data_t(7)
  }}; // matrix
  const Data_t true_det = Data_t(-90);

  PrintMatrix(std::cout, matrix, "Matrix");
  MatrixTest(matrix, true_det);

} // TestMatrix4x4_2()

template<typename T , unsigned int Dim>

void TestMatrix_N

(

unsigned int

N = 100

)

Definition at line 343 of file FastMatrixMath_test.cc.

                                        {

  using Data_t = T;

  std::default_random_engine engine;
  std::uniform_real_distribution<Data_t> uniform(Data_t(-10.), Data_t(10.));

  std::array<Data_t, Dim*Dim> matrix;
  for (unsigned int i = 0; i < N; ++i) {

    std::generate(matrix.begin(), matrix.end(),
      [&engine, &uniform] { return uniform(engine); }
      );

    PrintMatrix(std::cout, matrix, "Matrix");
    MatrixTest(matrix);
  } // for

} // TestMatrix_N()

template<typename T , unsigned int Dim>

void TestNullMatrix

(

)

Definition at line 365 of file FastMatrixMath_test.cc.

                      {

  using Data_t = T;

  std::array<Data_t, Dim*Dim> matrix;
  matrix.fill(Data_t(0));

  PrintMatrix(std::cout, matrix, "Empty matrix");
  MatrixTest(matrix, Data_t(0));
  PrintMatrix(std::cout, matrix, "Empty symmetric matrix");
  SymmetricMatrixTest(matrix, Data_t(0));

} // TestNullMatrix()

template<typename T >

void TestSymmetricMatrix2x2

(

)

Definition at line 216 of file FastMatrixMath_test.cc.

                              {
  using Data_t = T;
  constexpr unsigned int Dim = 2; // we are testing 2x2 matrices

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<Data_t, Dim*Dim> matrix = {{
    Data_t(2), Data_t(3),
    Data_t(3), Data_t(1)
  }}; // matrix
  const Data_t true_det = Data_t(-7);

  PrintMatrix(std::cout, matrix, "Symmetric matrix");
  SymmetricMatrixTest(matrix, true_det);

} // TestSymmetricMatrix2x2()

template<typename T >

void TestSymmetricMatrix3x3

(

)

Definition at line 278 of file FastMatrixMath_test.cc.

                              {

  using Data_t = T;
  constexpr unsigned int Dim = 3; // we are testing 3x3 matrices

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<Data_t, Dim*Dim> matrix = {{
    Data_t(2), Data_t(0), Data_t(3),
    Data_t(0), Data_t(3), Data_t(0),
    Data_t(3), Data_t(0), Data_t(1),
  }}; // matrix
  const Data_t true_det = Data_t(-21);

  PrintMatrix(std::cout, matrix, "Symmetric matrix");
  SymmetricMatrixTest(matrix, true_det);

} // TestSymmetricMatrix3x3()

template<typename T >

void TestSymmetricMatrix4x4

(

)

Definition at line 382 of file FastMatrixMath_test.cc.

                              {

  using Data_t = T;
  constexpr unsigned int Dim = 4; // we are testing 4x4 matrices

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<Data_t, Dim*Dim> matrix = {{
    Data_t(2), Data_t(0), Data_t(3), Data_t(0),
    Data_t(0), Data_t(3), Data_t(0), Data_t(2),
    Data_t(3), Data_t(0), Data_t(1), Data_t(0),
    Data_t(0), Data_t(2), Data_t(0), Data_t(7)
  }}; // matrix
  const Data_t true_det = Data_t(-119);

  PrintMatrix(std::cout, matrix, "Symmetric matrix");
  SymmetricMatrixTest(matrix, true_det);

} // TestSymmetricMatrix4x4()