libraries/libmatricxx
1
0
Fork 0
Code Issues Pull Requests Releases Activity

more operators more tests

Browse Source
This commit is contained in:
Marc Wäckerlin
2016-08-19 14:52:35 +00:00
parent 092d194b95
commit b9ccd5dee5
8 changed files with 363 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
COPYING
View File

@@ -1 +1 @@
/usr/share/automake-1.15/COPYING
/usr/share/automake-1.14/COPYING

2
INSTALL
View File

@@ -1 +1 @@
/usr/share/automake-1.15/INSTALL
/usr/share/automake-1.14/INSTALL

3
ax_cxx_compile_stdcxx_11.m4
View File

@@ -201,15 +201,16 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX_14], [dnl
AC_MSG_ERROR([*** A compiler with support for C++14 language features is required.])
fi
else
HAVE_CXX11=${HAVE_CXX14}
if test x$ac_success = xno; then
HAVE_CXX14=0
AC_MSG_NOTICE([No compiler with C++14 support was found])
AX_CXX_COMPILE_STDCXX_11([$1], [optional])
else
HAVE_CXX14=1
AC_DEFINE(HAVE_CXX14,1,
[define if the compiler supports basic C++14 syntax])
fi
HAVE_CXX11=${HAVE_CXX14}
AC_SUBST(HAVE_CXX11)
AC_SUBST(HAVE_CXX14)
fi

19
ax_init_standard_project.m4
View File

@@ -129,7 +129,7 @@ AC_DEFUN([AX_SUBST], [
# m4_define(x_minor, MINOR_NUMBER) # project's minor version
# m4_include(ax_init_standard_project.m4)
# AC_INIT(x_package_name, x_version, x_bugreport, x_package_name)
# AM_INIT_AUTOMAKE([1.9 tar-pax])
# AM_INIT_AUTOMAKE([1.9 tar-pax parallel-tests color-tests])
# AX_INIT_STANDARD_PROJECT
#
# you change nothing but: YOUR_PACKAGE_NAME, MAJOR_NUMBER, MINOR_NUMBER
@@ -243,6 +243,21 @@ AC_DEFUN([AX_INIT_STANDARD_PROJECT], [
AM_CPPFLAGS="${AM_CPPFLAGS} -DQT_NO_DEBUG_OUTPUT -DQT_NO_DEBUG"
fi
AC_ARG_WITH(gcov,
[AS_HELP_STRING([--with-gcov=FILE],
[enable gcov, set gcov file (defaults to gcov)])],
[GCOV="$enableval"], [GCOV="no"])
AM_CONDITIONAL(COVERAGE, test "$GCOV" != "no")
if test "$GCOV" != "no"; then
if test "$GCOV" == "yes"; then
GCOV=gcov
fi
AC_MSG_NOTICE([Coverage tests enabled, using ${GCOV}]);
AM_CXXFLAGS="${AM_CXXFLAGS:-} -O0 --coverage -fprofile-arcs -ftest-coverage"
AM_LDFLAGS="${AM_LDFLAGS} -O0 --coverage -fprofile-arcs"
AX_SUBST(GCOV)
fi
if test -f ${PACKAGE_NAME}.desktop.in; then
AC_CONFIG_FILES([${PACKAGE_NAME}.desktop])
fi
@@ -273,7 +288,7 @@ EOF
AC_DEFUN([AX_USE_CXX], [
m4_include(ax_cxx_compile_stdcxx_11.m4)
AC_LANG(C++)
AX_CXX_COMPILE_STDCXX_11(noext, optional)
AX_CXX_COMPILE_STDCXX_14(noext, optional)
AC_PROG_CXX
AC_PROG_CPP

2
bootstrap.sh
View File

@@ -129,6 +129,7 @@ GENERATED FILES
* ax_init_standard_project.m4 - auxiliary macro definition file
* ax_cxx_compile_stdcxx_11.m4 - auxiliary macro definition file
* ax_check_qt.m4 - auxiliary macro definition file
* makefile_test.inc.am - makefile to be included in tests
* resolve-debbuilddeps.sh - script to install debian package dependencies
* resolve-rpmbuilddeps.sh - script to install RPM package dependencies
* build-in-docker.sh - script to build the project encapsulated in a docker container
@@ -500,6 +501,7 @@ copy ${MY_NAME}
copy ax_init_standard_project.m4
copy ax_cxx_compile_stdcxx_11.m4
copy ax_check_qt.m4
copy makefile_test.inc.am
copy resolve-debbuilddeps.sh
copy resolve-rpmbuilddeps.sh
copy build-in-docker.sh

5
makefile_test.inc.am Normal file
View File

@@ -0,0 +1,5 @@
## @id $Id$
## 1 2 3 4 5 6 7 8
## 45678901234567890123456789012345678901234567890123456789012345678901234567890

168
src/matrix.hxx
View File

@@ -84,6 +84,41 @@ template<typename TYPE, typename ARRAY=TYPE*> class MatrixBase {
///}
/// @name element access
///{
TYPE& at(size_t row, size_t column) {
assert(row<ROWS);
assert(column<COLUMNS);
return *((TYPE*)_c+row*COLUMNS+column);
}
const TYPE& at(size_t row, size_t column) const {
assert(row<ROWS);
assert(column<COLUMNS);
return *((TYPE*)_c+row*COLUMNS+column);
}
TYPE& operator()(size_t row, size_t column) {
return at(row, column);
}
const TYPE& operator()(size_t row, size_t column) const {
return at(row, column);
}
RowVector operator[](size_t row) {
assert(row<ROWS);
return RowVector(*this, (TYPE*)_c+row*COLUMNS);
}
const ConstRowVector operator[](size_t row) const {
assert(row<ROWS);
return ConstRowVector(*this, (TYPE*)_c+row*COLUMNS);
}
///}
/// @name operators
///{
@@ -138,29 +173,28 @@ template<typename TYPE, typename ARRAY=TYPE*> class MatrixBase {
///}
/// @name element access
/// @name special operations
///{
TYPE& operator()(size_t row, size_t column) {
assert(row<ROWS);
assert(column<COLUMNS);
return *((TYPE*)_c+row*COLUMNS+column);
TYPE det() {
// rule of sarrus
TYPE res(0);
assert(ROWS==COLUMNS); // not really necessary
// 1) terms to add
for (size_t i(0); i<COLUMNS; ++i) {
TYPE term(1);
for (size_t j(0); j<ROWS; ++j)
term *= at((i+j)%COLUMNS, j);
res += term;
}
const TYPE& operator()(size_t row, size_t column) const {
assert(row<ROWS);
assert(column<COLUMNS);
return *((TYPE*)_c+row*COLUMNS+column);
// 2) terms to subtract
for (size_t i(0); i<COLUMNS; ++i) {
TYPE term(1);
for (size_t j(0); j<ROWS; ++j)
term *= at((i+j)%COLUMNS, ROWS-j-1);
res -= term;
}
RowVector operator[](size_t row) {
assert(row<ROWS);
return RowVector(*this, (TYPE*)_c+row*COLUMNS);
}
const ConstRowVector operator[](size_t row) const {
assert(row<ROWS);
return ConstRowVector(*this, (TYPE*)_c+row*COLUMNS);
return res;
}
///}
@@ -196,18 +230,19 @@ template<typename TYPE, size_t TROWS=0, size_t TCOLUMNS=0> class Matrix:
/// @name construction
///{
Matrix(): Parent(TROWS, TCOLUMNS) {}
template<typename ...ARGS>
Matrix(ARGS...t): Parent(TROWS, TCOLUMNS, t...) {
static_assert(sizeof...(t)==TROWS*TCOLUMNS,
"wrong array size");
Matrix(): Parent(TROWS, TCOLUMNS) {
memset(Parent::_c, 0, Parent::MEM_SIZE);
}
Matrix(const Matrix& o): Matrix() {
memcpy(Parent::_c, o._c, Parent::MEM_SIZE);
}
template<typename ...ARGS>
Matrix(ARGS...t): Parent(TROWS, TCOLUMNS, t...) {
static_assert(sizeof...(t)==TROWS*TCOLUMNS, "wrong array size");
}
///}
/// @name operators
@@ -218,14 +253,6 @@ template<typename TYPE, size_t TROWS=0, size_t TCOLUMNS=0> class Matrix:
return *this;
}
Matrix<TYPE, TCOLUMNS, TROWS> T() const {
Matrix<TYPE, TCOLUMNS, TROWS> res;
for (size_t row(0); row<TROWS; ++row)
for (size_t column(0); column<TCOLUMNS; ++column)
res(column, row) = Parent::operator()(row, column);
return res;
}
Matrix operator-() const {
Matrix res;
for (TYPE *to((TYPE*)(res._c)+Parent::SIZE); to>(TYPE*)(Parent::_c); --to)
@@ -234,15 +261,30 @@ template<typename TYPE, size_t TROWS=0, size_t TCOLUMNS=0> class Matrix:
}
template<size_t NEWCOLUMNS>
Matrix operator*(const Matrix<TYPE, TCOLUMNS, NEWCOLUMNS>& o) {
Matrix<TYPE, TROWS, NEWCOLUMNS>
operator*(const Matrix<TYPE, TCOLUMNS, NEWCOLUMNS>& o) const {
Matrix<TYPE, TROWS, NEWCOLUMNS> res;
for (size_t i(0); i<TROWS; ++i)
for (size_t k(0); k<NEWCOLUMNS; ++k)
for (size_t j(0); j<TCOLUMNS; ++j)
res(i, k) += (*this)(i, j) * o(j, k);
res(i, k) += this->at(i, j) * o(j, k);
return res;
}
///}
/// @name special operations
///{
Matrix<TYPE, TCOLUMNS, TROWS> t() const {
Matrix<TYPE, TCOLUMNS, TROWS> res;
for (size_t row(0); row<TROWS; ++row)
for (size_t column(0); column<TCOLUMNS; ++column)
res(column, row) = this->at(row, column);
return res;
}
///}
};
//==============================================================================
@@ -260,12 +302,18 @@ template<typename TYPE> class Matrix<TYPE, 0, 0>: public MatrixBase<TYPE> {
/// @name construction
///{
Matrix() = delete;
Matrix(size_t rows, size_t columns):
Parent(rows, columns) {
Parent::_c = new TYPE[rows*columns];
memset(Parent::_c, 0, Parent::MEM_SIZE);
}
Matrix(const Matrix& o): Matrix(o.ROWS, o.Parent::COLUMNS) {
memcpy(Parent::_c, o.Parent::_c, Parent::MEM_SIZE);
}
template<typename ...ARGS>
Matrix(size_t rows, size_t columns, ARGS...t):
Matrix(rows, columns) {
@@ -273,10 +321,6 @@ template<typename TYPE> class Matrix<TYPE, 0, 0>: public MatrixBase<TYPE> {
copy_args(Parent::_c, t...);
}
Matrix(const Matrix& o): Matrix(o.ROWS, o.Parent::COLUMNS) {
memcpy(Parent::_c, o.Parent::_c, Parent::MEM_SIZE);
}
///}
/// @name destruction
@@ -303,11 +347,11 @@ template<typename TYPE> class Matrix<TYPE, 0, 0>: public MatrixBase<TYPE> {
return Parent::operator=(o);
}
Matrix T() const {
Matrix t() const {
Matrix res(Parent::COLUMNS, Parent::ROWS);
for (size_t row(0); row<Parent::ROWS; ++row)
for (size_t column(0); column<Parent::COLUMNS; ++column)
res(column, row) = Parent::operator()(row, column);
res(column, row) = this->at(row, column);
return res;
}
@@ -318,6 +362,16 @@ template<typename TYPE> class Matrix<TYPE, 0, 0>: public MatrixBase<TYPE> {
return res;
}
Matrix operator*(const Matrix& o) const {
Matrix<TYPE> res(this->ROWS, o.COLUMNS);
assert(this->COLUMNS==o.ROWS);
for (size_t i(0); i<this->ROWS; ++i)
for (size_t k(0); k<o.COLUMNS; ++k)
for (size_t j(0); j<this->COLUMNS; ++j)
res(i, k) += this->at(i, j) * o(j, k);
return res;
}
///}
//................................................................methods
@@ -343,6 +397,38 @@ template<typename TYPE> class Matrix<TYPE, 0, 0>: public MatrixBase<TYPE> {
//==============================================================================
template<typename TYPE, size_t ROWS, size_t COLUMNS>
Matrix<TYPE, ROWS, COLUMNS> operator+(const Matrix<TYPE, ROWS, COLUMNS>& a,
const Matrix<TYPE, ROWS, COLUMNS>& b) {
Matrix<TYPE, ROWS, COLUMNS> res(a);
res += b;
return res;
}
template<typename TYPE, size_t ROWS, size_t COLUMNS>
Matrix<TYPE, ROWS, COLUMNS> operator-(const Matrix<TYPE, ROWS, COLUMNS>& a,
const Matrix<TYPE, ROWS, COLUMNS>& b) {
Matrix<TYPE, ROWS, COLUMNS> res(a);
res -= b;
return res;
}
template<typename TYPE, size_t ROWS, size_t COLUMNS>
Matrix<TYPE, ROWS, COLUMNS> operator*(const TYPE& v,
const Matrix<TYPE, ROWS, COLUMNS>& m) {
Matrix<TYPE, ROWS, COLUMNS> res(m);
res *= v;
return res;
}
template<typename TYPE, size_t ROWS, size_t COLUMNS>
Matrix<TYPE, ROWS, COLUMNS> operator*(const Matrix<TYPE, ROWS, COLUMNS>& m,
const TYPE& v) {
Matrix<TYPE, ROWS, COLUMNS> res(m);
res *= v;
return res;
}
template<typename TYPE, size_t ROWS, size_t COLUMNS>
std::ostream& operator<<(std::ostream& s, const Matrix<TYPE, ROWS, COLUMNS>& m) {
for (size_t w = 0; w < m.ROWS; ++w) {

203
test/basic.cxx
View File

@@ -17,7 +17,7 @@ class TemplateMatrixTest: public CppUnit::TestFixture {
public:
template<typename T>
void initFromArray1() {
Matrix<T,2,4> m {1, 2, 3, 4,
const Matrix<T,2,4> m {1, 2, 3, 4,
5, 6, 7, 8};
CPPUNIT_ASSERT_EQUAL((T)1, m[0][0]);
CPPUNIT_ASSERT_EQUAL((T)2, m[0][1]);
@@ -30,7 +30,7 @@ class TemplateMatrixTest: public CppUnit::TestFixture {
}
template<typename T>
void initFromArray2() {
Matrix<T,2,4> m(1, 2, 3, 4,
const Matrix<T,2,4> m(1, 2, 3, 4,
5, 6, 7, 8);
CPPUNIT_ASSERT_EQUAL((T)1, m[0][0]);
CPPUNIT_ASSERT_EQUAL((T)2, m[0][1]);
@@ -43,7 +43,7 @@ class TemplateMatrixTest: public CppUnit::TestFixture {
}
template<typename T>
void initFromArray3() {
Matrix<T,2,4> m({1, 2, 3, 4,
const Matrix<T,2,4> m({1, 2, 3, 4,
5, 6, 7, 8});
CPPUNIT_ASSERT_EQUAL((T)1, m[0][0]);
CPPUNIT_ASSERT_EQUAL((T)2, m[0][1]);
@@ -81,7 +81,7 @@ class TemplateMatrixTest: public CppUnit::TestFixture {
}
template<typename T>
void initFromDefault() {
Matrix<T,2,2> m;
const Matrix<T,2,2> m;
CPPUNIT_ASSERT_EQUAL((T)0, m[0][0]);
CPPUNIT_ASSERT_EQUAL((T)0, m[0][1]);
CPPUNIT_ASSERT_EQUAL((T)0, m[1][0]);
@@ -105,9 +105,69 @@ class TemplateMatrixTest: public CppUnit::TestFixture {
5, 6, 7, 9);
Matrix<T,2,4> m4(9, 2, 3, 4,
5, 6, 7, 8);
Matrix<T,2,4> m5(1, 2, 0, 4,
5, 6, 7, 8);
CPPUNIT_ASSERT(m1==m2);
CPPUNIT_ASSERT(m1!=m3);
CPPUNIT_ASSERT(m1!=m4);
CPPUNIT_ASSERT(m1!=m5);
}
template<typename T>
void operator_plus() {
const Matrix<T,2,4> m1(1, 2, 3, 4,
5, 6, 7, 8);
const Matrix<T,2,4> m2(2, 4, 6, 8,
1, 3, 5, 7);
const Matrix<T,2,4> m(m1+m2);
const Matrix<T,2,4> res(3, 6, 9, 12,
6, 9, 12, 15);
CPPUNIT_ASSERT_EQUAL(res, m);
}
template<typename T>
void operator_minus() {
const Matrix<T,2,4> m1(1, 2, 3, 4,
5, 6, 7, 8);
const Matrix<T,2,4> m2(2, 4, 6, 8,
1, 3, 5, 7);
const Matrix<T,2,4> m(m1-m2);
const Matrix<T,2,4> res(-1, -2, -3, -4,
4, 3, 2, 1);
CPPUNIT_ASSERT_EQUAL(res, m);
}
template<typename T>
void scalar_mult() {
const Matrix<T,2,4> m1(1, 2, 3, 4,
5, 6, 7, 8);
T two(2), three(3), four(4), big(32);
CPPUNIT_ASSERT_EQUAL(m1*two, m1+m1);
CPPUNIT_ASSERT_EQUAL(m1*three, m1+m1+m1);
CPPUNIT_ASSERT_EQUAL(m1*four, m1+m1+m1+m1);
CPPUNIT_ASSERT_EQUAL(two*m1, m1*two);
CPPUNIT_ASSERT_EQUAL(three*m1, m1*three);
CPPUNIT_ASSERT_EQUAL(four*m1, m1*four);
CPPUNIT_ASSERT_EQUAL(two*m1*two, m1*four);
CPPUNIT_ASSERT_EQUAL(big*m1*four, m1*four*big);
}
template<typename T>
void matrix_mult() {
const Matrix<T,2,3> m1(1, 2, 3,
4, 5, 6);
const Matrix<T,3,4> m2(1, 4, 7, 10,
2, 5, 8, 11,
3, 6, 9, 12);
const Matrix<T,2,4> m(m1*m2);
const Matrix<T,2,4> res(14, 32, 50, 68,
32, 77, 122, 167);
CPPUNIT_ASSERT_EQUAL(res, m);
}
template<typename T>
void transpose() {
const Matrix<T,2,3> m(1, 2, 3,
4, 5, 6);
const Matrix<T,3,2> res(1, 4,
2, 5,
3, 6);
CPPUNIT_ASSERT_EQUAL(res, m.t());
}
CPPUNIT_TEST_SUITE(TemplateMatrixTest);
CPPUNIT_TEST(initFromArray1<int>);
@@ -146,6 +206,36 @@ class TemplateMatrixTest: public CppUnit::TestFixture {
CPPUNIT_TEST(equality<unsigned long>);
CPPUNIT_TEST(equality<float>);
CPPUNIT_TEST(equality<double>);
CPPUNIT_TEST(operator_plus<int>);
CPPUNIT_TEST(operator_plus<long>);
CPPUNIT_TEST(operator_plus<unsigned>);
CPPUNIT_TEST(operator_plus<unsigned long>);
CPPUNIT_TEST(operator_plus<float>);
CPPUNIT_TEST(operator_plus<double>);
CPPUNIT_TEST(operator_minus<int>);
CPPUNIT_TEST(operator_minus<long>);
CPPUNIT_TEST(operator_minus<unsigned>);
CPPUNIT_TEST(operator_minus<unsigned long>);
CPPUNIT_TEST(operator_minus<float>);
CPPUNIT_TEST(operator_minus<double>);
CPPUNIT_TEST(scalar_mult<int>);
CPPUNIT_TEST(scalar_mult<long>);
CPPUNIT_TEST(scalar_mult<unsigned>);
CPPUNIT_TEST(scalar_mult<unsigned long>);
CPPUNIT_TEST(scalar_mult<float>);
CPPUNIT_TEST(scalar_mult<double>);
CPPUNIT_TEST(matrix_mult<int>);
CPPUNIT_TEST(matrix_mult<long>);
CPPUNIT_TEST(matrix_mult<unsigned>);
CPPUNIT_TEST(matrix_mult<unsigned long>);
CPPUNIT_TEST(matrix_mult<float>);
CPPUNIT_TEST(matrix_mult<double>);
CPPUNIT_TEST(transpose<int>);
CPPUNIT_TEST(transpose<long>);
CPPUNIT_TEST(transpose<unsigned>);
CPPUNIT_TEST(transpose<unsigned long>);
CPPUNIT_TEST(transpose<float>);
CPPUNIT_TEST(transpose<double>);
CPPUNIT_TEST_SUITE_END();
};
CPPUNIT_TEST_SUITE_REGISTRATION(TemplateMatrixTest);
@@ -241,6 +331,75 @@ class VariableMatrixTest: public CppUnit::TestFixture {
CPPUNIT_ASSERT(m1!=m3);
CPPUNIT_ASSERT(m1!=m4);
}
template<typename T>
void operator_plus() {
const Matrix<T> m1(2, 4,
1, 2, 3, 4,
5, 6, 7, 8);
const Matrix<T> m2(2, 4,
2, 4, 6, 8,
1, 3, 5, 7);
const Matrix<T> m(m1+m2);
const Matrix<T> res(2, 4,
3, 6, 9, 12,
6, 9, 12, 15);
CPPUNIT_ASSERT_EQUAL(res, m);
}
template<typename T>
void operator_minus() {
const Matrix<T> m1(2, 4,
1, 2, 3, 4,
5, 6, 7, 8);
const Matrix<T> m2(2, 4,
2, 4, 6, 8,
1, 3, 5, 7);
const Matrix<T> m(m1-m2);
const Matrix<T> res(2, 4,
-1, -2, -3, -4,
4, 3, 2, 1);
CPPUNIT_ASSERT_EQUAL(res, m);
}
template<typename T>
void scalar_mult() {
const Matrix<T> m1(2, 4,
1, 2, 3, 4,
5, 6, 7, 8);
T two(2), three(3), four(4), big(32);
CPPUNIT_ASSERT_EQUAL(m1*two, m1+m1);
CPPUNIT_ASSERT_EQUAL(m1*three, m1+m1+m1);
CPPUNIT_ASSERT_EQUAL(m1*four, m1+m1+m1+m1);
CPPUNIT_ASSERT_EQUAL(two*m1, m1*two);
CPPUNIT_ASSERT_EQUAL(three*m1, m1*three);
CPPUNIT_ASSERT_EQUAL(four*m1, m1*four);
CPPUNIT_ASSERT_EQUAL(two*m1*two, m1*four);
CPPUNIT_ASSERT_EQUAL(big*m1*four, m1*four*big);
}
template<typename T>
void matrix_mult() {
const Matrix<T> m1(2, 3,
1, 2, 3,
4, 5, 6);
const Matrix<T> m2(3, 4,
1, 4, 7, 10,
2, 5, 8, 11,
3, 6, 9, 12);
const Matrix<T> m(m1*m2);
const Matrix<T> res(2, 4,
14, 32, 50, 68,
32, 77, 122, 167);
CPPUNIT_ASSERT_EQUAL(res, m);
}
template<typename T>
void transpose() {
const Matrix<T> m(2, 3,
1, 2, 3,
4, 5, 6);
const Matrix<T> res(3, 2,
1, 4,
2, 5,
3, 6);
CPPUNIT_ASSERT_EQUAL(res, m.t());
}
CPPUNIT_TEST_SUITE(VariableMatrixTest);
CPPUNIT_TEST(initFromArray1<int>);
CPPUNIT_TEST(initFromArray1<long>);
@@ -272,6 +431,42 @@ class VariableMatrixTest: public CppUnit::TestFixture {
CPPUNIT_TEST(equality<unsigned long>);
CPPUNIT_TEST(equality<float>);
CPPUNIT_TEST(equality<double>);
CPPUNIT_TEST(operator_plus<int>);
CPPUNIT_TEST(operator_plus<long>);
CPPUNIT_TEST(operator_plus<unsigned>);
CPPUNIT_TEST(operator_plus<unsigned long>);
CPPUNIT_TEST(operator_plus<float>);
CPPUNIT_TEST(operator_plus<double>);
CPPUNIT_TEST(operator_minus<int>);
CPPUNIT_TEST(operator_minus<long>);
CPPUNIT_TEST(operator_minus<unsigned>);
CPPUNIT_TEST(operator_minus<unsigned long>);
CPPUNIT_TEST(operator_minus<float>);
CPPUNIT_TEST(operator_minus<double>);
CPPUNIT_TEST(scalar_mult<int>);
CPPUNIT_TEST(scalar_mult<long>);
CPPUNIT_TEST(scalar_mult<unsigned>);
CPPUNIT_TEST(scalar_mult<unsigned long>);
CPPUNIT_TEST(scalar_mult<float>);
CPPUNIT_TEST(scalar_mult<double>);
CPPUNIT_TEST(scalar_mult<int>);
CPPUNIT_TEST(scalar_mult<long>);
CPPUNIT_TEST(scalar_mult<unsigned>);
CPPUNIT_TEST(scalar_mult<unsigned long>);
CPPUNIT_TEST(scalar_mult<float>);
CPPUNIT_TEST(scalar_mult<double>);
CPPUNIT_TEST(matrix_mult<int>);
CPPUNIT_TEST(matrix_mult<long>);
CPPUNIT_TEST(matrix_mult<unsigned>);
CPPUNIT_TEST(matrix_mult<unsigned long>);
CPPUNIT_TEST(matrix_mult<float>);
CPPUNIT_TEST(matrix_mult<double>);
CPPUNIT_TEST(transpose<int>);
CPPUNIT_TEST(transpose<long>);
CPPUNIT_TEST(transpose<unsigned>);
CPPUNIT_TEST(transpose<unsigned long>);
CPPUNIT_TEST(transpose<float>);
CPPUNIT_TEST(transpose<double>);
CPPUNIT_TEST_SUITE_END();
};
CPPUNIT_TEST_SUITE_REGISTRATION(VariableMatrixTest);