diff --git a/libs/main/math/pimathmatrix.h b/libs/main/math/pimathmatrix.h index 0be4325c..80f1eaab 100644 --- a/libs/main/math/pimathmatrix.h +++ b/libs/main/math/pimathmatrix.h @@ -29,7 +29,6 @@ #include "pimathcomplex.h" - template inline bool _PIMathMatrixNullCompare(const T v) { static_assert(std::is_floating_point::value, "Type must be floating point"); @@ -37,11 +36,12 @@ inline bool _PIMathMatrixNullCompare(const T v) { } template<> -inline bool _PIMathMatrixNullCompare(const complexf v) { +inline bool _PIMathMatrixNullCompare(const complexf v) { return (abs(v) < float(1E-200)); } + template<> -inline bool _PIMathMatrixNullCompare(const complexd v) { +inline bool _PIMathMatrixNullCompare(const complexd v) { return (abs(v) < double(1E-200)); } @@ -56,6 +56,7 @@ inline bool _PIMathMatrixNullCompare(const complexd v) { #define PIMM_FOR_R(v) for (uint v = 0; v < Rows; ++v) #pragma pack(push, 1) + //! \brief A class that works with square matrix operations, the input data of which are columns, rows and the data type of the matrix template class PIP_EXPORT PIMathMatrixT { @@ -67,313 +68,391 @@ class PIP_EXPORT PIMathMatrixT { static_assert(Rows > 0, "Row count must be > 0"); static_assert(Cols > 0, "Column count must be > 0"); public: - PIMathMatrixT() {resize(Rows, Cols);} - PIMathMatrixT(const PIVector & val) {resize(Rows, Cols); int i = 0; PIMM_FOR_I_WB(r, c) m[r][c] = val[i++];} + PIMathMatrixT() { resize(Rows, Cols); } - /** - * @brief Сreates a matrix whose main diagonal is filled with ones and the remaining elements are zeros - * - * @return identitied matrix of type PIMathMatrixT - */ - static _CMatrix identity() {_CMatrix tm = _CMatrix(); PIMM_FOR_WB(r, c) tm.m[r][c] = (c == r ? Type(1) : Type(0)); return tm;} + PIMathMatrixT(const PIVector &val) { + resize(Rows, Cols); + int i = 0; + PIMM_FOR_I_WB(r, c) m[r][c] = val[i++]; + } - /** - * @brief Creates a matrix that is filled with elements - * - * @param v is a parameter the type and value of which is selected and later filled into the matrix - * @return filled matrix of type PIMathMatrixT - */ - static _CMatrix filled(const Type & v) {_CMatrix tm; PIMM_FOR_WB(r, c) tm.m[r][c] = v; return tm;} + /** + * @brief Сreates a matrix whose main diagonal is filled with ones and the remaining elements are zeros + * + * @return identitied matrix of type PIMathMatrixT + */ + static _CMatrix identity() { + _CMatrix tm = _CMatrix(); + PIMM_FOR_WB(r, c) tm.m[r][c] = (c == r ? Type(1) : Type(0)); + return tm; + } - /** - * @brief Rotation the matrix by an "angle". Works only with 2x2 matrix, - * else return default construction of PIMathMatrixT + /** + * @brief Creates a matrix that is filled with elements + * + * @param v is a parameter the type and value of which is selected and later filled into the matrix + * @return filled matrix of type PIMathMatrixT + */ + static _CMatrix filled(const Type &v) { + _CMatrix tm; + PIMM_FOR_WB(r, c) tm.m[r][c] = v; + return tm; + } + + /** + * @brief Rotation the matrix by an "angle". Works only with 2x2 matrix, + * else return default construction of PIMathMatrixT +* + * @param angle is the angle of rotation of the matrix + * @return rotated matrix + */ + static _CMatrix rotation(double angle) { return _CMatrix(); } + + /** + * @brief Rotation of the matrix by an "angle" along the X axis. Works only with 3x3 matrix, + * else return default construction of PIMathMatrixT + * + * @param angle is the angle of rotation of the matrix along the X axis + * @return rotated matrix + */ + static _CMatrix rotationX(double angle) { return _CMatrix(); } + + /** + * @brief Rotation of the matrix by an "angle" along the Y axis. Works only with 3x3 matrix, + * else return default construction of PIMathMatrixT + * + * @param angle is the angle of rotation of the matrix along the Y axis + * @return rotated matrix + */ + static _CMatrix rotationY(double angle) { return _CMatrix(); } + + /** + * @brief Rotation of the matrix by an "angle" along the Z axis. Works only with 3x3 matrix, + * else return default construction of PIMathMatrixT + * + * @param angle is the angle of rotation of the matrix along the Z axis + * @return rotated matrix + */ + static _CMatrix rotationZ(double angle) { return _CMatrix(); } + + /** + * @brief Scaling the matrix along the X axis by the value "factor". Works only with 3x3 and 2x2 matrix, + * else return default construction of PIMathMatrixT + * + * @param factor is the value of scaling by X axis + * @return rotated matrix + */ + static _CMatrix scaleX(double factor) { return _CMatrix(); } + + /** + * @brief Scaling the matrix along the Y axis by the value "factor". Works only with 3x3 and 2x2 matrix, + * else return default construction of PIMathMatrixT + * + * @param factor is the value of scaling by Y axis + * @return rotated matrix + */ + static _CMatrix scaleY(double factor) { return _CMatrix(); } + + /** + * @brief Scaling the matrix along the Z axis by the value "factor". Works only with 3x3 matrix, + * else return default construction of PIMathMatrixT + * + * @param factor is the value of scaling by Z axis + * @return rotated matrix + */ + static _CMatrix scaleZ(double factor) { return _CMatrix(); } + + /** + * @brief Method which returns number of columns in matrix + * + * @return type uint shows number of columns + */ + uint cols() const { return Cols; } + + /** + * @brief Method which returns number of rows in matrix * - * @param angle is the angle of rotation of the matrix - * @return rotated matrix - */ - static _CMatrix rotation(double angle) {return _CMatrix();} + * @return type uint shows number of rows + */ + uint rows() const { return Rows; } - /** - * @brief Rotation of the matrix by an "angle" along the X axis. Works only with 3x3 matrix, - * else return default construction of PIMathMatrixT - * - * @param angle is the angle of rotation of the matrix along the X axis - * @return rotated matrix - */ - static _CMatrix rotationX(double angle) {return _CMatrix();} + /** + * @brief Method which returns the selected column in PIMathVectorT format + * + * @param index is the number of the selected column + * @return column in PIMathVectorT format + */ + _CMCol col(uint index) { + _CMCol tv; + PIMM_FOR_R(i) tv[i] = m[i][index]; + return tv; + } - /** - * @brief Rotation of the matrix by an "angle" along the Y axis. Works only with 3x3 matrix, - * else return default construction of PIMathMatrixT - * - * @param angle is the angle of rotation of the matrix along the Y axis - * @return rotated matrix - */ - static _CMatrix rotationY(double angle) {return _CMatrix();} + /** + * @brief Method which returns the selected row in PIMathVectorT format + * + * @param index is the number of the selected row + * @return row in PIMathVectorT format + */ + _CMRow row(uint index) { + _CMRow tv; + PIMM_FOR_C(i) tv[i] = m[index][i]; + return tv; + } - /** - * @brief Rotation of the matrix by an "angle" along the Z axis. Works only with 3x3 matrix, - * else return default construction of PIMathMatrixT - * - * @param angle is the angle of rotation of the matrix along the Z axis - * @return rotated matrix - */ - static _CMatrix rotationZ(double angle) {return _CMatrix();} + /** + * @brief Set the selected column in matrix + * + * @param index is the number of the selected column + * @param v is a vector of the type _CMCol that needs to fill the column + * @return matrix type _CMatrix + */ + _CMatrix &setCol(uint index, const _CMCol &v) { + PIMM_FOR_R(i) m[i][index] = v[i]; + return *this; + } - /** - * @brief Scaling the matrix along the X axis by the value "factor". Works only with 3x3 and 2x2 matrix, - * else return default construction of PIMathMatrixT - * - * @param factor is the value of scaling by X axis - * @return rotated matrix - */ - static _CMatrix scaleX(double factor) {return _CMatrix();} + /** + * @brief Set the selected row in matrix + * + * @param index is the number of the selected row + * @param v is a vector of the type _CMCol that needs to fill the row + * @return matrix type _CMatrix + */ + _CMatrix &setRow(uint index, const _CMRow &v) { + PIMM_FOR_C(i) m[index][i] = v[i]; + return *this; + } - /** - * @brief Scaling the matrix along the Y axis by the value "factor". Works only with 3x3 and 2x2 matrix, - * else return default construction of PIMathMatrixT - * - * @param factor is the value of scaling by Y axis - * @return rotated matrix - */ - static _CMatrix scaleY(double factor) {return _CMatrix();} + /** + * @brief Method which changes selected rows in a matrix + * + * @param r0 is the number of the first selected row + * @param r1 is the number of the second selected row + * @return matrix type _CMatrix + */ + _CMatrix &swapRows(uint r0, uint r1) { + Type t; + PIMM_FOR_C(i) { + t = m[r0][i]; + m[r0][i] = m[r1][i]; + m[r1][i] = t; + } + return *this; + } - /** - * @brief Scaling the matrix along the Z axis by the value "factor". Works only with 3x3 matrix, - * else return default construction of PIMathMatrixT - * - * @param factor is the value of scaling by Z axis - * @return rotated matrix - */ - static _CMatrix scaleZ(double factor) {return _CMatrix();} + /** + * @brief Method which changes selected columns in a matrix + * + * @param c0 is the number of the first selected column + * @param c1 is the number of the second selected column + * @return matrix type _CMatrix + */ + _CMatrix &swapCols(uint c0, uint c1) { + Type t; + PIMM_FOR_R(i) { + t = m[i][c0]; + m[i][c0] = m[i][c1]; + m[i][c1] = t; + } + return *this; + } - /** - * @brief Method which returns number of columns in matrix - * - * @return type uint shows number of columns - */ - uint cols() const {return Cols;} + /** + * @brief Method which fills the matrix with selected value + * + * @param v is a parameter the type and value of which is selected and later filled into the matrix + * @return filled matrix type _CMatrix + */ + _CMatrix &fill(const Type &v) { + PIMM_FOR_WB(r, c) m[r][c] = v; + return *this; + } - /** - * @brief Method which returns number of rows in matrix - * - * @return type uint shows number of rows - */ - uint rows() const {return Rows;} + /** + * @brief Method which checks if matrix is square + * + * @return true if matrix is square, else false + */ + bool isSquare() const { return cols() == rows(); } - /** - * @brief Method which returns the selected column in PIMathVectorT format - * - * @param index is the number of the selected column - * @return column in PIMathVectorT format - */ - _CMCol col(uint index) {_CMCol tv; PIMM_FOR_R(i) tv[i] = m[i][index]; return tv;} + /** + * @brief Method which checks if main diagonal of matrix consists of ones and another elements are zeros + * + * @return true if matrix is identitied, else false + */ + bool isIdentity() const { + PIMM_FOR_WB(r, c) if ((c == r) ? m[r][c] != Type(1) : m[r][c] != Type(0)) return false; + return true; + } - /** - * @brief Method which returns the selected row in PIMathVectorT format - * - * @param index is the number of the selected row - * @return row in PIMathVectorT format - */ - _CMRow row(uint index) {_CMRow tv; PIMM_FOR_C(i) tv[i] = m[index][i]; return tv;} + /** + * @brief Method which checks if every elements of matrix are zeros + * + * @return true if matrix is null, else false + */ + bool isNull() const { + PIMM_FOR_WB(r, c) if (m[r][c] != Type(0)) return false; + return true; + } - /** - * @brief Set the selected column in matrix - * - * @param index is the number of the selected column - * @param v is a vector of the type _CMCol that needs to fill the column - * @return matrix type _CMatrix - */ - _CMatrix & setCol(uint index, const _CMCol & v) {PIMM_FOR_R(i) m[i][index] = v[i]; return *this;} + /** + * @brief Full access to elements reference by row "row" and col "col" + * + * @param row is a parameter that shows the row number of the matrix of the selected element + * @param col is a parameter that shows the column number of the matrix of the selected element + * @return reference to element of matrix by row "row" and col "col" + */ + Type &at(uint row, uint col) { return m[row][col]; } - /** - * @brief Set the selected row in matrix - * - * @param index is the number of the selected row - * @param v is a vector of the type _CMCol that needs to fill the row - * @return matrix type _CMatrix - */ - _CMatrix & setRow(uint index, const _CMRow & v) {PIMM_FOR_C(i) m[index][i] = v[i]; return *this;} + /** + * @brief Full access to element by row "row" and col "col" + * + * @param row is a parameter that shows the row number of the matrix of the selected element + * @param col is a parameter that shows the column number of the matrix of the selected element + * @return element of matrix by row "row" and col "col" + */ + Type at(uint row, uint col) const { return m[row][col]; } - /** - * @brief Method which changes selected rows in a matrix - * - * @param r0 is the number of the first selected row - * @param r1 is the number of the second selected row - * @return matrix type _CMatrix - */ - _CMatrix & swapRows(uint r0, uint r1) {Type t; PIMM_FOR_C(i) {t = m[r0][i]; m[r0][i] = m[r1][i]; m[r1][i] = t;} return *this;} + /** + * @brief Full access to the matrix row pointer + * + * @param row is a row of necessary matrix + * @return matrix row pointer + */ + Type *operator[](uint row) { return m[row]; } - /** - * @brief Method which changes selected columns in a matrix - * - * @param c0 is the number of the first selected column - * @param c1 is the number of the second selected column - * @return matrix type _CMatrix - */ - _CMatrix & swapCols(uint c0, uint c1) {Type t; PIMM_FOR_R(i) {t = m[i][c0]; m[i][c0] = m[i][c1]; m[i][c1] = t;} return *this;} + /** + * @brief Read-only access to the matrix row pointer + * + * @param row is a row of necessary matrix + * @return matrix row pointer + */ + const Type *operator[](uint row) const { return m[row]; } - /** - * @brief Method which fills the matrix with selected value - * - * @param v is a parameter the type and value of which is selected and later filled into the matrix - * @return filled matrix type _CMatrix - */ - _CMatrix & fill(const Type & v) {PIMM_FOR_WB(r, c) m[r][c] = v; return *this;} + /** + * @brief Matrix assignment to matrix "sm" + * + * @param sm matrix for the assigment + * @return matrix equal with sm + */ + _CMatrix &operator=(const _CMatrix &sm) { + memcpy(m, sm.m, sizeof(Type) * Cols * Rows); + return *this; + } - /** - * @brief Method which checks if matrix is square - * - * @return true if matrix is square, else false - */ - bool isSquare() const {return cols() == rows();} + /** + * @brief Compare with matrix "sm" + * + * @param sm matrix for the compare + * @return if matrices are equal true, else false + */ + bool operator==(const _CMatrix &sm) const { + PIMM_FOR_WB(r, c) if (m[r][c] != sm.m[r][c]) return false; + return true; + } - /** - * @brief Method which checks if main diagonal of matrix consists of ones and another elements are zeros - * - * @return true if matrix is identitied, else false - */ - bool isIdentity() const {PIMM_FOR_WB(r, c) if ((c == r) ? m[r][c] != Type(1) : m[r][c] != Type(0)) return false; return true;} + /** + * @brief Compare with matrix "sm" + * + * @param sm matrix for the compare + * @return if matrices are not equal true, else false + */ + bool operator!=(const _CMatrix &sm) const { return !(*this == sm); } - /** - * @brief Method which checks if every elements of matrix are zeros - * - * @return true if matrix is null, else false - */ - bool isNull() const {PIMM_FOR_WB(r, c) if (m[r][c] != Type(0)) return false; return true;} + /** + * @brief Addition assignment with matrix "sm" + * + * @param sm matrix for the addition assigment + */ + void operator+=(const _CMatrix &sm) { PIMM_FOR_WB(r, c) m[r][c] += sm.m[r][c]; } - /** - * @brief Full access to elements reference by row "row" and col "col" - * - * @param row is a parameter that shows the row number of the matrix of the selected element - * @param col is a parameter that shows the column number of the matrix of the selected element - * @return reference to element of matrix by row "row" and col "col" - */ - Type & at(uint row, uint col) {return m[row][col];} + /** + * @brief Subtraction assignment with matrix "sm" + * + * @param sm matrix for the subtraction assigment + */ + void operator-=(const _CMatrix &sm) { PIMM_FOR_WB(r, c) m[r][c] -= sm.m[r][c]; } - /** - * @brief Full access to element by row "row" and col "col" - * - * @param row is a parameter that shows the row number of the matrix of the selected element - * @param col is a parameter that shows the column number of the matrix of the selected element - * @return element of matrix by row "row" and col "col" - */ - Type at(uint row, uint col) const {return m[row][col];} + /** + * @brief Multiplication assignment with value "v" + * + * @param v value for the multiplication assigment + */ + void operator*=(const Type &v) { PIMM_FOR_WB(r, c) m[r][c] *= v; } - /** - * @brief Full access to the matrix row pointer - * - * @param row is a row of necessary matrix - * @return matrix row pointer - */ - Type * operator [](uint row) {return m[row];} + /** + * @brief Division assignment with value "v" + * + * @param v value for the division assigment + */ + void operator/=(const Type &v) { PIMM_FOR_WB(r, c) m[r][c] /= v; } - /** - * @brief Read-only access to the matrix row pointer - * - * @param row is a row of necessary matrix - * @return matrix row pointer - */ - const Type * operator [](uint row) const {return m[row];} + /** + * @brief Matrix substraction + * + * @return the result of matrix substraction + */ + _CMatrix operator-() const { + _CMatrix tm; + PIMM_FOR_WB(r, c) tm.m[r][c] = -m[r][c]; + return tm; + } - /** - * @brief Matrix assignment to matrix "sm" - * - * @param sm matrix for the assigment - * @return matrix equal with sm - */ - _CMatrix & operator =(const _CMatrix & sm) {memcpy(m, sm.m, sizeof(Type) * Cols * Rows); return *this;} + /** + * @brief Matrix addition + * + * @param sm is matrix term + * @return the result of matrix addition + */ + _CMatrix operator+(const _CMatrix &sm) const { + _CMatrix tm = _CMatrix(*this); + PIMM_FOR_WB(r, c) tm.m[r][c] += sm.m[r][c]; + return tm; + } - /** - * @brief Compare with matrix "sm" - * - * @param sm matrix for the compare - * @return if matrices are equal true, else false - */ - bool operator ==(const _CMatrix & sm) const {PIMM_FOR_WB(r, c) if (m[r][c] != sm.m[r][c]) return false; return true;} + /** + * @brief Matrix substraction + * + * @param sm is matrix subtractor + * @return the result of matrix substraction + */ + _CMatrix operator-(const _CMatrix &sm) const { + _CMatrix tm = _CMatrix(*this); + PIMM_FOR_WB(r, c) tm.m[r][c] -= sm.m[r][c]; + return tm; + } - /** - * @brief Compare with matrix "sm" - * - * @param sm matrix for the compare - * @return if matrices are not equal true, else false - */ - bool operator !=(const _CMatrix & sm) const {return !(*this == sm);} + /** + * @brief Matrix multiplication + * + * @param v is value factor + * @return the result of matrix multiplication + */ + _CMatrix operator*(const Type &v) const { + _CMatrix tm = _CMatrix(*this); + PIMM_FOR_WB(r, c) tm.m[r][c] *= v; + return tm; + } - /** - * @brief Addition assignment with matrix "sm" - * - * @param sm matrix for the addition assigment - */ - void operator +=(const _CMatrix & sm) {PIMM_FOR_WB(r, c) m[r][c] += sm.m[r][c];} + /** + * @brief Matrix division + * + * @param v is value divider + * @return the result of matrix division + */ + _CMatrix operator/(const Type &v) const { + _CMatrix tm = _CMatrix(*this); + PIMM_FOR_WB(r, c) tm.m[r][c] /= v; + return tm; + } - /** - * @brief Subtraction assignment with matrix "sm" - * - * @param sm matrix for the subtraction assigment - */ - void operator -=(const _CMatrix & sm) {PIMM_FOR_WB(r, c) m[r][c] -= sm.m[r][c];} - - /** - * @brief Multiplication assignment with value "v" - * - * @param v value for the multiplication assigment - */ - void operator *=(const Type & v) {PIMM_FOR_WB(r, c) m[r][c] *= v;} - - /** - * @brief Division assignment with value "v" - * - * @param v value for the division assigment - */ - void operator /=(const Type & v) {PIMM_FOR_WB(r, c) m[r][c] /= v;} - - /** - * @brief Matrix substraction - * - * @return the result of matrix substraction - */ - _CMatrix operator -() const {_CMatrix tm; PIMM_FOR_WB(r, c) tm.m[r][c] = -m[r][c]; return tm;} - - /** - * @brief Matrix addition - * - * @param sm is matrix term - * @return the result of matrix addition - */ - _CMatrix operator +(const _CMatrix & sm) const {_CMatrix tm = _CMatrix(*this); PIMM_FOR_WB(r, c) tm.m[r][c] += sm.m[r][c]; return tm;} - - /** - * @brief Matrix substraction - * - * @param sm is matrix subtractor - * @return the result of matrix substraction - */ - _CMatrix operator -(const _CMatrix & sm) const {_CMatrix tm = _CMatrix(*this); PIMM_FOR_WB(r, c) tm.m[r][c] -= sm.m[r][c]; return tm;} - - /** - * @brief Matrix multiplication - * - * @param v is value factor - * @return the result of matrix multiplication - */ - _CMatrix operator *(const Type & v) const {_CMatrix tm = _CMatrix(*this); PIMM_FOR_WB(r, c) tm.m[r][c] *= v; return tm;} - - /** - * @brief Matrix division - * - * @param v is value divider - * @return the result of matrix division - */ - _CMatrix operator /(const Type & v) const {_CMatrix tm = _CMatrix(*this); PIMM_FOR_WB(r, c) tm.m[r][c] /= v; return tm;} - - /** - * @brief Determinant of the matrix is ​​calculated - * - * @return matrix determinant - */ - Type determinant(bool * ok = 0) const { + /** + * @brief Determinant of the matrix is ​​calculated + * + * @return matrix determinant + */ + Type determinant(bool *ok = 0) const { _CMatrix m(*this); bool k; Type ret = Type(0); @@ -388,12 +467,12 @@ public: return ret; } - /** - * @brief Transforming matrix to upper triangular - * - * @return transformed upper triangular matrix - */ - _CMatrix & toUpperTriangular(bool * ok = 0) { + /** + * @brief Transforming matrix to upper triangular + * + * @return transformed upper triangular matrix + */ + _CMatrix &toUpperTriangular(bool *ok = 0) { if (Cols != Rows) { if (ok != 0) *ok = false; return *this; @@ -419,7 +498,7 @@ public: for (uint k = i; k < Cols; ++k) smat.m[k][j] -= mul * smat.m[k][i]; } if (i < Cols - 1) { - if (fabs(smat.m[i+1][i+1]) < Type(1E-200)) { + if (fabs(smat.m[i + 1][i + 1]) < Type(1E-200)) { if (ok != 0) *ok = false; return *this; } @@ -430,12 +509,12 @@ public: return *this; } - /** - * @brief Matrix inversion operation - * - * @return inverted matrix - */ - _CMatrix & invert(bool * ok = 0) { + /** + * @brief Matrix inversion operation + * + * @return inverted matrix + */ + _CMatrix &invert(bool *ok = 0) { static_assert(Cols == Rows, "Only square matrix invertable"); _CMatrix mtmp = _CMatrix::identity(), smat(*this); bool ndet; @@ -462,7 +541,7 @@ public: for (uint k = 0; k < Cols; ++k) mtmp.m[k][j] -= mul * mtmp.m[k][i]; } if (i < Cols - 1) { - if (fabs(smat.m[i+1][i+1]) < Type(1E-200)) { + if (fabs(smat.m[i + 1][i + 1]) < Type(1E-200)) { if (ok != 0) *ok = false; return *this; } @@ -483,39 +562,125 @@ public: return *this; } - /** - * @brief Matrix inversion operation - * - * @return inverted matrix - */ - _CMatrix inverted(bool * ok = 0) const {_CMatrix tm(*this); tm.invert(ok); return tm;} + /** + * @brief Matrix inversion operation + * + * @return inverted matrix + */ + _CMatrix inverted(bool *ok = 0) const { + _CMatrix tm(*this); + tm.invert(ok); + return tm; + } - /** - * @brief Matrix transposition operation - * - * @return transposed matrix - */ - _CMatrixI transposed() const {_CMatrixI tm; PIMM_FOR_WB(r, c) tm[c][r] = m[r][c]; return tm;} + /** + * @brief Matrix transposition operation + * + * @return transposed matrix + */ + _CMatrixI transposed() const { + _CMatrixI tm; + PIMM_FOR_WB(r, c) tm[c][r] = m[r][c]; + return tm; + } private: - void resize(uint rows_, uint cols_, const Type & new_value = Type()) {r_ = rows_; c_ = cols_; PIMM_FOR_WB(r, c) m[r][c] = new_value;} + void resize(uint rows_, uint cols_, const Type &new_value = Type()) { + r_ = rows_; + c_ = cols_; + PIMM_FOR_WB(r, c) m[r][c] = new_value; + } + int c_, r_; Type m[Rows][Cols]; }; + #pragma pack(pop) -template<> inline PIMathMatrixT<2u, 2u> PIMathMatrixT<2u, 2u>::rotation(double angle) {double c = cos(angle), s = sin(angle); PIMathMatrixT<2u, 2u> tm; tm[0][0] = tm[1][1] = c; tm[0][1] = -s; tm[1][0] = s; return tm;} -template<> inline PIMathMatrixT<2u, 2u> PIMathMatrixT<2u, 2u>::scaleX(double factor) {PIMathMatrixT<2u, 2u> tm; tm[0][0] = factor; tm[1][1] = 1.; return tm;} -template<> inline PIMathMatrixT<2u, 2u> PIMathMatrixT<2u, 2u>::scaleY(double factor) {PIMathMatrixT<2u, 2u> tm; tm[0][0] = 1.; tm[1][1] = factor; return tm;} +template<> +inline PIMathMatrixT<2u, 2u> PIMathMatrixT<2u, 2u>::rotation(double angle) { + double c = cos(angle), s = sin(angle); + PIMathMatrixT<2u, 2u> tm; + tm[0][0] = tm[1][1] = c; + tm[0][1] = -s; + tm[1][0] = s; + return tm; +} -template<> inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::rotationX(double angle) {double c = cos(angle), s = sin(angle); PIMathMatrixT<3u, 3u> tm; tm[0][0] = 1.; tm[1][1] = tm[2][2] = c; tm[2][1] = s; tm[1][2] = -s; return tm;} -template<> inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::rotationY(double angle) {double c = cos(angle), s = sin(angle); PIMathMatrixT<3u, 3u> tm; tm[1][1] = 1.; tm[0][0] = tm[2][2] = c; tm[2][0] = -s; tm[0][2] = s; return tm;} -template<> inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::rotationZ(double angle) {double c = cos(angle), s = sin(angle); PIMathMatrixT<3u, 3u> tm; tm[2][2] = 1.; tm[0][0] = tm[1][1] = c; tm[1][0] = s; tm[0][1] = -s; return tm;} -template<> inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::scaleX(double factor) {PIMathMatrixT<3u, 3u> tm; tm[1][1] = tm[2][2] = 1.; tm[0][0] = factor; return tm;} -template<> inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::scaleY(double factor) {PIMathMatrixT<3u, 3u> tm; tm[0][0] = tm[2][2] = 1.; tm[1][1] = factor; return tm;} -template<> inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::scaleZ(double factor) {PIMathMatrixT<3u, 3u> tm; tm[0][0] = tm[1][1] = 1.; tm[2][2] = factor; return tm;} +template<> +inline PIMathMatrixT<2u, 2u> PIMathMatrixT<2u, 2u>::scaleX(double factor) { + PIMathMatrixT<2u, 2u> tm; + tm[0][0] = factor; + tm[1][1] = 1.; + return tm; +} + +template<> +inline PIMathMatrixT<2u, 2u> PIMathMatrixT<2u, 2u>::scaleY(double factor) { + PIMathMatrixT<2u, 2u> tm; + tm[0][0] = 1.; + tm[1][1] = factor; + return tm; +} + +template<> +inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::rotationX(double angle) { + double c = cos(angle), s = sin(angle); + PIMathMatrixT<3u, 3u> tm; + tm[0][0] = 1.; + tm[1][1] = tm[2][2] = c; + tm[2][1] = s; + tm[1][2] = -s; + return tm; +} + +template<> +inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::rotationY(double angle) { + double c = cos(angle), s = sin(angle); + PIMathMatrixT<3u, 3u> tm; + tm[1][1] = 1.; + tm[0][0] = tm[2][2] = c; + tm[2][0] = -s; + tm[0][2] = s; + return tm; +} + +template<> +inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::rotationZ(double angle) { + double c = cos(angle), s = sin(angle); + PIMathMatrixT<3u, 3u> tm; + tm[2][2] = 1.; + tm[0][0] = tm[1][1] = c; + tm[1][0] = s; + tm[0][1] = -s; + return tm; +} + +template<> +inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::scaleX(double factor) { + PIMathMatrixT<3u, 3u> tm; + tm[1][1] = tm[2][2] = 1.; + tm[0][0] = factor; + return tm; +} + +template<> +inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::scaleY(double factor) { + PIMathMatrixT<3u, 3u> tm; + tm[0][0] = tm[2][2] = 1.; + tm[1][1] = factor; + return tm; +} + +template<> +inline PIMathMatrixT<3u, 3u> PIMathMatrixT<3u, 3u>::scaleZ(double factor) { + PIMathMatrixT<3u, 3u> tm; + tm[0][0] = tm[1][1] = 1.; + tm[2][2] = factor; + return tm; +} #ifdef PIP_STD_IOSTREAM template @@ -523,12 +688,19 @@ inline std::ostream & operator <<(std::ostream & s, const PIMathMatrixT -inline PICout operator <<(PICout s, const PIMathMatrixT & m) {s << "{"; PIMM_FOR_I(r, c) s << m[r][c]; if (c < Cols - 1 || r < Rows - 1) s << ", ";} if (r < Rows - 1) s << PICoutManipulators::NewLine << " ";} s << "}"; return s;} +inline PICout operator<<(PICout s, const PIMathMatrixT &m) { + s << "{"; + PIMM_FOR_I(r, c) s << m[r][c]; + if (c < Cols - 1 || r < Rows - 1) s << ", "; } + if (r < Rows - 1) s << PICoutManipulators::NewLine << " "; } + s << "}"; + return s; +} /// Multiply matrices {Rows0 x CR} on {CR x Cols1}, result is {Rows0 x Cols1} template -inline PIMathMatrixT operator *(const PIMathMatrixT & fm, - const PIMathMatrixT & sm) { +inline PIMathMatrixT operator*(const PIMathMatrixT &fm, + const PIMathMatrixT &sm) { PIMathMatrixT tm; Type t; for (uint j = 0; j < Rows0; ++j) { @@ -544,8 +716,8 @@ inline PIMathMatrixT operator *(const PIMathMatrixT -inline PIMathVectorT operator *(const PIMathMatrixT & fm, - const PIMathVectorT & sv) { +inline PIMathVectorT operator*(const PIMathMatrixT &fm, + const PIMathVectorT &sv) { PIMathVectorT tv; Type t; for (uint j = 0; j < Rows; ++j) { @@ -559,8 +731,8 @@ inline PIMathVectorT operator *(const PIMathMatrixT -inline PIMathVectorT operator *(const PIMathVectorT & sv, - const PIMathMatrixT & fm) { +inline PIMathVectorT operator*(const PIMathVectorT &sv, + const PIMathMatrixT &fm) { PIMathVectorT tv; Type t; for (uint j = 0; j < Cols; ++j) { @@ -574,7 +746,7 @@ inline PIMathVectorT operator *(const PIMathVectorT & sv /// Multiply value(T) on matrix {Rows x Cols}, result is vector {Rows} template -inline PIMathMatrixT operator *(const Type & x, const PIMathMatrixT & v) { +inline PIMathMatrixT operator*(const Type &x, const PIMathMatrixT &v) { return v * x; } @@ -612,209 +784,277 @@ class PIMathMatrix; //! \brief A class that works with matrix operations, the input data of which is the data type of the matrix template class PIP_EXPORT PIMathMatrix : public PIVector2D { - typedef PIVector2D _V2D; + typedef PIVector2D _V2D; typedef PIMathMatrix _CMatrix; typedef PIMathVector _CMCol; public: - PIMathMatrix(const uint cols = 0, const uint rows = 0, const Type & f = Type()) {_V2D::resize(rows, cols, f);} - PIMathMatrix(const uint cols, const uint rows, const PIVector & val) {_V2D::resize(rows, cols); int i=0; PIMM_FOR_I(c, r) _V2D::element(r, c) = val[i++];} - PIMathMatrix(const PIVector > & val) {if(!val.isEmpty()) {_V2D::resize(val.size(), val[0].size()); PIMM_FOR_I(c, r) _V2D::element(r, c) = val[r][c];}} - PIMathMatrix(const PIVector2D & val) {if(!val.isEmpty()) {_V2D::resize(val.rows(), val.cols()); PIMM_FOR_I(c, r) _V2D::element(r, c) = val.element(r, c);}} + PIMathMatrix(const uint cols = 0, const uint rows = 0, const Type &f = Type()) { _V2D::resize(rows, cols, f); } - /** - * @brief Сreates a matrix whose main diagonal is filled with ones and the remaining elements are zeros - * - * @param cols is number of matrix column uint type - * @param rows is number of matrix row uint type - * @return identitied matrix of type PIMathMatrix - */ - static _CMatrix identity(const uint cols, const uint rows) {_CMatrix tm(cols, rows); for (uint r = 0; r < rows; ++r) for (uint c = 0; c < cols; ++c) tm.element(r, c) = (c == r ? Type(1) : Type(0)); return tm;} + PIMathMatrix(const uint cols, const uint rows, const PIVector &val) { + _V2D::resize(rows, cols); + int i = 0; + PIMM_FOR_I(c, r) _V2D::element(r, c) = val[i++]; + } - /** - * @brief Сreates a matrix whose row equal to vector - * - * @param val is the vector type PIMathVector - * @return matrix identitied by vector - */ - static _CMatrix matrixRow(const PIMathVector & val) {return _CMatrix(val.size(), 1, val.toVector());} + PIMathMatrix(const PIVector > &val) { + if (!val.isEmpty()) { + _V2D::resize(val.size(), val[0].size()); + PIMM_FOR_I(c, r) _V2D::element(r, c) = val[r][c]; + } + } - /** - * @brief Сreates a matrix whose column equal to vector - * - * @param val is the vector type PIMathVector - * @return matrix identitied by vector - */ - static _CMatrix matrixCol(const PIMathVector & val) {return _CMatrix(1, val.size(), val.toVector());} + PIMathMatrix(const PIVector2D &val) { + if (!val.isEmpty()) { + _V2D::resize(val.rows(), val.cols()); + PIMM_FOR_I(c, r) _V2D::element(r, c) = val.element(r, c); + } + } - /** - * @brief Set the selected column in matrix - * - * @param index is the number of the selected column - * @param v is a vector of the type _CMCol that needs to fill the column - * @return matrix type _CMatrix - */ - _CMatrix & setCol(uint index, const _CMCol & v) {PIMM_FOR_R(i) _V2D::element(i, index) = v[i]; return *this;} + /** + * @brief Creates a matrix whose main diagonal is filled with ones and the remaining elements are zeros + * + * @param cols is number of matrix column uint type + * @param rows is number of matrix row uint type + * @return identity matrix of type PIMathMatrix + */ + static _CMatrix identity(const uint cols, const uint rows) { + _CMatrix tm(cols, rows); + for (uint r = 0; r < rows; ++r) for (uint c = 0; c < cols; ++c) tm.element(r, c) = (c == r ? Type(1) : Type(0)); + return tm; + } - /** - * @brief Set the selected row in matrix - * - * @param index is the number of the selected row - * @param v is a vector of the type _CMCol that needs to fill the row - * @return matrix type _CMatrix - */ - _CMatrix & setRow(uint index, const _CMCol & v) {PIMM_FOR_C(i) _V2D::element(index, i) = v[i]; return *this;} + /** + * @brief Creates a matrix whose row equal to vector + * + * @param val is the vector type PIMathVector + * @return identity matrix by vector + */ + static _CMatrix matrixRow(const PIMathVector &val) { return _CMatrix(val.size(), 1, val.toVector()); } - /** - * @brief Method which changes selected rows in a matrix - * - * @param r0 is the number of the first selected row - * @param r1 is the number of the second selected row - * @return matrix type _CMatrix - */ - _CMatrix & swapCols(uint r0, uint r1) {PIMM_FOR_C(i) {piSwap(_V2D::element(i, r0), _V2D::element(i, r1));} return *this;} + /** + * @brief Creates a matrix whose column equal to vector + * + * @param val is the vector type PIMathVector + * @return identity matrix by vector + */ + static _CMatrix matrixCol(const PIMathVector &val) { return _CMatrix(1, val.size(), val.toVector()); } - /** - * @brief Method which changes selected columns in a matrix - * - * @param c0 is the number of the first selected column - * @param c1 is the number of the second selected column - * @return matrix type _CMatrix - */ - _CMatrix & swapRows(uint c0, uint c1) {PIMM_FOR_R(i) {piSwap(_V2D::element(c0, i), _V2D::element(c1, i));} return *this;} + /** + * @brief Set the selected column in matrix + * + * @param index is the number of the selected column + * @param v is a vector of the type _CMCol that needs to fill the column + * @return matrix type _CMatrix + */ + _CMatrix &setCol(uint index, const _CMCol &v) { + PIMM_FOR_R(i) _V2D::element(i, index) = v[i]; + return *this; + } - /** - * @brief Method which fills the matrix with selected value - * - * @param v is a parameter the type and value of which is selected and later filled into the matrix - * @return filled matrix type _CMatrix - */ - _CMatrix & fill(const Type & v) {PIMM_FOR_A(i) _V2D::mat[i] = v; return *this;} + /** + * @brief Set the selected row in matrix + * + * @param index is the number of the selected row + * @param v is a vector of the type _CMCol that needs to fill the row + * @return matrix type _CMatrix + */ + _CMatrix &setRow(uint index, const _CMCol &v) { + PIMM_FOR_C(i) _V2D::element(index, i) = v[i]; + return *this; + } - /** - * @brief Method which checks if matrix is square - * - * @return true if matrix is square, else false - */ - bool isSquare() const {return _V2D::cols_ == _V2D::rows_;} + /** + * @brief Method which changes selected rows in a matrix + * + * @param r0 is the number of the first selected row + * @param r1 is the number of the second selected row + * @return matrix type _CMatrix + */ + _CMatrix &swapCols(uint r0, uint r1) { + PIMM_FOR_C(i) { piSwap(_V2D::element(i, r0), _V2D::element(i, r1)); } + return *this; + } - /** - * @brief Method which checks if main diagonal of matrix consists of ones and another elements are zeros - * - * @return true if matrix is identitied, else false - */ - bool isIdentity() const {PIMM_FOR(c, r) if ((c == r) ? _V2D::element(r, c) != Type(1) : _V2D::element(r, c) != Type(0)) return false; return true;} + /** + * @brief Method which changes selected columns in a matrix + * + * @param c0 is the number of the first selected column + * @param c1 is the number of the second selected column + * @return matrix type _CMatrix + */ + _CMatrix &swapRows(uint c0, uint c1) { + PIMM_FOR_R(i) { piSwap(_V2D::element(c0, i), _V2D::element(c1, i)); } + return *this; + } - /** - * @brief Method which checks if every elements of matrix are zeros - * - * @return true if matrix is null, else false - */ - bool isNull() const {PIMM_FOR_A(i) if (_V2D::mat[i] != Type(0)) return false; return true;} + /** + * @brief Method which fills the matrix with selected value + * + * @param v is a parameter the type and value of which is selected and later filled into the matrix + * @return filled matrix type _CMatrix + */ + _CMatrix &fill(const Type &v) { + PIMM_FOR_A(i) _V2D::mat[i] = v; + return *this; + } - /** - * @brief Method which checks if matrix is empty - * - * @return true if matrix is valid, else false - */ - bool isValid() const {return !PIVector2D::isEmpty();} + /** + * @brief Method which checks if matrix is square + * + * @return true if matrix is square, else false + */ + bool isSquare() const { return _V2D::cols_ == _V2D::rows_; } - /** - * @brief Matrix assignment to matrix "v" - * - * @param v matrix for the assigment - * @return matrix equal with v - */ - _CMatrix & operator =(const PIVector > & v) {*this = _CMatrix(v); return *this;} + /** + * @brief Method which checks if main diagonal of matrix consists of ones and another elements are zeros + * + * @return true if matrix is identitied, else false + */ + bool isIdentity() const { + PIMM_FOR(c, r) if ((c == r) ? _V2D::element(r, c) != Type(1) : _V2D::element(r, c) != Type(0))return false; + return true; + } - /** - * @brief Compare with matrix "sm" - * - * @param sm matrix for the compare - * @return if matrices are equal true, else false - */ - bool operator ==(const _CMatrix & sm) const {PIMM_FOR_A(i) if (_V2D::mat[i] != sm.mat[i]) return false; return true;} + /** + * @brief Method which checks if every elements of matrix are zeros + * + * @return true if matrix is null, else false + */ + bool isNull() const { + PIMM_FOR_A(i) if (_V2D::mat[i] != Type(0)) return false; + return true; + } - /** - * @brief Compare with matrix "sm" - * - * @param sm matrix for the compare - * @return if matrices are not equal true, else false - */ - bool operator !=(const _CMatrix & sm) const {return !(*this == sm);} + /** + * @brief Method which checks if matrix is empty + * + * @return true if matrix is valid, else false + */ + bool isValid() const { return !PIVector2D::isEmpty(); } - /** - * @brief Addition assignment with matrix "sm" - * - * @param sm matrix for the addition assigment - */ - void operator +=(const _CMatrix & sm) {PIMM_FOR_A(i) _V2D::mat[i] += sm.mat[i];} + /** + * @brief Matrix assignment to matrix "v" + * + * @param v matrix for the assigment + * @return matrix equal with v + */ + _CMatrix &operator=(const PIVector > &v) { + *this = _CMatrix(v); + return *this; + } - /** - * @brief Subtraction assignment with matrix "sm" - * - * @param sm matrix for the subtraction assigment - */ - void operator -=(const _CMatrix & sm) {PIMM_FOR_A(i) _V2D::mat[i] -= sm.mat[i];} + /** + * @brief Compare with matrix "sm" + * + * @param sm matrix for the compare + * @return if matrices are equal true, else false + */ + bool operator==(const _CMatrix &sm) const { + PIMM_FOR_A(i) if (_V2D::mat[i] != sm.mat[i]) return false; + return true; + } - /** - * @brief Multiplication assignment with value "v" - * - * @param v value for the multiplication assigment - */ - void operator *=(const Type & v) {PIMM_FOR_A(i) _V2D::mat[i] *= v;} + /** + * @brief Compare with matrix "sm" + * + * @param sm matrix for the compare + * @return if matrices are not equal true, else false + */ + bool operator!=(const _CMatrix &sm) const { return !(*this == sm); } - /** - * @brief Division assignment with value "v" - * - * @param v value for the division assigment - */ - void operator /=(const Type & v) {PIMM_FOR_A(i) _V2D::mat[i] /= v;} + /** + * @brief Addition assignment with matrix "sm" + * + * @param sm matrix for the addition assigment + */ + void operator+=(const _CMatrix &sm) { PIMM_FOR_A(i) _V2D::mat[i] += sm.mat[i]; } - /** - * @brief Matrix substraction - * - * @return the result of matrix substraction - */ - _CMatrix operator -() const {_CMatrix tm(*this); PIMM_FOR_A(i) tm.mat[i] = -_V2D::mat[i]; return tm;} + /** + * @brief Subtraction assignment with matrix "sm" + * + * @param sm matrix for the subtraction assigment + */ + void operator-=(const _CMatrix &sm) { PIMM_FOR_A(i) _V2D::mat[i] -= sm.mat[i]; } - /** - * @brief Matrix addition - * - * @param sm is matrix term - * @return the result of matrix addition - */ - _CMatrix operator +(const _CMatrix & sm) const {_CMatrix tm(*this); PIMM_FOR_A(i) tm.mat[i] += sm.mat[i]; return tm;} + /** + * @brief Multiplication assignment with value "v" + * + * @param v value for the multiplication assigment + */ + void operator*=(const Type &v) { PIMM_FOR_A(i) _V2D::mat[i] *= v; } - /** - * @brief Matrix substraction - * - * @param sm is matrix subtractor - * @return the result of matrix substraction - */ - _CMatrix operator -(const _CMatrix & sm) const {_CMatrix tm(*this); PIMM_FOR_A(i) tm.mat[i] -= sm.mat[i]; return tm;} + /** + * @brief Division assignment with value "v" + * + * @param v value for the division assigment + */ + void operator/=(const Type &v) { PIMM_FOR_A(i) _V2D::mat[i] /= v; } - /** - * @brief Matrix multiplication - * - * @param v is value factor - * @return the result of matrix multiplication - */ - _CMatrix operator *(const Type & v) const {_CMatrix tm(*this); PIMM_FOR_A(i) tm.mat[i] *= v; return tm;} + /** + * @brief Matrix substraction + * + * @return the result of matrix substraction + */ + _CMatrix operator-() const { + _CMatrix tm(*this); + PIMM_FOR_A(i) tm.mat[i] = -_V2D::mat[i]; + return tm; + } - /** - * @brief Matrix division - * - * @param v is value divider - * @return the result of matrix division - */ - _CMatrix operator /(const Type & v) const {_CMatrix tm(*this); PIMM_FOR_A(i) tm.mat[i] /= v; return tm;} + /** + * @brief Matrix addition + * + * @param sm is matrix term + * @return the result of matrix addition + */ + _CMatrix operator+(const _CMatrix &sm) const { + _CMatrix tm(*this); + PIMM_FOR_A(i) tm.mat[i] += sm.mat[i]; + return tm; + } - /** - * @brief Determinant of the matrix is ​​calculated - * - * @return matrix determinant - */ - Type determinant(bool * ok = 0) const { + /** + * @brief Matrix subtraction + * + * @param sm is matrix subtractor + * @return the result of matrix subtraction + */ + _CMatrix operator-(const _CMatrix &sm) const { + _CMatrix tm(*this); + PIMM_FOR_A(i) tm.mat[i] -= sm.mat[i]; + return tm; + } + + /** + * @brief Matrix multiplication + * + * @param v is value factor + * @return the result of matrix multiplication + */ + _CMatrix operator*(const Type &v) const { + _CMatrix tm(*this); + PIMM_FOR_A(i) tm.mat[i] *= v; + return tm; + } + + /** + * @brief Matrix division + * + * @param v is value divider + * @return the result of matrix division + */ + _CMatrix operator/(const Type &v) const { + _CMatrix tm(*this); + PIMM_FOR_A(i) tm.mat[i] /= v; + return tm; + } + + /** + * @brief Determinant of the matrix is ​​calculated + * + * @return matrix determinant + */ + Type determinant(bool *ok = 0) const { _CMatrix m(*this); bool k; Type ret = Type(0); @@ -829,12 +1069,12 @@ public: return ret; } - /** - * @brief Trace of the matrix is calculated - * - * @return matrix trace - */ - Type trace(bool * ok = 0) const { + /** + * @brief Trace of the matrix is calculated + * + * @return matrix trace + */ + Type trace(bool *ok = 0) const { Type ret = Type(0); if (!isSquare()) { if (ok != 0) *ok = false; @@ -847,12 +1087,12 @@ public: return ret; } - /** - * @brief Transforming matrix to upper triangular - * - * @return transformed upper triangular matrix - */ - _CMatrix & toUpperTriangular(bool * ok = 0) { + /** + * @brief Transforming matrix to upper triangular + * + * @return transformed upper triangular matrix + */ + _CMatrix &toUpperTriangular(bool *ok = 0) { if (!isSquare()) { if (ok != 0) *ok = false; return *this; @@ -878,7 +1118,7 @@ public: for (uint k = i; k < _V2D::cols_; ++k) smat.element(k, j) -= mul * smat.element(k, i); } if (i < _V2D::cols_ - 1) { - if (_PIMathMatrixNullCompare(smat.element(i+1, i+1))) { + if (_PIMathMatrixNullCompare(smat.element(i + 1, i + 1))) { if (ok != 0) *ok = false; return *this; } @@ -889,12 +1129,12 @@ public: return *this; } - /** - * @brief Matrix inversion operation - * - * @return inverted matrix - */ - _CMatrix & invert(bool * ok = 0, _CMCol * sv = 0) { + /** + * @brief Matrix inversion operation + * + * @return inverted matrix + */ + _CMatrix &invert(bool *ok = 0, _CMCol *sv = 0) { if (!isSquare()) { if (ok != 0) *ok = false; return *this; @@ -926,7 +1166,7 @@ public: if (sv != 0) (*sv)[j] -= mul * (*sv)[i]; } if (i < _V2D::cols_ - 1) { - if (_PIMathMatrixNullCompare(smat.element(i+1, i+1))) { + if (_PIMathMatrixNullCompare(smat.element(i + 1, i + 1))) { if (ok != 0) *ok = false; return *this; } @@ -949,19 +1189,27 @@ public: return *this; } - /** - * @brief Matrix inversion operation - * - * @return inverted matrix - */ - _CMatrix inverted(bool * ok = 0) const {_CMatrix tm(*this); tm.invert(ok); return tm;} + /** + * @brief Matrix inversion operation + * + * @return inverted matrix + */ + _CMatrix inverted(bool *ok = 0) const { + _CMatrix tm(*this); + tm.invert(ok); + return tm; + } - /** - * @brief Matrix transposition operation - * - * @return transposed matrix - */ - _CMatrix transposed() const {_CMatrix tm(_V2D::rows_, _V2D::cols_); PIMM_FOR(c, r) tm.element(c, r) = _V2D::element(r, c); return tm;} + /** + * @brief Matrix transposition operation + * + * @return transposed matrix + */ + _CMatrix transposed() const { + _CMatrix tm(_V2D::rows_, _V2D::cols_); + PIMM_FOR(c, r) tm.element(c, r) = _V2D::element(r, c); + return tm; + } }; @@ -971,18 +1219,36 @@ inline std::ostream & operator <<(std::ostream & s, const PIMathMatrix & m #endif template -inline PICout operator <<(PICout s, const PIMathMatrix & m) {s << "Matrix{"; for (uint r = 0; r < m.rows(); ++r) { for (uint c = 0; c < m.cols(); ++c) { s << m.element(r, c); if (c < m.cols() - 1 || r < m.rows() - 1) s << ", ";} if (r < m.rows() - 1) s << PICoutManipulators::NewLine << " ";} s << "}"; return s;} +inline PICout operator<<(PICout s, const PIMathMatrix &m) { + s << "Matrix{"; + for (uint r = 0; r < m.rows(); ++r) { + for (uint c = 0; c < m.cols(); ++c) { + s << m.element(r, c); + if (c < m.cols() - 1 || r < m.rows() - 1) s << ", "; + } + if (r < m.rows() - 1) s << PICoutManipulators::NewLine << " "; + } + s << "}"; + return s; +} template -inline PIByteArray & operator <<(PIByteArray & s, const PIMathMatrix & v) {s << (const PIVector2D &)v; return s;} +inline PIByteArray &operator<<(PIByteArray &s, const PIMathMatrix &v) { + s << (const PIVector2D &) v; + return s; +} + template -inline PIByteArray & operator >>(PIByteArray & s, PIMathMatrix & v) {s >> (PIVector2D &)v; return s;} +inline PIByteArray &operator>>(PIByteArray &s, PIMathMatrix &v) { + s >> (PIVector2D &) v; + return s; +} /// Multiply matrices {CR x Rows0} on {Cols1 x CR}, result is {Cols1 x Rows0} template -inline PIMathMatrix operator *(const PIMathMatrix & fm, - const PIMathMatrix & sm) { +inline PIMathMatrix operator*(const PIMathMatrix &fm, + const PIMathMatrix &sm) { uint cr = fm.cols(), rows0 = fm.rows(), cols1 = sm.cols(); PIMathMatrix tm(cols1, rows0); if (fm.cols() != sm.rows()) return tm; @@ -1000,8 +1266,8 @@ inline PIMathMatrix operator *(const PIMathMatrix & fm, /// Multiply matrix {Cols x Rows} on vector {Cols}, result is vector {Rows} template -inline PIMathVector operator *(const PIMathMatrix & fm, - const PIMathVector & sv) { +inline PIMathVector operator*(const PIMathMatrix &fm, + const PIMathVector &sv) { uint c = fm.cols(), r = fm.rows(); PIMathVector tv(r); if (c != sv.size()) return tv; @@ -1018,8 +1284,8 @@ inline PIMathVector operator *(const PIMathMatrix & fm, /// Multiply vector {Rows} on matrix {Rows x Cols}, result is vector {Cols} template -inline PIMathVector operator *(const PIMathVector & sv, - const PIMathMatrix & fm) { +inline PIMathVector operator*(const PIMathVector &sv, + const PIMathMatrix &fm) { uint c = fm.cols(), r = fm.rows(); PIMathVector tv(c); Type t; @@ -1034,7 +1300,7 @@ inline PIMathVector operator *(const PIMathVector & sv, /// Multiply value(T) on matrix {Rows x Cols}, result is vector {Rows} template -inline PIMathMatrix operator *(const Type & x, const PIMathMatrix & v) { +inline PIMathMatrix operator*(const Type &x, const PIMathMatrix &v) { return v * x; } @@ -1042,9 +1308,11 @@ typedef PIMathMatrix PIMathMatrixi; typedef PIMathMatrix PIMathMatrixd; template -PIMathMatrix > hermitian(const PIMathMatrix > & m) { +PIMathMatrix > hermitian(const PIMathMatrix > &m) { PIMathMatrix > ret(m); - for (uint r = 0; r < ret.rows(); ++r) for (uint c = 0; c < ret.cols(); ++c) ret.element(r, c).imag(-(ret.element(r, c).imag())); + for (uint r = 0; r < ret.rows(); ++r) + for (uint c = 0; c < ret.cols(); ++c) + ret.element(r, c).imag(-(ret.element(r, c).imag())); return ret.transposed(); }