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

remove redundancy, collect common functionality in base class

Browse Source
master
Marc Wäckerlin 8 years ago
parent 8f37bef3e9
commit 714df5dbc0
6 changed files with 146 additions and 198 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      COPYING
  2. 2
      INSTALL
  3. 2
      ax_init_standard_project.m4
  4. 2
      configure.ac
  5. 301
      src/matrix.hxx
  6. 7
      test/basic.cxx

2
COPYING
Unescape View File

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

2
INSTALL
Unescape View File

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

2
ax_init_standard_project.m4
Unescape View File

@ -273,7 +273,7 @@ EOF
AC_DEFUN([AX_USE_CXX], [
m4_include(ax_cxx_compile_stdcxx_11.m4)
AC_LANG(C++)
AX_CXX_COMPILE_STDCXX_14(noext, optional)
AX_CXX_COMPILE_STDCXX_11(noext, optional)
AC_PROG_CXX
AC_PROG_CPP

2
configure.ac
Unescape View File

@ -32,7 +32,7 @@ AX_BUILD_EXAMPLES
#AX_CHECK_QT([QT], [QtCore QtGui QtNetwork], [QtWidgets])
#AX_REQUIRE_QT([QT], [QtCore QtGui QtNetwork], [QtWidgets])
#AX_QT_NO_KEYWORDS
AX_REQUIRE_STDCXX_14
AX_REQUIRE_STDCXX_11
# create output
AC_OUTPUT

301
src/matrix.hxx
Unescape View File

@ -10,15 +10,15 @@
#include <cassert>
#include <type_traits>
template<typename TYPE, size_t TROWS=0, size_t TCOLUMNS=0> class Matrix {
template<typename TYPE, typename ARRAY=TYPE*> class MatrixBase {
//........................................................const.variables
//..............................................................constants
public:
static const size_t ROWS = TROWS;
static const size_t COLUMNS = TCOLUMNS;
static const size_t SIZE = ROWS*COLUMNS;
static const size_t MEM_SIZE = ROWS*COLUMNS*sizeof(TYPE);
const size_t ROWS;
const size_t COLUMNS;
const size_t SIZE;
const size_t MEM_SIZE;
//...............................................................typedefs
public:
@ -36,12 +36,14 @@ template<typename TYPE, size_t TROWS=0, size_t TCOLUMNS=0> class Matrix {
class RowVector {
public:
TYPE& operator[](size_t column) {
assert(column<_m.COLUMNS);
return _v[column];
}
protected:
friend class Matrix;
friend class MatrixBase;
RowVector() = delete; // forbidden
RowVector(TYPE c[COLUMNS]): _v(c) {}
RowVector(const MatrixBase& m, TYPE c[]): _m(m), _v(c) {}
const MatrixBase& _m;
TYPE *_v;
};
@ -49,12 +51,14 @@ template<typename TYPE, size_t TROWS=0, size_t TCOLUMNS=0> class Matrix {
class ConstRowVector {
public:
const TYPE& operator[](size_t column) const {
assert(column<_m.COLUMNS);
return _v[column];
}
protected:
friend class Matrix;
friend class MatrixBase;
ConstRowVector() = delete; // forbidden
ConstRowVector(const TYPE c[COLUMNS]): _v(c) {}
ConstRowVector(const MatrixBase& m, const TYPE c[]): _m(m), _v(c) {}
const MatrixBase& _m;
const TYPE *_v;
};
@ -66,17 +70,16 @@ template<typename TYPE, size_t TROWS=0, size_t TCOLUMNS=0> class Matrix {
/// @name construction
///{
Matrix() {
memset(_c, 0, MEM_SIZE);
MatrixBase(size_t rows, size_t columns):
ROWS(rows), COLUMNS(columns),
SIZE(ROWS*COLUMNS), MEM_SIZE(SIZE*sizeof(TYPE)) {
}
template<typename ...ARGS>
Matrix(ARGS...t): _c{std::forward<TYPE>(t)...} {
static_assert(sizeof...(t)==SIZE, "variadic matrix initialisation requires correct array size");
}
Matrix(const Matrix& o) {
memcpy(_c, o._c, MEM_SIZE);
MatrixBase(size_t rows, size_t columns, ARGS...t):
ROWS(rows), COLUMNS(columns),
SIZE(ROWS*COLUMNS), MEM_SIZE(SIZE*sizeof(TYPE)),
_c{std::forward<TYPE>(t)...} {
}
///}
@ -84,47 +87,38 @@ template<typename TYPE, size_t TROWS=0, size_t TCOLUMNS=0> class Matrix {
/// @name operators
///{
Matrix& operator=(TYPE oc[ROWS][COLUMNS]) {
MatrixBase& operator=(TYPE oc[]) {
assert(sizeof(oc)==MEM_SIZE);
memcpy(_c, oc, MEM_SIZE);
return *this;
}
Matrix& operator=(const Matrix& o) {
MatrixBase& operator=(const MatrixBase& o) {
assert_check(o);
memcpy(_c, o._c, MEM_SIZE);
return *this;
}
bool operator==(const Matrix& o) const {
bool operator==(const MatrixBase& o) const {
if (!check(o)) return false;
TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
while (to>(TYPE*)(_c)) if (*--to != *--from) return false;
return true;
}
bool operator!=(const Matrix& o) const {
bool operator!=(const MatrixBase& o) const {
return !operator==(o);
}
Matrix<TYPE, COLUMNS, ROWS> T() const {
Matrix<TYPE, COLUMNS, ROWS> res;
for (size_t row(0); row<ROWS; ++row)
for (size_t column(0); column<COLUMNS; ++column)
res(column, row) = operator()(row, column);
return res;
}
Matrix operator-() const {
Matrix res;
for (TYPE *to((TYPE*)(res._c)+SIZE); to>(TYPE*)(_c); --to) *to = -*to;
return res;
}
Matrix& operator+=(const Matrix& o) {
MatrixBase& operator+=(const MatrixBase& o) {
assert_check(o);
TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
while (to>(TYPE*)(_c)) *--to += *--from;
return *this;
}
Matrix& operator-=(const Matrix& o) {
MatrixBase& operator-=(const MatrixBase& o) {
assert_check(o);
TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
while (to>(TYPE*)(_c)) *--to -= *--from;
return *this;
@ -138,88 +132,106 @@ template<typename TYPE, size_t TROWS=0, size_t TCOLUMNS=0> class Matrix {
TYPE& operator()(size_t row, size_t column) {
assert(row<ROWS);
assert(column<COLUMNS);
return _c[row][column];
return *((TYPE*)_c+row*COLUMNS+column);
}
const TYPE& operator()(size_t row, size_t column) const {
assert(row<ROWS);
assert(column<COLUMNS);
return _c[row][column];
return *((TYPE*)_c+row*COLUMNS+column);
}
RowVector operator[](size_t row) {
assert(row<ROWS);
return RowVector(_c[row]);
return RowVector(*this, (TYPE*)_c+row*COLUMNS);
}
const ConstRowVector operator[](size_t row) const {
assert(row<ROWS);
return ConstRowVector(_c[row]);
return ConstRowVector(*this, (TYPE*)_c+row*COLUMNS);
}
///}
//................................................................methods
protected:
virtual void assert_check(const MatrixBase& o) const {}
virtual bool check(const MatrixBase& o) const {
return true;
}
//..............................................................variables
protected:
TYPE _c[ROWS][COLUMNS];
ARRAY _c;
};
template<typename TYPE> class Matrix<TYPE, 0, 0> {
//==============================================================================
//..............................................................constants
public:
const size_t ROWS;
const size_t COLUMNS;
const size_t SIZE;
const size_t MEM_SIZE;
template<typename TYPE, size_t TROWS=0, size_t TCOLUMNS=0> class Matrix:
public MatrixBase<TYPE, TYPE[TROWS][TCOLUMNS]> {
//...............................................................typedefs
private:
typedef MatrixBase<TYPE, TYPE[TROWS][TCOLUMNS]> Parent;
//................................................................methods
public:
/// @name Auxiliary Classes
/// @name construction
///{
/// Return One Row as Vector, internally used for element access
/** Only used to access values:
Matrix(): Parent(TROWS, TCOLUMNS) {}
@code
Matrix<int,4,4> m;
m[2][2] = 1;
@endcode */
class RowVector {
public:
TYPE& operator[](size_t column) {
assert(column<_m.COLUMNS);
return _v[column];
template<typename ...ARGS>
Matrix(ARGS...t): Parent(TROWS, TCOLUMNS, t...) {
static_assert(sizeof...(t)==TROWS*TCOLUMNS,
"wrong array size");
}
protected:
friend class Matrix;
RowVector() = delete; // forbidden
RowVector(const Matrix& m, TYPE c[]): _m(m), _v(c) {}
const Matrix& _m;
TYPE *_v;
};
/// Same as RowVector, but in a constant environment.
class ConstRowVector {
public:
const TYPE& operator[](size_t column) const {
assert(column<_m.COLUMNS);
return _v[column];
Matrix(const Matrix& o): Matrix() {
memcpy(Parent::_c, o._c, Parent::MEM_SIZE);
}
protected:
friend class Matrix;
ConstRowVector() = delete; // forbidden
ConstRowVector(const Matrix& m, const TYPE c[]): _m(m), _v(c) {}
const Matrix& _m;
const TYPE *_v;
};
///}
/// @name operators
///{
Matrix& operator=(TYPE oc[TROWS][TCOLUMNS]) {
memcpy(Parent::_c, oc, Parent::MEM_SIZE);
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)
*to = -*to;
return res;
}
};
//==============================================================================
template<typename TYPE> class Matrix<TYPE, 0, 0>: public MatrixBase<TYPE> {
//...............................................................typedefs
private:
typedef MatrixBase<TYPE> Parent;
//................................................................methods
public:
@ -227,23 +239,20 @@ template<typename TYPE> class Matrix<TYPE, 0, 0> {
///{
Matrix(size_t rows, size_t columns):
ROWS(rows),
COLUMNS(columns),
SIZE(rows*columns),
MEM_SIZE(rows*columns*sizeof(TYPE)),
_c(new TYPE[rows*columns]) {
memset(_c, 0, MEM_SIZE);
Parent(rows, columns) {
Parent::_c = new TYPE[rows*columns];
memset(Parent::_c, 0, Parent::MEM_SIZE);
}
template<typename ...ARGS>
Matrix(size_t rows, size_t columns, ARGS...t):
Matrix(rows, columns) {
assert(sizeof...(t)==SIZE);
copy_args(_c, t...);
assert(sizeof...(t)==Parent::SIZE);
copy_args(Parent::_c, t...);
}
Matrix(const Matrix& o): Matrix(o.ROWS, o.COLUMNS) {
memcpy(_c, o._c, MEM_SIZE);
Matrix(const Matrix& o): Matrix(o.ROWS, o.Parent::COLUMNS) {
memcpy(Parent::_c, o.Parent::_c, Parent::MEM_SIZE);
}
///}
@ -251,8 +260,8 @@ template<typename TYPE> class Matrix<TYPE, 0, 0> {
/// @name destruction
///{
~Matrix() {
delete[] _c;
virtual ~Matrix() {
delete[] Parent::_c;
}
///}
@ -260,98 +269,47 @@ template<typename TYPE> class Matrix<TYPE, 0, 0> {
/// @name operators
///{
Matrix& operator=(TYPE oc[]) {
assert(sizeof(oc)==MEM_SIZE);
memcpy(_c, oc, MEM_SIZE);
return *this;
}
Matrix& operator=(const Matrix& o) {
if (o.ROWS!=ROWS&&o.COLUMNS!=COLUMNS) {
delete[] _c;
ROWS = o.ROWS;
COLUMNS = o.COLUMNS;
SIZE = o.SIZE;
MEM_SIZE = o.MEM_SIZE;
_c = new TYPE[SIZE];
if (o.ROWS!=Parent::ROWS&&o.COLUMNS!=Parent::COLUMNS) {
delete[] Parent::_c;
Parent::ROWS = o.ROWS;
Parent::COLUMNS = o.COLUMNS;
Parent::SIZE = o.SIZE;
Parent::MEM_SIZE = o.MEM_SIZE;
Parent::_c = new TYPE[Parent::SIZE];
}
memcpy(_c, o._c, MEM_SIZE);
return *this;
}
bool operator==(const Matrix& o) const {
if (o.ROWS!=ROWS||o.COLUMNS!=COLUMNS) return false;
TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
while (to>(TYPE*)(_c)) if (*--to != *--from) return false;
return true;
}
bool operator!=(const Matrix& o) const {
return !operator==(o);
return Parent::operator=(o);
}
Matrix T() const {
Matrix res(COLUMNS, ROWS);
for (size_t row(0); row<ROWS; ++row)
for (size_t column(0); column<COLUMNS; ++column)
res(column, row) = operator()(row, column);
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);
return res;
}
Matrix operator-() const {
Matrix res(COLUMNS, ROWS);
for (TYPE *to((TYPE*)(res._c)+SIZE); to>(TYPE*)(_c); --to) *to = -*to;
Matrix res(Parent::COLUMNS, Parent::ROWS);
for (TYPE *to((TYPE*)(res._c)+Parent::SIZE); to>(TYPE*)(Parent::_c); --to)
*to = -*to;
return res;
}
Matrix& operator+=(const Matrix& o) {
assert(o.ROWS==ROWS);
assert(o.COLUMNS==COLUMNS);
TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
while (to>(TYPE*)(_c)) *--to += *--from;
return *this;
}
Matrix& operator-=(const Matrix& o) {
assert(o.ROWS==ROWS);
assert(o.COLUMNS==COLUMNS);
TYPE *to((TYPE*)(_c)+SIZE), *from((TYPE*)(o._c)+SIZE);
while (to>(TYPE*)(_c)) *--to -= *--from;
return *this;
}
///}
/// @name element access
///{
TYPE& operator()(size_t row, size_t column) {
assert(row<ROWS);
assert(column<COLUMNS);
return *(_c+row*COLUMNS+column);
}
const TYPE& operator()(size_t row, size_t column) const {
assert(row<ROWS);
assert(column<COLUMNS);
return *(_c+row*COLUMNS+column);
}
//................................................................methods
protected:
RowVector operator[](size_t row) {
assert(row<ROWS);
return RowVector(*this, _c+row*COLUMNS);
virtual void assert_check(const Matrix& o) const {
assert(o.ROWS==Parent::ROWS);
assert(o.COLUMNS==Parent::COLUMNS);
}
const ConstRowVector operator[](size_t row) const {
assert(row<ROWS);
return ConstRowVector(*this, _c+row*COLUMNS);
virtual bool check(const Matrix& o) const {
return o.ROWS==Parent::ROWS && o.COLUMNS==Parent::COLUMNS;
}
///}
//................................................................methods
protected:
void copy_args(TYPE*) {}
template<typename ...ARGS>
void copy_args(TYPE* to, TYPE t1, ARGS...t) {
@ -359,13 +317,10 @@ template<typename TYPE> class Matrix<TYPE, 0, 0> {
copy_args(++to, t...);
}
//..............................................................variables
protected:
TYPE* _c;
};
//==============================================================================
template<typename TYPE, size_t ROWS, size_t COLUMNS>
Matrix<TYPE, ROWS, COLUMNS> operator+(const Matrix<TYPE, ROWS, COLUMNS>& m1, const Matrix<TYPE, ROWS, COLUMNS>& m2) {
Matrix<TYPE, ROWS, COLUMNS> res(m1);

7
test/basic.cxx
Unescape View File

@ -105,13 +105,6 @@ class TemplateMatrixTest: public CppUnit::TestFixture {
5, 6, 7, 9);
Matrix<T,2,4> m4(9, 2, 3, 4,
5, 6, 7, 8);
std::cout<<std::endl
<<"m1 = "<<std::endl
<<m1<<std::endl
<<"m2 = "<<std::endl
<<m2<<std::endl
<<"m3 = "<<std::endl
<<m3<<std::endl;
CPPUNIT_ASSERT(m1==m2);
CPPUNIT_ASSERT(m1!=m3);
CPPUNIT_ASSERT(m1!=m4);

Write Preview
Loading…
Cancel
Save