From 241149ba6e85ad225d9c355e2033f0595e29a10d Mon Sep 17 00:00:00 2001 From: Nao Pross Date: Thu, 10 Oct 2019 01:18:49 +0200 Subject: Update access model for operator| The operator | can access the matrix either by directly changing the values (by reference, mm::mutate(M)) or by creating first a a copy of the matrix (mm::clone(M)). ToDo: The order of destruction of the mutate object is not yet well defined, and therefore it is not yet deterministic enough to work with expressions like (pseudocode) matrix m = a * b * (a | mm::alg::invert) because operator| (defaults to mutate), should not but could, change the value of a before the product a * b gets evaluated. --- include/mm/mmmatrix.hpp | 120 +++++++++++++++++++++++++++++++++---------- include/mm/view.hpp | 134 ++++++++++++++++++++++++++++++++---------------- 2 files changed, 183 insertions(+), 71 deletions(-) (limited to 'include') diff --git a/include/mm/mmmatrix.hpp b/include/mm/mmmatrix.hpp index d653d72..0f8833e 100644 --- a/include/mm/mmmatrix.hpp +++ b/include/mm/mmmatrix.hpp @@ -11,13 +11,19 @@ */ #pragma once +#include "mm/debug.hpp" + #include +#include #include #include #include #include +/* + * Forward declarations + */ namespace mm { using index = std::size_t; @@ -28,47 +34,97 @@ namespace mm { template class matrix; + template + class vector; + template class square_matrix; template class diagonal_matrix; + } /* - * Matrix class, no access methods + * Matrix Classes */ namespace mm { template - class basic_matrix + struct basic_matrix { public: using type = T; + static constexpr std::size_t rows = Rows; + static constexpr std::size_t cols = Cols; + + template - friend class mm::matrix; + friend class mm::basic_matrix; + + virtual ~basic_matrix() {}; // copy from another matrix - template - matrix(const basic_matrix& other); + // template + // basic_matrix(const basic_matrix& other) { + // static_assert(ORows <= Rows); + // static_assert(OCols <= Cols); + + // for (index row = 0; row < Rows; row++) + // for (index col = 0; col < Cols; col++) + // at(row, col) = other.at(row, col); + // } virtual T& at(index row, index col) = 0; - virtual const T& at(index row, index col) const = 0; + virtual const T& at(index row, index col) const = 0; + + // constexpr std::size_t rows() { return Rows; } + // constexpr std::size_t cols() { return Cols; } + + protected: + basic_matrix() { + npdebug("default construtor"); + } + + basic_matrix(const basic_matrix& other) { + npdebug("copy constructor"); + } + + basic_matrix(basic_matrix&& other) { + npdebug("move constructor"); + } }; + /* Specializations */ template - struct matrix : public basic_matrix + struct matrix : public basic_matrix { public: + // aggregate initialization + template::value + >::type... + > + matrix(E ...e) : m_data({{std::forward(e)...}}) {} + + matrix(const matrix& o) + : basic_matrix(o), m_data(o.m_data) {} + + matrix(matrix&& o) + : basic_matrix(std::move(o)), m_data(std::move(o.m_data)) {} + + virtual ~matrix() = default; + virtual T& at(index row, index col) override { return m_data[row * Cols + col]; } virtual const T& at(index row, index col) const override { - return at(row, col); + return m_data[row * Cols + col]; } private: @@ -80,20 +136,8 @@ namespace mm { struct vector : public matrix {}; template - struct square_matrix : public basic_matrix - { - public: - virtual T& at(index row, index col) override { - return m_data[row * N + col]; - } - - virtual const T& at(index row, index col) const override { - return at(row, col); - } - - private: - std::array m_data; - }; + struct square_matrix : public matrix + {}; template struct identity_matrix : public basic_matrix @@ -104,17 +148,17 @@ namespace mm { } private: - T m_useless; - T& at(index row, index col) { return m_useless; } - } + // not allowed + T& at(index row, index col) { return static_cast(0); } + }; template struct diagonal_matrix : public basic_matrix { public: T& at(index row, index col) override { - n_null_element = static_cast(0); - return (row != col) ? m_data[row] : n_null_element; + m_null_element = static_cast(0); + return (row != col) ? m_data[row] : m_null_element; } const T& at(index row, index col) const override { @@ -124,5 +168,27 @@ namespace mm { private: T m_null_element; std::array m_data; + }; +} + +/* + * Matrix Opertors + */ + +namespace mm { +} + + +template +std::ostream& operator<<(std::ostream& os, const mm::basic_matrix& m) { + for (mm::index row = 0; row < Rows; row++) { + os << "[ "; + for (mm::index col = 0; col < (Cols -1); col++) { + os << std::setw(NumW) << m.at(row, col) << ", "; + } + os << std::setw(NumW) << m.at(row, (Cols -1)) << " ]\n"; } + + return os; } + \ No newline at end of file diff --git a/include/mm/view.hpp b/include/mm/view.hpp index 910c16a..e701a78 100644 --- a/include/mm/view.hpp +++ b/include/mm/view.hpp @@ -1,66 +1,112 @@ #pragma once -#include +#include "mm/mmmatrix.hpp" +#include +#include +#include +#include -namespace mm::alg { - template < - template typename Matrix, - typename T, std::size_t Rows, std::size_t Cols - > - struct visitor - { - using type = T; +namespace mm { + + namespace algorithm { + // does nothing + struct visit + { + visit() = default; - // copy constructible - visitor(const visitor& other) = default; + template + void operator()(Matrix& m) {} + }; - T& operator()(const Matrix& m, index row, index col) { - return m.at(row, col); - } + struct transpose : public visit + { + /// does not work with non-square matrices + template + void operator()(Matrix& m) { + static_assert(Matrix::rows == Matrix::cols); + // naiive impl + for (index r = 0; r < m.rows / 2; r++) + for (index c = 0; c < m.cols; c++) + if (c != r) + std::swap(m.at(r, c), m.at(c, r)); + } + }; - const T& operator()(const Matrix& m, index row, index col) { - return operator()(m, row, col); - } - }; + /// algorithm aliases + using tr = transpose; + } + + /// namespace alias + namespace alg = algorithm; - template < - template typename Matrix, - typename T, std::size_t Rows, std::size_t Cols - > - struct transpose : public visitor + template + struct clone { - T& operator()(const Matrix m, index row, index col) { - // assert(col < Rows) - // assert(row < Cols) - return m.at(col, row); + Matrix matrix; + + explicit clone(Matrix&& m) : matrix(m) {} + explicit clone(const Matrix& m) : matrix(m) {} + + operator Matrix() { + return std::move(matrix); } }; -} -namespace mm { - template < - template typename Matrix, - typename T, std::size_t Rows, std::size_t Cols - > - struct view + template + struct mutate { - Matrix& m; - // std::stack> visitors; - std::unique_ptr visitor; + Matrix& matrix; + std::tuple visitors; + + explicit mutate(Matrix& m) : matrix(m) {} + + template + explicit mutate(Matrix& m, std::tuple&& t, Alg&& v) + : matrix(m) + { + /// append the new operator + visitors = std::tuple_cat(t, std::make_tuple(v)); + } + + ~mutate() { + visit(); + } - T& at(index row, index col) { - return visitor(m, row, col); + void visit() { + std::apply([this](auto&&... v) { + (v(matrix),...); + }, visitors); } - view& operator|=(const alg::visitor& other) { - // visitors.push(std::move(std::make_unique(other))); - visitor = std::make_unique(other); + operator Matrix() { + return std::move(matrix); } }; - view operator|(const view& left, const alg::visitor& right) { - return left |= right; + template + clone operator|(clone&& cl, Alg&& v) { + static_assert(std::is_convertible::value); + /// apply alg operator + v(cl.matrix); + /// forward to next alg + return clone(std::move(cl)); + } + + template + mutate operator|(mutate&& mut, Alg&& v) { + static_assert(std::is_convertible::value); + /// append alg to the visitors tuple + return mutate( + mut.matrix, + std::move(mut.visitors), + v + ); + } + + template + mutate operator|(Matrix& m, Alg&& v) { + return mutate(m) | std::move(v); } } -- cgit v1.2.1