diff --git a/libs/main/math/pimathmatrix.h b/libs/main/math/pimathmatrix.h
index 9a767dd5..fe1c6a66 100644
--- a/libs/main/math/pimathmatrix.h
+++ b/libs/main/math/pimathmatrix.h
@@ -85,19 +85,19 @@ class PIP_EXPORT PIMathMatrixT {
 	static_assert(Rows > 0, "Row count must be > 0");
 	static_assert(Cols > 0, "Column count must be > 0");
 public:
-    /**
-    * @brief Constructor that calls the private resize method
-    *
-    * @return identitied matrix of type PIMathMatrixT
-    */
+	/**
+	* @brief Constructor that calls the private resize method
+	*
+	* @return identitied matrix of type PIMathMatrixT
+	*/
 	PIMathMatrixT() { resize(Rows, Cols); }
 
-    /**
-    * @brief Constructor that calls the private resize method
-    *
-    * @param val is the PIVector with which the matrix is ​​filled
-    * @return identitied matrix of type PIMathMatrixT
-    */
+	/**
+	* @brief Constructor that calls the private resize method
+	*
+	* @param val is the PIVector with which the matrix is ​​filled
+	* @return identitied matrix of type PIMathMatrixT
+	*/
 	PIMathMatrixT(const PIVector<Type> &val) {
 		resize(Rows, Cols);
 		int i = 0;
@@ -105,10 +105,10 @@ public:
 	}
 
 	/**
-    * @brief Сreates a matrix whose main diagonal is filled with ones and the remaining elements are zeros
-    *
-    * @return identity matrix of type PIMathMatrixT
-    */
+	* @brief Сreates a matrix whose main diagonal is filled with ones and the remaining elements are zeros
+	*
+	* @return identity 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));
@@ -116,11 +116,11 @@ public:
 	}
 
 	/**
-    * @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
-    */
+	* @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;
@@ -128,73 +128,73 @@ public:
 	}
 
 	/**
-    * @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
-    */
+	* @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
-    */
+	* @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
-    */
+	* @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
-    */
+	* @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
-    */
+	* @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
-    */
+	* @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
-    */
+	* @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
-    */
+	* @brief Method which returns number of columns in matrix
+	*
+	* @return type uint shows number of columns
+	*/
 	uint cols() const { return Cols; }
 
 	/**
@@ -205,12 +205,12 @@ public:
 	uint rows() const { return Rows; }
 
 	/**
-    * @brief Method which returns the selected column in PIMathVectorT format.
-    * If you enter an index out of the border of the matrix will be SEGFAULT
-    *
-    * @param index is the number of the selected column
-    * @return column in PIMathVectorT format
-    */
+	* @brief Method which returns the selected column in PIMathVectorT format.
+	* If you enter an index out of the border of the matrix will be SEGFAULT
+	*
+	* @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];
@@ -218,12 +218,12 @@ public:
 	}
 
 	/**
-    * @brief Method which returns the selected row in PIMathVectorT format
-    * If you enter an index out of the border of the matrix will be SEGFAULT
-    *
-    * @param index is the number of the selected row
-    * @return row in PIMathVectorT format
-    */
+	* @brief Method which returns the selected row in PIMathVectorT format
+	* If you enter an index out of the border of the matrix will be SEGFAULT
+	*
+	* @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];
@@ -231,39 +231,39 @@ public:
 	}
 
 	/**
-    * @brief Set the selected column in matrix.
-    * If you enter an index out of the border of the matrix will be SEGFAULT
-    *
-    * @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
-    */
+	* @brief Set the selected column in matrix.
+	* If you enter an index out of the border of the matrix will be SEGFAULT
+	*
+	* @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 Set the selected row in matrix
-    * If you enter an index out of the border of the matrix will be SEGFAULT
-    *
-    * @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
-    */
+	* @brief Set the selected row in matrix
+	* If you enter an index out of the border of the matrix will be SEGFAULT
+	*
+	* @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 Method which changes selected rows in a matrix.
-    * If you enter an index out of the border of the matrix will be SEGFAULT
-    *
-    * @param r0 is the number of the first selected row
-    * @param r1 is the number of the second selected row
-    * @return matrix type _CMatrix
-    */
+	* @brief Method which changes selected rows in a matrix.
+	* If you enter an index out of the border of the matrix will be SEGFAULT
+	*
+	* @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) {
@@ -275,13 +275,13 @@ public:
 	}
 
 	/**
-    * @brief Method which changes selected columns in a matrix.
-    * If you enter an index out of the border of the matrix will be SEGFAULT
-    *
-    * @param c0 is the number of the first selected column
-    * @param c1 is the number of the second selected column
-    * @return matrix type _CMatrix
-    */
+	* @brief Method which changes selected columns in a matrix.
+	* If you enter an index out of the border of the matrix will be SEGFAULT
+	*
+	* @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) {
@@ -293,142 +293,142 @@ public:
 	}
 
 	/**
-    * @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
-    */
+	* @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 checks if matrix is square
-    *
-    * @return true if matrix is square, else false
-    */
+	* @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 checks if main diagonal of matrix consists of ones and another elements are zeros
-    *
-    * @return true if matrix is identitied, else false
-    */
+	* @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 checks if every elements of matrix are zeros
-    *
-    * @return true if matrix is null, else false
-    */
+	* @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 Full access to elements reference by row "row" and col "col".
-    * If you enter an index out of the border of the matrix will be SEGFAULT
-    *
-    * @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"
-    */
+	* @brief Full access to elements reference by row "row" and col "col".
+	* If you enter an index out of the border of the matrix will be SEGFAULT
+	*
+	* @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 Full access to element by row "row" and col "col".
-    * If you enter an index out of the border of the matrix will be SEGFAULT
-    *
-    * @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"
-    */
+	* @brief Full access to element by row "row" and col "col".
+	* If you enter an index out of the border of the matrix will be SEGFAULT
+	*
+	* @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 Full access to the matrix row pointer. If you enter an index out of the border of the matrix will be SEGFAULT
-    *
-    * @param row is a row of necessary matrix
-    * @return matrix row pointer
-    */
+	* @brief Full access to the matrix row pointer. If you enter an index out of the border of the matrix will be SEGFAULT
+	*
+	* @param row is a row of necessary matrix
+	* @return matrix row pointer
+	*/
 	Type *operator[](uint row) { return m[row]; }
 
 	/**
-    * @brief Read-only access to the matrix row pointer. If you enter an index out of the border of the matrix will be SEGFAULT
-    *
-    * @param row is a row of necessary matrix
-    * @return matrix row pointer
-    */
+	* @brief Read-only access to the matrix row pointer. If you enter an index out of the border of the matrix will be SEGFAULT
+	*
+	* @param row is a row of necessary matrix
+	* @return matrix row pointer
+	*/
 	const Type *operator[](uint row) const { return m[row]; }
 
 	/**
-    * @brief Matrix assignment to matrix "sm"
-    *
-    * @param sm matrix for the assigment
-    * @return matrix equal with sm
-    */
+	* @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 Compare with matrix "sm"
-    *
-    * @param sm matrix for the compare
-    * @return if matrices are equal true, else false
-    */
+	* @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 Compare with matrix "sm"
-    *
-    * @param sm matrix for the compare
-    * @return if matrices are not equal true, else false
-    */
+	* @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 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 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 Subtraction assignment with matrix "sm"
-    *
-    * @param sm matrix for the subtraction assigment
-    */
+	* @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
-    */
+	* @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
-    */
+	* @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
-    */
+	* @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];
@@ -436,11 +436,11 @@ public:
 	}
 
 	/**
-    * @brief Matrix addition
-    *
-    * @param sm is matrix term
-    * @return the result of matrix addition
-    */
+	* @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];
@@ -448,11 +448,11 @@ public:
 	}
 
 	/**
-    * @brief Matrix substraction
-    *
-    * @param sm is matrix subtractor
-    * @return the result of matrix substraction
-    */
+	* @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];
@@ -460,11 +460,11 @@ public:
 	}
 
 	/**
-    * @brief Matrix multiplication
-    *
-    * @param v is value factor
-    * @return the result of matrix multiplication
-    */
+	* @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;
@@ -472,11 +472,11 @@ public:
 	}
 
 	/**
-    * @brief Matrix division
-    *
-    * @param v is value divider
-    * @return the result of matrix division
-    */
+	* @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;
@@ -484,10 +484,10 @@ public:
 	}
 
 	/**
-    * @brief Determinant of the matrix is ​​calculated
-    *
-    * @return matrix determinant
-    */
+	* @brief Determinant of the matrix is ​​calculated
+	*
+	* @return matrix determinant
+	*/
 	Type determinant(bool *ok = 0) const {
 		_CMatrix m(*this);
 		bool k;
@@ -504,10 +504,10 @@ public:
 	}
 
 	/**
-    * @brief Transforming matrix to upper triangular
-    *
-    * @return copy of transformed upper triangular matrix
-    */
+	* @brief Transforming matrix to upper triangular
+	*
+	* @return copy of transformed upper triangular matrix
+	*/
 	_CMatrix &toUpperTriangular(bool *ok = 0) {
 		if (Cols != Rows) {
 			if (ok != 0) *ok = false;
@@ -546,10 +546,10 @@ public:
 	}
 
 	/**
-    * @brief Matrix inversion operation
-    *
-    * @return copy of inverted matrix
-    */
+	* @brief Matrix inversion operation
+	*
+	* @return copy of inverted matrix
+	*/
 	_CMatrix &invert(bool *ok = 0) {
 		static_assert(Cols == Rows, "Only square matrix invertable");
 		_CMatrix mtmp = _CMatrix::identity(), smat(*this);
@@ -599,10 +599,10 @@ public:
 	}
 
 	/**
-    * @brief Matrix inversion operation
-    *
-    * @return inverted matrix
-    */
+	* @brief Matrix inversion operation
+	*
+	* @return inverted matrix
+	*/
 	_CMatrix inverted(bool *ok = 0) const {
 		_CMatrix tm(*this);
 		tm.invert(ok);
@@ -610,10 +610,10 @@ public:
 	}
 
 	/**
-    * @brief Matrix transposition operation
-    *
-    * @return transposed matrix
-    */
+	* @brief Matrix transposition operation
+	*
+	* @return transposed matrix
+	*/
 	_CMatrixI transposed() const {
 		_CMatrixI tm;
 		PIMM_FOR_WB(r, c) tm[c][r] = m[r][c];
@@ -859,33 +859,33 @@ class PIP_EXPORT PIMathMatrix : public PIVector2D<Type> {
 	typedef PIMathMatrix<Type> _CMatrix;
 	typedef PIMathVector<Type> _CMCol;
 public:
-    /**
-    * @brief Constructor of class PIMathMatrix, which creates a matrix
-    *
-    * @param cols is number of matrix column uint type
-    * @param rows is number of matrix row uint type
-    * @param f is type of matrix elements
-    */
+	/**
+	* @brief Constructor of class PIMathMatrix, which creates a matrix
+	*
+	* @param cols is number of matrix column uint type
+	* @param rows is number of matrix row uint type
+	* @param f is type of matrix elements
+	*/
 	PIMathMatrix(const uint cols = 0, const uint rows = 0, const Type &f = Type()) { _V2D::resize(rows, cols, f); }
 
-    /**
-    * @brief Constructor of class PIMathMatrix, which creates a matrix
-    *
-    * @param cols is number of matrix column uint type
-    * @param rows is number of matrix row uint type
-    * @param val is PIVector<Type> of matrix elements
-    */
+	/**
+	* @brief Constructor of class PIMathMatrix, which creates a matrix
+	*
+	* @param cols is number of matrix column uint type
+	* @param rows is number of matrix row uint type
+	* @param val is PIVector<Type> of matrix elements
+	*/
 	PIMathMatrix(const uint cols, const uint rows, const PIVector<Type> &val) {
 		_V2D::resize(rows, cols);
 		int i = 0;
 		PIMM_FOR_I(c, r) _V2D::element(r, c) = val[i++];
 	}
 
-    /**
-    * @brief Constructor of class PIMathMatrix, which creates a matrix
-    *
-    * @param val is PIVector<Type> of PIVector, which creates matrix
-    */
+	/**
+	* @brief Constructor of class PIMathMatrix, which creates a matrix
+	*
+	* @param val is PIVector<Type> of PIVector, which creates matrix
+	*/
 	PIMathMatrix(const PIVector<PIVector<Type> > &val) {
 		if (!val.isEmpty()) {
 			_V2D::resize(val.size(), val[0].size());
@@ -893,11 +893,11 @@ public:
 		}
 	}
 
-    /**
-    * @brief Constructor of class PIMathMatrix, which creates a matrix
-    *
-    * @param val is PIVector2D<Type>, which creates matrix
-    */
+	/**
+	* @brief Constructor of class PIMathMatrix, which creates a matrix
+	*
+	* @param val is PIVector2D<Type>, which creates matrix
+	*/
 	PIMathMatrix(const PIVector2D<Type> &val) {
 		if (!val.isEmpty()) {
 			_V2D::resize(val.rows(), val.cols());
@@ -905,194 +905,193 @@ public:
 		}
 	}
 
-    /**
-    * @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
-    */
+	/**
+	* @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 Creates a row matrix of every element that is equal to every element of the vector
-    *
-    * @param val is the vector type PIMathVector
-    * @return row matrix of every element that is equal to every element of the vector
-    */
+	/**
+	* @brief Creates a row matrix of every element that is equal to every element of the vector
+	*
+	* @param val is the vector type PIMathVector
+	* @return row matrix of every element that is equal to every element of the vector
+	*/
 	static _CMatrix matrixRow(const PIMathVector<Type> &val) { return _CMatrix(val.size(), 1, val.toVector()); }
 
 	/**
-    * @brief Creates a column matrix of every element that is equal to every element of the vector
-    *
-    * @param val is the vector type PIMathVector
-    * @return column matrix of every element that is equal to every element of the vector
-    */
+	* @brief Creates a column matrix of every element that is equal to every element of the vector
+	*
+	* @param val is the vector type PIMathVector
+	* @return column matrix of every element that is equal to every element of the vector
+	*/
 	static _CMatrix matrixCol(const PIMathVector<Type> &val) { return _CMatrix(1, val.size(), val.toVector()); }
 
 	/**
-    * @brief Set the selected column in matrix. If there are more elements of the vector than elements in the column of the matrix
-    * or index larger than the number of columns otherwise there will be a SEGFAULT
-    *
-    * @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
-    */
+	* @brief Set the selected column in matrix. If there are more elements of the vector than elements in the 	column of the matrix
+	* or index larger than the number of columns otherwise there will be a SEGFAULT
+	*
+	* @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 Set the selected row in matrix. If there are more elements of the vector than elements in the row of the matrix,
-    * or index larger than the number of rows otherwise there will be a SEGFAULT
-    * @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
-    */
+	* @brief Set the selected row in matrix. If there are more elements of the vector than elements in the row of the matrix,
+	* or index larger than the number of rows otherwise there will be a SEGFAULT
+	* @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 replace selected columns in a matrix. You cannot use an index larger than the number of columns,
-    *  otherwise there will be a SEGFAULT
-    *
-    * @param r0 is the number of the first selected row
-    * @param r1 is the number of the second selected row
-    * @return matrix type _CMatrix
-    */
+	* @brief Method which replace selected columns in a matrix. You cannot use an index larger than the number of columns,
+	*  otherwise there will be a SEGFAULT
+	*
+	* @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 replace selected rows in a matrix. You cannot use an index larger than the number of rows,
-    *  otherwise there will be a SEGFAULT
-    *
-    * @param c0 is the number of the first selected row
-    * @param c1 is the number of the second selected row
-    * @return matrix type _CMatrix
-    */
+	/**
+	* @brief Method which replace selected rows in a matrix. You cannot use an index larger than the number of rows,
+	*  otherwise there will be a SEGFAULT
+	*
+	* @param c0 is the number of the first selected row
+	* @param c1 is the number of the second selected row
+	* @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 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
-    */
+	* @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 square
-    *
-    * @return true if matrix is square, else false
-    */
+	* @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 checks if main diagonal of matrix consists of ones and another elements are zeros
-    *
-    * @return true if matrix is identity, else false
-    */
+	* @brief Method which checks if main diagonal of matrix consists of ones and another elements are zeros
+	*
+	* @return true if matrix is identity, 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 checks if every elements of matrix are zeros
-    *
-    * @return true if matrix elements equal to zero, else false
-    */
+	* @brief Method which checks if every elements of matrix are zeros
+	*
+	* @return true if matrix elements equal to zero, else false
+	*/
 	bool isNull() const {
 		PIMM_FOR_A(i) if (_V2D::mat[i] != Type(0)) return false;
 		return true;
 	}
 
 	/**
-    * @brief Method which checks if matrix is empty
-    *
-    * @return true if matrix is valid, else false
-    */
+	* @brief Method which checks if matrix is empty
+	*
+	* @return true if matrix is valid, else false
+	*/
 	bool isValid() const { return !PIVector2D<Type>::isEmpty(); }
 
 	/**
-    * @brief Matrix assignment to matrix "v"
-    *
-    * @param v matrix for the assigment
-    * @return matrix equal with v
-    */
+	* @brief Matrix assignment to matrix "v"
+	*
+	* @param v matrix for the assigment
+	* @return matrix equal with v
+	*/
 	_CMatrix &operator=(const PIVector<PIVector<Type> > &v) {
 		*this = _CMatrix(v);
 		return *this;
 	}
 
 	/**
-    * @brief Compare with matrix "sm"
-    *
-    * @param sm matrix for the compare
-    * @return if matrices are equal true, else false
-    */
+	* @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 Compare with matrix "sm"
-    *
-    * @param sm matrix for the compare
-    * @return if matrices are not equal true, else false
-    */
+	* @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 Addition assignment with matrix "sm"
-    *
-    * @param sm matrix for the addition assigment
-    */
+	* @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 Subtraction assignment with matrix "sm"
-    *
-    * @param sm matrix for the subtraction assigment
-    */
+	* @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 Multiplication assignment with value "v"
-    *
-    * @param v value for the multiplication assigment
-    */
+	/**
+	* @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 Division assignment with value "v"
-    *
-    * @param v value for the division assigment
-    */
+	* @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 substraction
-    *
-    * @return the result of matrix substraction
-    */
+	/**
+	* @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];
@@ -1100,11 +1099,11 @@ public:
 	}
 
 	/**
-    * @brief Matrix addition
-    *
-    * @param sm is matrix term
-    * @return the result of matrix addition
-    */
+	* @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];
@@ -1112,11 +1111,11 @@ public:
 	}
 
 	/**
-    * @brief Matrix subtraction
-    *
-    * @param sm is matrix subtractor
-    * @return the result of matrix subtraction
-    */
+	* @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];
@@ -1124,11 +1123,11 @@ public:
 	}
 
 	/**
-    * @brief Matrix multiplication
-    *
-    * @param v is value factor
-    * @return the result of matrix multiplication
-    */
+	* @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;
@@ -1136,11 +1135,11 @@ public:
 	}
 
 	/**
-    * @brief Matrix division
-    *
-    * @param v is value divider
-    * @return the result of matrix division
-    */
+	* @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;
@@ -1148,10 +1147,10 @@ public:
 	}
 
 	/**
-    * @brief Determinant of the matrix is ​​calculated. Works only with square matrix
-    *
-    * @return matrix determinant
-    */
+	* @brief Determinant of the matrix is ​​calculated. Works only with square matrix
+	*
+	* @return matrix determinant
+	*/
 	Type determinant(bool *ok = 0) const {
 		_CMatrix m(*this);
 		bool k;
@@ -1168,10 +1167,10 @@ public:
 	}
 
 	/**
-    * @brief Trace of the matrix is calculated. Works only with square matrix
-    *
-    * @return matrix trace
-    */
+	* @brief Trace of the matrix is calculated. Works only with square matrix
+	*
+	* @return matrix trace
+	*/
 	Type trace(bool *ok = 0) const {
 		Type ret = Type(0);
 		if (!isSquare()) {
@@ -1186,10 +1185,10 @@ public:
 	}
 
 	/**
-    * @brief Transforming matrix to upper triangular. Works only with square matrix
-    *
-    * @return copy of transformed upper triangular matrix
-    */
+	* @brief Transforming matrix to upper triangular. Works only with square matrix
+	*
+	* @return copy of transformed upper triangular matrix
+	*/
 	_CMatrix &toUpperTriangular(bool *ok = 0) {
 		if (!isSquare()) {
 			if (ok != 0) *ok = false;
@@ -1228,10 +1227,10 @@ public:
 	}
 
 	/**
-    * @brief Matrix inversion operation. Works only with square matrix
-    *
-    * @return copy of inverted matrix
-    */
+	* @brief Matrix inversion operation. Works only with square matrix
+	*
+	* @return copy of inverted matrix
+	*/
 	_CMatrix &invert(bool *ok = 0, _CMCol *sv = 0) {
 		if (!isSquare()) {
 			if (ok != 0) *ok = false;
@@ -1288,10 +1287,10 @@ public:
 	}
 
 	/**
-    * @brief Matrix inversion operation
-    *
-    * @return inverted matrix
-    */
+	* @brief Matrix inversion operation
+	*
+	* @return inverted matrix
+	*/
 	_CMatrix inverted(bool *ok = 0) const {
 		_CMatrix tm(*this);
 		tm.invert(ok);
@@ -1299,10 +1298,10 @@ public:
 	}
 
 	/**
-    * @brief Matrix transposition operation
-    *
-    * @return transposed matrix
-    */
+	* @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);