From d3d723533825cee33f1489777fe41c7c93d3c900 Mon Sep 17 00:00:00 2001 From: peri4 Date: Wed, 16 Oct 2024 22:10:28 +0300 Subject: [PATCH] enable complex type for PIMathVectorT and PIMathMatrixT TODO: add precision to invert and test vector --- libs/main/math/pimathcomplex.h | 6 + libs/main/math/pimathmatrix.h | 26 +-- libs/main/math/pimathvector.h | 120 ++++++++---- tests/math/testpimathmatrixt.cpp | 313 ++++++++++++++++--------------- 4 files changed, 258 insertions(+), 207 deletions(-) diff --git a/libs/main/math/pimathcomplex.h b/libs/main/math/pimathcomplex.h index a6435666..84cf1ab0 100644 --- a/libs/main/math/pimathcomplex.h +++ b/libs/main/math/pimathcomplex.h @@ -36,6 +36,12 @@ using std::complex; +template +struct is_complex: std::false_type {}; + +template +struct is_complex>: std::true_type {}; + typedef complex complexi; typedef complex complexs; typedef complex complexf; diff --git a/libs/main/math/pimathmatrix.h b/libs/main/math/pimathmatrix.h index 242c9c4f..c853a381 100644 --- a/libs/main/math/pimathmatrix.h +++ b/libs/main/math/pimathmatrix.h @@ -63,7 +63,7 @@ class PIP_EXPORT PIMathMatrixT { typedef PIMathMatrixT _CMatrixI; typedef PIMathVectorT _CMCol; typedef PIMathVectorT _CMRow; - static_assert(std::is_arithmetic::value, "Type must be arithmetic"); + static_assert(std::is_arithmetic::value || is_complex::value, "Type must be arithmetic or complex"); static_assert(Rows > 0, "Row count must be > 0"); static_assert(Cols > 0, "Column count must be > 0"); @@ -386,7 +386,7 @@ public: //! \brief Деление с присваиванием с матрицей `v`. //! \param sm матрица для деления с присваиванием. void operator/=(const Type & v) { - assert(piAbs(v) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(v) > PIMATHVECTOR_ZERO_CMP); PIMM_FOR m[r][c] /= v; } @@ -453,7 +453,7 @@ public: //! \param v делитель. //! \return результат деления. PIMathMatrixT operator/(const Type & v) const { - assert(piAbs(v) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(v) > PIMATHVECTOR_ZERO_CMP); PIMathMatrixT tm = PIMathMatrixT(*this); PIMM_FOR tm.m[r][c] /= v; return tm; @@ -517,7 +517,7 @@ public: for (uint i = 0; i < Cols; ++i) { ndet = true; for (uint j = 0; j < Rows; ++j) - if (smat.m[i][j] != 0) ndet = false; + if (smat.m[i][j] != Type{}) ndet = false; if (ndet) { if (ok != 0) *ok = false; return *this; @@ -525,15 +525,16 @@ public: } for (uint i = 0; i < Cols; ++i) { crow = i; - while (smat.m[i][i] == Type(0)) + while (smat.m[i][i] == Type{}) { smat.swapRows(i, ++crow); + } for (uint j = i + 1; j < Rows; ++j) { mul = smat.m[i][j] / smat.m[i][i]; for (uint k = i; k < Cols; ++k) smat.m[k][j] -= mul * smat.m[k][i]; } if (i < Cols - 1) { - if (piAbs(smat.m[i + 1][i + 1]) < Type(1E-200)) { + if (std::abs(smat.m[i + 1][i + 1]) < PIMATHVECTOR_ZERO_CMP) { if (ok != 0) *ok = false; return *this; } @@ -562,8 +563,9 @@ public: Type mul, iddiv; for (uint i = 0; i < Cols; ++i) { ndet = true; - for (uint j = 0; j < Rows; ++j) - if (smat.m[i][j] != 0) ndet = false; + for (uint j = 0; j < Rows; ++j) { + if (std::abs(smat.m[i][j]) >= PIMATHVECTOR_ZERO_CMP) ndet = false; + } if (ndet) { if (ok != 0) *ok = false; return *this; @@ -571,7 +573,7 @@ public: } for (uint i = 0; i < Cols; ++i) { crow = i; - while (smat.m[i][i] == Type(0)) { + while (std::abs(smat.m[i][i]) < PIMATHVECTOR_ZERO_CMP) { ++crow; smat.swapRows(i, crow); mtmp.swapRows(i, crow); @@ -584,7 +586,7 @@ public: mtmp.m[k][j] -= mul * mtmp.m[k][i]; } if (i < Cols - 1) { - if (piAbs(smat.m[i + 1][i + 1]) < Type(1E-200)) { + if (std::abs(smat.m[i + 1][i + 1]) < PIMATHVECTOR_ZERO_CMP) { if (ok != 0) *ok = false; return *this; } @@ -650,7 +652,7 @@ public: static_assert(Rows == 2 && Cols == 2, "Works only with 2x2 matrix"); Type c = std::cos(angle); Type s = std::sin(angle); - PIMathMatrixT<2u, 2u> tm; + PIMathMatrixT<2u, 2u, Type> tm; tm[0][0] = tm[1][1] = c; tm[0][1] = -s; tm[1][0] = s; @@ -671,7 +673,7 @@ public: PIMathMatrixT outm; Type c = std::cos(angle); Type s = std::sin(angle); - PIMathMatrixT<2u, 2u> tm; + PIMathMatrixT<2u, 2u, Type> tm; tm[0][0] = tm[1][1] = c; tm[0][1] = -s; tm[1][0] = s; diff --git a/libs/main/math/pimathvector.h b/libs/main/math/pimathvector.h index 4f8195ff..41b4daa5 100644 --- a/libs/main/math/pimathvector.h +++ b/libs/main/math/pimathvector.h @@ -27,12 +27,13 @@ #define PIMATHVECTOR_H #include "pimathbase.h" +#include "pimathcomplex.h" template class PIMathMatrixT; -#define PIMATHVECTOR_ZERO_CMP Type(1E-100) +#define PIMATHVECTOR_ZERO_CMP (1E-100) /// Vector templated @@ -42,7 +43,7 @@ class PIMathMatrixT; template class PIP_EXPORT PIMathVectorT { typedef PIMathVectorT _CVector; - static_assert(std::is_arithmetic::value, "Type must be arithmetic"); + static_assert(std::is_arithmetic::value || is_complex::value, "Type must be arithmetic or complex"); static_assert(Size > 0, "Size must be > 0"); public: @@ -83,35 +84,71 @@ public: PIMV_FOR tv += c[i] * c[i]; return tv; } - Type length() const { return std::sqrt(lengthSqr()); } + + Type length() const { + static_assert(std::is_arithmetic::value, "Unavailable for complex"); + if (std::is_arithmetic::value) return std::sqrt(lengthSqr()); + // if (is_complex::value) return 1000.; // std::sqrt(lengthSqr()); + } + Type manhattanLength() const { - Type tv(0); - PIMV_FOR tv += piAbs(c[i]); - return tv; + static_assert(std::is_arithmetic::value, "Unavailable for complex"); + if (std::is_arithmetic::value) { + Type tv(0); + PIMV_FOR tv += piAbs(c[i]); + return tv; + } } Type angleCos(const _CVector & v) const { - Type tv = v.length() * length(); - assert(piAbs(tv) > PIMATHVECTOR_ZERO_CMP); - return dot(v) / tv; + static_assert(std::is_arithmetic::value, "Unavailable for complex"); + if (std::is_arithmetic::value) { + Type tv = v.length() * length(); + assert(piAbs(tv) > PIMATHVECTOR_ZERO_CMP); + return dot(v) / tv; + } } Type angleSin(const _CVector & v) const { - Type tv = angleCos(v); - return std::sqrt(Type(1) - tv * tv); + static_assert(std::is_arithmetic::value, "Unavailable for complex"); + if (std::is_arithmetic::value) { + Type tv = angleCos(v); + return std::sqrt(Type(1) - tv * tv); + } + } + Type angleRad(const _CVector & v) const { + static_assert(std::is_arithmetic::value, "Unavailable for complex"); + if (std::is_arithmetic::value) { + return std::acos(angleCos(v)); + } + } + Type angleDeg(const _CVector & v) const { + static_assert(std::is_arithmetic::value, "Unavailable for complex"); + if (std::is_arithmetic::value) { + return toDeg(angleRad(v)); + } + } + Type angleElevation(const _CVector & v) const { + static_assert(std::is_arithmetic::value, "Unavailable for complex"); + if (std::is_arithmetic::value) { + return 90.0 - angleDeg(v - *this); + } } - Type angleRad(const _CVector & v) const { return std::acos(angleCos(v)); } - Type angleDeg(const _CVector & v) const { return toDeg(angleRad(v)); } - Type angleElevation(const _CVector & v) const { return 90.0 - angleDeg(v - *this); } _CVector projection(const _CVector & v) { - Type tv = v.length(); - assert(piAbs(tv) > PIMATHVECTOR_ZERO_CMP); - return v * (dot(v) / tv); + static_assert(std::is_arithmetic::value, "Unavailable for complex"); + if (std::is_arithmetic::value) { + Type tv = v.length(); + assert(piAbs(tv) > PIMATHVECTOR_ZERO_CMP); + return v * (dot(v) / tv); + } } _CVector & normalize() { - Type tv = length(); - assert(piAbs(tv) > PIMATHVECTOR_ZERO_CMP); - if (tv == Type(1)) return *this; - PIMV_FOR c[i] /= tv; - return *this; + static_assert(std::is_arithmetic::value, "Unavailable for complex"); + if (std::is_arithmetic::value) { + Type tv = length(); + assert(piAbs(tv) > PIMATHVECTOR_ZERO_CMP); + if (tv == Type(1)) return *this; + PIMV_FOR c[i] /= tv; + return *this; + } } _CVector normalized() { _CVector tv(*this); @@ -119,10 +156,10 @@ public: return tv; } bool isNull() const { - PIMV_FOR if (c[i] != Type(0)) return false; + PIMV_FOR if (c[i] != Type{}) return false; return true; } - bool isOrtho(const _CVector & v) const { return ((*this) ^ v) == Type(0); } + bool isOrtho(const _CVector & v) const { return ((*this) ^ v) == Type{}; } Type & operator[](uint index) { return c[index]; } const Type & operator[](uint index) const { return c[index]; } @@ -145,7 +182,7 @@ public: void operator-=(const _CVector & v) { PIMV_FOR c[i] -= v[i]; } void operator*=(const Type & v) { PIMV_FOR c[i] *= v; } void operator/=(const Type & v) { - assert(piAbs(v) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(v) > PIMATHVECTOR_ZERO_CMP); PIMV_FOR c[i] /= v; } _CVector operator-() const { @@ -169,7 +206,7 @@ public: return tv; } _CVector operator/(const Type & v) const { - assert(piAbs(v) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(v) > PIMATHVECTOR_ZERO_CMP); _CVector tv = _CVector(*this); PIMV_FOR tv[i] /= v; return tv; @@ -184,7 +221,7 @@ public: return tv; } Type dot(const _CVector & v) const { - Type tv(0); + Type tv{}; PIMV_FOR tv += c[i] * v[i]; return tv; } @@ -197,7 +234,7 @@ public: _CVector div(const _CVector & v) const { _CVector tv(*this); PIMV_FOR { - assert(piAbs(v[i]) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(v[i]) > PIMATHVECTOR_ZERO_CMP); tv[i] /= v[i]; } return tv; @@ -211,11 +248,14 @@ public: } Type distToLine(const _CVector & lp0, const _CVector & lp1) { - _CVector a(lp0, lp1); - Type tv = a.length(); - assert(piAbs(tv) > PIMATHVECTOR_ZERO_CMP); - _CVector b(lp0, *this); - return piAbs(a[0] * b[1] - a[1] * b[0]) / tv; + static_assert(std::is_arithmetic::value, "Unavailable for complex"); + if (std::is_arithmetic::value) { + _CVector a(lp0, lp1); + Type tv = a.length(); + assert(std::abs(tv) > PIMATHVECTOR_ZERO_CMP); + _CVector b(lp0, *this); + return piAbs(a[0] * b[1] - a[1] * b[0]) / tv; + } } template /// vector {Size, Type} to vector {Size1, Type1} @@ -394,7 +434,7 @@ public: Type angleCos(const _CVector & v) const { assert(c.size() == v.size()); Type tv = v.length() * length(); - assert(piAbs(tv) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(tv) > PIMATHVECTOR_ZERO_CMP); return dot(v) / tv; } Type angleSin(const _CVector & v) const { @@ -407,12 +447,12 @@ public: _CVector projection(const _CVector & v) { assert(c.size() == v.size()); Type tv = v.length(); - assert(piAbs(tv) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(tv) > PIMATHVECTOR_ZERO_CMP); return v * (dot(v) / tv); } _CVector & normalize() { Type tv = length(); - assert(piAbs(tv) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(tv) > PIMATHVECTOR_ZERO_CMP); if (tv == Type(1)) return *this; PIMV_FOR c[i] /= tv; return *this; @@ -451,7 +491,7 @@ public: } void operator*=(const Type & v) { PIMV_FOR c[i] *= v; } void operator/=(const Type & v) { - assert(piAbs(v) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(v) > PIMATHVECTOR_ZERO_CMP); PIMV_FOR c[i] /= v; } _CVector operator-() const { @@ -477,7 +517,7 @@ public: return tv; } _CVector operator/(const Type & v) const { - assert(piAbs(v) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(v) > PIMATHVECTOR_ZERO_CMP); _CVector tv(*this); PIMV_FOR tv[i] /= v; return tv; @@ -508,7 +548,7 @@ public: assert(c.size() == v.size()); _CVector tv(*this); PIMV_FOR { - assert(piAbs(v[i]) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(v[i]) > PIMATHVECTOR_ZERO_CMP); tv[i] /= v[i]; } return tv; @@ -520,7 +560,7 @@ public: assert(c.size() == lp1.size()); _CVector a = _CVector::fromTwoPoints(lp0, lp1); Type tv = a.length(); - assert(piAbs(tv) > PIMATHVECTOR_ZERO_CMP); + assert(std::abs(tv) > PIMATHVECTOR_ZERO_CMP); _CVector b = _CVector::fromTwoPoints(lp0, *this); return piAbs(a[0] * b[1] - a[1] * b[0]) / tv; } diff --git a/tests/math/testpimathmatrixt.cpp b/tests/math/testpimathmatrixt.cpp index d5c643b0..8900aa99 100644 --- a/tests/math/testpimathmatrixt.cpp +++ b/tests/math/testpimathmatrixt.cpp @@ -4,8 +4,9 @@ const uint rows = 3; const uint cols = 3; +using Type = double; -bool cmpSquareMatrixWithValue(PIMathMatrixT matrix, double val, int num) { +bool cmpSquareMatrixWithValue(PIMathMatrixT matrix, Type val, int num) { for (int i = 0; i < num; i++) { for (int j = 0; j < num; j++) { if (matrix.at(i, j) != val) { @@ -17,50 +18,50 @@ bool cmpSquareMatrixWithValue(PIMathMatrixT matrix, double v } TEST(PIMathMatrixT_Test, identity) { - auto matrix = PIMathMatrixT::identity(); + auto matrix = PIMathMatrixT::identity(); for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (i != j) { if (matrix[i][j] != 0.0) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } } else { if (matrix[i][i] != 1.0) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } } } } - ASSERT_TRUE(true); + EXPECT_TRUE(true); } TEST(PIMathMatrixT_Test, at) { - auto matrix1 = PIMathMatrixT::identity(); + auto matrix1 = PIMathMatrixT::identity(); for (uint i = 0; i < rows; i++) { if (matrix1.at(i, i) != 1.0) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } } - ASSERT_TRUE(true); + EXPECT_TRUE(true); } TEST(PIMathMatrixT_Test, filled) { - auto matr = PIMathMatrixT(1.0); - ASSERT_TRUE(cmpSquareMatrixWithValue(matr, 1.0, rows)); + auto matr = PIMathMatrixT(1.0); + EXPECT_TRUE(cmpSquareMatrixWithValue(matr, 1.0, rows)); } TEST(PIMathMatrixT_Test, cols) { - PIMathMatrixT matr; - ASSERT_EQ(cols, matr.cols()); + PIMathMatrixT matr; + EXPECT_EQ(cols, matr.cols()); } TEST(PIMathMatrixT_Test, rows) { - PIMathMatrixT matr; - ASSERT_EQ(rows, matr.rows()); + PIMathMatrixT matr; + EXPECT_EQ(rows, matr.rows()); } TEST(PIMathMatrixT_Test, col) { - PIMathMatrixT matr; - PIMathVectorT vect; + PIMathMatrixT matr; + PIMathVectorT vect; uint g = 2; matr.element(0, 0) = 3; matr.element(0, 1) = 6; @@ -74,15 +75,15 @@ TEST(PIMathMatrixT_Test, col) { vect = matr.col(g); for (uint i = 0; i < matr.cols(); i++) { if (matr.element(i, g) != vect[i]) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } } - ASSERT_TRUE(true); + EXPECT_TRUE(true); } TEST(PIMathMatrixT_Test, row) { - PIMathMatrixT matr; - PIMathVectorT vect; + PIMathMatrixT matr; + PIMathVectorT vect; uint g = 2; matr.element(0, 0) = 3; matr.element(0, 1) = 6; @@ -96,15 +97,15 @@ TEST(PIMathMatrixT_Test, row) { vect = matr.row(g); for (uint i = 0; i < matr.rows(); i++) { if (matr.element(g, i) != vect[i]) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } } - ASSERT_TRUE(true); + EXPECT_TRUE(true); } TEST(PIMathMatrixT_Test, setCol) { - PIMathMatrixT matr; - PIMathVectorT vect; + PIMathMatrixT matr; + PIMathVectorT vect; vect[0] = 1.0; vect[1] = 3.0; vect[2] = 5.0; @@ -112,15 +113,15 @@ TEST(PIMathMatrixT_Test, setCol) { matr.setCol(g, vect); for (uint i = 0; i < vect.size(); i++) { if (matr.element(i, g) != vect[i]) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } } - ASSERT_TRUE(true); + EXPECT_TRUE(true); } TEST(PIMathMatrixT_Test, setRow) { - PIMathMatrixT matr; - PIMathVectorT vect; + PIMathMatrixT matr; + PIMathVectorT vect; vect[0] = 1.0; vect[1] = 3.0; vect[2] = 5.0; @@ -128,114 +129,114 @@ TEST(PIMathMatrixT_Test, setRow) { matr.setRow(g, vect); for (uint i = 0; i < vect.size(); i++) { if (matr.element(g, i) != vect[i]) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } } - ASSERT_TRUE(true); + EXPECT_TRUE(true); } TEST(PIMathMatrixT_Test, swapCols) { - PIMathMatrixT matr; + PIMathMatrixT matr; int g1 = 1, g2 = 2; - matr.element(0, 0) = 3; - matr.element(0, 1) = 6; - matr.element(0, 2) = 8; - matr.element(1, 0) = 2; - matr.element(1, 1) = 1; - matr.element(1, 2) = 4; - matr.element(2, 0) = 6; - matr.element(2, 1) = 2; - matr.element(2, 2) = 5; - const PIMathVectorT before_Vect1 = matr.col(g1); - const PIMathVectorT before_Vect2 = matr.col(g2); + matr.element(0, 0) = 3; + matr.element(0, 1) = 6; + matr.element(0, 2) = 8; + matr.element(1, 0) = 2; + matr.element(1, 1) = 1; + matr.element(1, 2) = 4; + matr.element(2, 0) = 6; + matr.element(2, 1) = 2; + matr.element(2, 2) = 5; + const PIMathVectorT before_Vect1 = matr.col(g1); + const PIMathVectorT before_Vect2 = matr.col(g2); matr.swapCols(g1, g2); - const PIMathVectorT after_Vect1 = matr.col(g1); - const PIMathVectorT after_Vect2 = matr.col(g2); + const PIMathVectorT after_Vect1 = matr.col(g1); + const PIMathVectorT after_Vect2 = matr.col(g2); if ((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1)) { - ASSERT_TRUE(true); + EXPECT_TRUE(true); } else { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } } TEST(PIMathMatrixT_Test, swapRows) { - PIMathMatrixT matr; + PIMathMatrixT matr; int g1 = 1, g2 = 2; - matr.element(0, 0) = 3; - matr.element(0, 1) = 6; - matr.element(0, 2) = 8; - matr.element(1, 0) = 2; - matr.element(1, 1) = 1; - matr.element(1, 2) = 4; - matr.element(2, 0) = 6; - matr.element(2, 1) = 2; - matr.element(2, 2) = 5; - const PIMathVectorT before_Vect1 = matr.row(g1); - const PIMathVectorT before_Vect2 = matr.row(g2); + matr.element(0, 0) = 3; + matr.element(0, 1) = 6; + matr.element(0, 2) = 8; + matr.element(1, 0) = 2; + matr.element(1, 1) = 1; + matr.element(1, 2) = 4; + matr.element(2, 0) = 6; + matr.element(2, 1) = 2; + matr.element(2, 2) = 5; + const PIMathVectorT before_Vect1 = matr.row(g1); + const PIMathVectorT before_Vect2 = matr.row(g2); matr.swapRows(g1, g2); - const PIMathVectorT after_Vect1 = matr.row(g1); - const PIMathVectorT after_Vect2 = matr.row(g2); + const PIMathVectorT after_Vect1 = matr.row(g1); + const PIMathVectorT after_Vect2 = matr.row(g2); if ((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1)) { - ASSERT_TRUE(true); + EXPECT_TRUE(true); } else { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } } TEST(PIMathMatrixT_Test, fill) { - PIMathMatrixT matr; - PIMathMatrixT matrix1; - double g = 1.0; + PIMathMatrixT matr; + PIMathMatrixT matrix1; + Type g = 1.0; matr.fill(g); for (uint i = 0; i < cols; i++) { for (uint j = 0; j < rows; j++) { matrix1.element(j, i) = g; } } - ASSERT_TRUE(matr == matrix1); + EXPECT_TRUE(matr == matrix1); } TEST(PIMathMatrixT_Test, isSquareTrue) { - PIMathMatrixT matrix1; - ASSERT_TRUE(matrix1.isSquare()); + PIMathMatrixT matrix1; + EXPECT_TRUE(matrix1.isSquare()); } TEST(PIMathMatrixT_Test, isSquareFalse) { const uint new_Cols = 4; - PIMathMatrixT matrix2; - ASSERT_FALSE(matrix2.isSquare()); + PIMathMatrixT matrix2; + EXPECT_FALSE(matrix2.isSquare()); } TEST(PIMathMatrixT_Test, isIdentityTrue) { - auto matrix1 = PIMathMatrixT::identity(); - ASSERT_TRUE(matrix1.isIdentity()); + auto matrix1 = PIMathMatrixT::identity(); + EXPECT_TRUE(matrix1.isIdentity()); } TEST(PIMathMatrixT_Test, isIdentityFalse) { - auto matrix1 = PIMathMatrixT(2.5); - ASSERT_FALSE(matrix1.isIdentity()); + auto matrix1 = PIMathMatrixT(2.5); + EXPECT_FALSE(matrix1.isIdentity()); } TEST(PIMathMatrixT_Test, isNullTrue) { - PIMathMatrixT matrix1; - ASSERT_TRUE(matrix1.isNull()); + PIMathMatrixT matrix1; + EXPECT_TRUE(matrix1.isNull()); } TEST(PIMathMatrixT_Test, isNullFalse) { - auto matrix1 = PIMathMatrixT::identity(); - ASSERT_FALSE(matrix1.isNull()); + auto matrix1 = PIMathMatrixT::identity(); + EXPECT_FALSE(matrix1.isNull()); } TEST(PIMathMatrixT_Test, operator_Assignment) { - PIMathMatrixT matrix1; - auto matrix2 = PIMathMatrixT(6.72); + PIMathMatrixT matrix1; + auto matrix2 = PIMathMatrixT(6.72); matrix1 = matrix2; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 6.72, rows)); + EXPECT_TRUE(cmpSquareMatrixWithValue(matrix1, 6.72, rows)); } TEST(PIMathMatrixT_Test, operator_EqualTrue) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; matrix1.element(0, 0) = 5.1; matrix1.element(0, 1) = 1.21; matrix1.element(1, 1) = 0.671; @@ -244,12 +245,12 @@ TEST(PIMathMatrixT_Test, operator_EqualTrue) { matrix2.element(0, 1) = 1.21; matrix2.element(1, 1) = 0.671; matrix2.element(1, 0) = 2.623; - ASSERT_TRUE(matrix1 == matrix2); + EXPECT_TRUE(matrix1 == matrix2); } TEST(PIMathMatrixT_Test, operator_EqualFalse) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; matrix1.element(0, 0) = 5.1; matrix1.element(0, 1) = 1.21; matrix1.element(1, 1) = 0.671; @@ -258,12 +259,12 @@ TEST(PIMathMatrixT_Test, operator_EqualFalse) { matrix2.element(0, 1) = 1.21; matrix2.element(1, 1) = 665.671; matrix2.element(1, 0) = 2.623; - ASSERT_FALSE(matrix1 == matrix2); + EXPECT_FALSE(matrix1 == matrix2); } TEST(PIMathMatrixT_Test, operator_Not_EqualTrue) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; matrix1.element(0, 0) = 5.1; matrix1.element(0, 1) = 1.21; matrix1.element(1, 1) = 0.671; @@ -272,12 +273,12 @@ TEST(PIMathMatrixT_Test, operator_Not_EqualTrue) { matrix2.element(0, 1) = 1.21; matrix2.element(1, 1) = 665.671; matrix2.element(1, 0) = 2.623; - ASSERT_TRUE(matrix1 != matrix2); + EXPECT_TRUE(matrix1 != matrix2); } TEST(PIMathMatrixT_Test, operator_Not_EqualFalse) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; matrix1.element(0, 0) = 5.1; matrix1.element(0, 1) = 1.21; matrix1.element(1, 1) = 0.671; @@ -286,60 +287,60 @@ TEST(PIMathMatrixT_Test, operator_Not_EqualFalse) { matrix2.element(0, 1) = 1.21; matrix2.element(1, 1) = 0.671; matrix2.element(1, 0) = 2.623; - ASSERT_FALSE(matrix1 != matrix2); + EXPECT_FALSE(matrix1 != matrix2); } TEST(PIMathMatrixT_Test, operator_Addition_Assignment) { - auto matrix1 = PIMathMatrixT(6.72); - auto matrix2 = PIMathMatrixT(1.0); + auto matrix1 = PIMathMatrixT(6.72); + auto matrix2 = PIMathMatrixT(1.0); matrix1 += matrix2; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.72, rows)); + EXPECT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.72, rows)); } TEST(PIMathMatrixT_Test, operator_Subtraction_Assignment) { - auto matrix1 = PIMathMatrixT(1.0); - auto matrix2 = PIMathMatrixT(6.72); + auto matrix1 = PIMathMatrixT(1.0); + auto matrix2 = PIMathMatrixT(6.72); matrix1 -= matrix2; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, -5.72, rows)); + EXPECT_TRUE(cmpSquareMatrixWithValue(matrix1, -5.72, rows)); } TEST(PIMathMatrixT_Test, operator_Multiplication_Assignment) { - auto matrix1 = PIMathMatrixT(6.72); + auto matrix1 = PIMathMatrixT(6.72); matrix1 *= 2.0; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 13.44, rows)); + EXPECT_TRUE(cmpSquareMatrixWithValue(matrix1, 13.44, rows)); } TEST(PIMathMatrixT_Test, operator_Division_Assignment) { - auto matrix1 = PIMathMatrixT(6.72); + auto matrix1 = PIMathMatrixT(6.72); matrix1 /= 2.0; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 3.36, rows)); + EXPECT_TRUE(cmpSquareMatrixWithValue(matrix1, 3.36, rows)); } TEST(PIMathMatrixT_Test, operator_Addition) { - auto matrix1 = PIMathMatrixT(6.72); - auto matrix2 = PIMathMatrixT(8.28); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 + matrix2, 15.0, rows)); + auto matrix1 = PIMathMatrixT(6.72); + auto matrix2 = PIMathMatrixT(8.28); + EXPECT_TRUE(cmpSquareMatrixWithValue(matrix1 + matrix2, 15.0, rows)); } TEST(PIMathMatrixT_Test, operator_Subtraction) { - auto matrix1 = PIMathMatrixT(6.0); - auto matrix2 = PIMathMatrixT(5.0); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 - matrix2, 1.0, rows)); + auto matrix1 = PIMathMatrixT(6.0); + auto matrix2 = PIMathMatrixT(5.0); + EXPECT_TRUE(cmpSquareMatrixWithValue(matrix1 - matrix2, 1.0, rows)); } TEST(PIMathMatrixT_Test, operator_Multiplication) { - auto matrix1 = PIMathMatrixT(6.72); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * 4.0, 26.88, rows)); + auto matrix1 = PIMathMatrixT(6.72); + EXPECT_TRUE(cmpSquareMatrixWithValue(matrix1 * 4.0, 26.88, rows)); } TEST(PIMathMatrixT_Test, operator_Division) { - auto matrix1 = PIMathMatrixT(6.72); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 / 4.0, 1.68, rows)); + auto matrix1 = PIMathMatrixT(6.72); + EXPECT_TRUE(cmpSquareMatrixWithValue(matrix1 / 4.0, 1.68, rows)); } TEST(PIMathMatrixT_Test, determinantIfSquare) { - double d; - double i = 59.0; - PIMathMatrixT matr; + Type d; + Type i = 59.0; + PIMathMatrixT matr; matr.element(0, 0) = 3; matr.element(0, 1) = 6; matr.element(0, 2) = 8; @@ -350,15 +351,15 @@ TEST(PIMathMatrixT_Test, determinantIfSquare) { matr.element(2, 1) = 2; matr.element(2, 2) = 5; d = matr.determinant(); - ASSERT_DOUBLE_EQ(i, d); + EXPECT_DOUBLE_EQ(std::abs(i - d), 0.); } TEST(PIMathMatrixT_Test, invert) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; - PIMathMatrixT matrix3; - PIMathMatrixT matr; - double d1, d2; + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; + PIMathMatrixT matrix3; + PIMathMatrixT matr; + Type d1, d2; matr.element(0, 0) = 3; matr.element(0, 1) = 6; matr.element(0, 2) = 8; @@ -374,15 +375,16 @@ TEST(PIMathMatrixT_Test, invert) { d2 = matrix2.determinant(); matrix3 = matrix1; matrix1.invert(); - ASSERT_TRUE((matrix1 == matrix3) && piCompare(d1, 1 / d2)); + EXPECT_EQ(matrix1, matrix3); + EXPECT_DOUBLE_EQ(std::abs(d1 - (1. / d2)), 0.); } TEST(PIMathMatrixT_Test, inverted) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; - PIMathMatrixT matrix3; - PIMathMatrixT matr; - double d1, d2; + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; + PIMathMatrixT matrix3; + PIMathMatrixT matr; + Type d1, d2; matrix1 = matr.identity(); matr.element(0, 0) = 3; matr.element(0, 1) = 6; @@ -397,13 +399,14 @@ TEST(PIMathMatrixT_Test, inverted) { d1 = matr.determinant(); d2 = matrix2.determinant(); matrix3 = matrix1.inverted(); - ASSERT_TRUE((matrix1 == matrix3) && (round((1 / d1) * 10000) / 10000 == round(d2 * 10000) / 10000)); + EXPECT_EQ(matrix1, matrix3); + EXPECT_DOUBLE_EQ(std::abs(d1 - (1. / d2)), 0.); } TEST(PIMathMatrixT_Test, toUpperTriangular) { - PIMathMatrixT matrix; - double d1, d2 = 1; - PIMathMatrixT matr; + PIMathMatrixT matrix; + Type d1, d2 = 1; + PIMathMatrixT matr; matr.element(0, 0) = 3; matr.element(0, 1) = 6; matr.element(0, 2) = 8; @@ -418,14 +421,14 @@ TEST(PIMathMatrixT_Test, toUpperTriangular) { for (uint i = 0; i < cols; i++) { d2 = d2 * matrix.at(i, i); } - ASSERT_DOUBLE_EQ(d1, d2); + EXPECT_LE(std::abs(d1 - d2), PIMATHVECTOR_ZERO_CMP); } TEST(PIMathMatrixT_Test, transposed) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; - PIMathMatrixT matr; - double d1, d2; + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; + PIMathMatrixT matr; + Type d1, d2; matr.element(0, 0) = 3; matr.element(0, 1) = 6; matr.element(0, 2) = 8; @@ -439,46 +442,46 @@ TEST(PIMathMatrixT_Test, transposed) { matrix1 = matr.transposed(); d2 = matrix1.determinant(); matrix2 = matrix1.transposed(); - ASSERT_TRUE((d1 == d2) && (matr == matrix2)); + EXPECT_TRUE((d1 == d2) && (matr == matrix2)); } TEST(PIMathMatrixT_Test, rotation_2x2) { - double angle = 1.0; - auto matrix = PIMathMatrixT<2u, 2u, double>::identity(); + Type angle = 1.0; + auto matrix = PIMathMatrixT<2u, 2u, Type>::identity(); matrix.rotate(angle); - double c = cos(angle); - double s = sin(angle); - ASSERT_TRUE((c == matrix.at(1u, 1u)) && (c == matrix.at(0u, 0u)) && (-s == matrix.at(0u, 1u)) && (s == matrix.at(1u, 0u))); + Type c = cos(angle); + Type s = sin(angle); + EXPECT_TRUE((c == matrix.at(1u, 1u)) && (c == matrix.at(0u, 0u)) && (-s == matrix.at(0u, 1u)) && (s == matrix.at(1u, 0u))); } TEST(PIMathMatrixT_Test, matrixMultiplication) { - auto matrix1 = PIMathMatrixT(1.5); - auto matrix2 = PIMathMatrixT(2.5); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 11.25, 3)); + auto matrix1 = PIMathMatrixT(1.5); + auto matrix2 = PIMathMatrixT(2.5); + EXPECT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 11.25, 3)); } TEST(PIMathMatrixT_Test, matrixAndVectorMultiplication) { - auto matrix1 = PIMathMatrixT(1.5); - auto vector = PIMathVectorT(2.5); + auto matrix1 = PIMathMatrixT(1.5); + auto vector = PIMathVectorT(2.5); for (uint i = 0; i < 2; i++) { if ((matrix1 * vector)[i] != 11.25) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } } - ASSERT_TRUE(true); + EXPECT_TRUE(true); } TEST(PIMathMatrixT_Test, vectorAndMatrixMultiplication) { - auto matrix1 = PIMathMatrixT(1.5); - auto vector = PIMathVectorT(2.5); + auto matrix1 = PIMathMatrixT(1.5); + auto vector = PIMathVectorT(2.5); for (uint i = 0; i < 2; i++) { if ((vector * matrix1)[i] != 11.25) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } } } TEST(PIMathMatrixT_Test, valAndMatrixMultiplication) { - auto matrix1 = PIMathMatrixT(1.5); - ASSERT_TRUE(cmpSquareMatrixWithValue(25.0 * matrix1, 37.5, 3)); + auto matrix1 = PIMathMatrixT(1.5); + EXPECT_TRUE(cmpSquareMatrixWithValue(Type(25.) * matrix1, 37.5, 3)); }