diff --git a/tests/math/testpimathmatrix.cpp b/tests/math/testpimathmatrix.cpp index c6a52ec7..cb8dbea5 100644 --- a/tests/math/testpimathmatrix.cpp +++ b/tests/math/testpimathmatrix.cpp @@ -2,553 +2,553 @@ #include "pimathmatrix.h" bool cmpSquareMatrixWithValue(PIMathMatrix matrix, double val, int num) { - bool b = true; - for(int i = 0; i < num; i++) { - for(int j = 0; j < num; j++) { - if(matrix.element(i, j) - val >= double(1E-200)) { - b = false; - } - } - } - return b; + bool b = true; + for(int i = 0; i < num; i++) { + for(int j = 0; j < num; j++) { + if(matrix.element(i, j) - val >= double(1E-200)) { + b = false; + } + } + } + return b; } TEST(PIMathMatrix_Test, identity) { - auto matrix = PIMathMatrix::identity(3, 3); - 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); - } - } - else { - if(matrix[i][i] != 1.0){ - ASSERT_TRUE(false); - } - } - } - } - ASSERT_TRUE(true); + auto matrix = PIMathMatrix::identity(3, 3); + 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); + } + } + else { + if(matrix[i][i] != 1.0){ + ASSERT_TRUE(false); + } + } + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrixT_Test, element) { - auto matrix = PIMathMatrix::identity(3, 3); - 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); - } - } - else { - if(matrix.element(i,i) != 1.0) { - ASSERT_TRUE(false); - } - } - } - } - ASSERT_TRUE(true); + auto matrix = PIMathMatrix::identity(3, 3); + 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); + } + } + else { + if(matrix.element(i,i) != 1.0) { + ASSERT_TRUE(false); + } + } + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrix_Test, matrixRow) { - PIMathVector vector; - vector.resize(3, 3.0); - auto matrix = PIMathMatrix::matrixRow(vector); - for(uint i = 0; i < vector.size(); i++) { - if(matrix[0][i] != 3.0) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + PIMathVector vector; + vector.resize(3, 3.0); + auto matrix = PIMathMatrix::matrixRow(vector); + for(uint i = 0; i < vector.size(); i++) { + if(matrix[0][i] != 3.0) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrix_Test, matrixCol) { - PIMathVector vector; - vector.resize(3, 3.0); - auto matrix = PIMathMatrix::matrixCol(vector); - for(uint i = 0; i < vector.size(); i++) { - if(matrix[i][0] != 3.0) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + PIMathVector vector; + vector.resize(3, 3.0); + auto matrix = PIMathMatrix::matrixCol(vector); + for(uint i = 0; i < vector.size(); i++) { + if(matrix[i][0] != 3.0) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrix_Test, setCol) { - PIMathVector vector; - vector.resize(3, 3.0); - auto matrix = PIMathMatrix::matrixCol(vector); - vector.fill(10.0); - matrix.setCol(0, vector); - for(uint i = 0; i < vector.size(); i++) { - if(matrix[i][0] != 10.0) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + PIMathVector vector; + vector.resize(3, 3.0); + auto matrix = PIMathMatrix::matrixCol(vector); + vector.fill(10.0); + matrix.setCol(0, vector); + for(uint i = 0; i < vector.size(); i++) { + if(matrix[i][0] != 10.0) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrix_Test, setRow) { - PIMathVector vector; - vector.resize(3, 3.0); - auto matrix = PIMathMatrix::matrixRow(vector); - vector.fill(10.0); - matrix.setRow(0, vector); - for(uint i = 0; i < vector.size(); i++) { - if(matrix[0][i] != 10.0) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + PIMathVector vector; + vector.resize(3, 3.0); + auto matrix = PIMathMatrix::matrixRow(vector); + vector.fill(10.0); + matrix.setRow(0, vector); + for(uint i = 0; i < vector.size(); i++) { + if(matrix[0][i] != 10.0) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrix_Test, swapCols) { - PIMathMatrix origMatr; - PIMathMatrix matrix1; - PIMathVector vector; - uint i1 = 0; uint i2 = 1; - double a1[3], a2[3], a3[3]; - double b1[3], b2[3], b3[3]; - vector.resize(3, 3.0); - vector[0] = 3.0; - vector[1] = 6.0; - vector[2] = 8.0; - matrix1 = origMatr.identity(3, 3); - matrix1.setCol(0, vector); - vector[0] = 2.0; - vector[1] = 1.0; - vector[2] = 4.0; - matrix1.setCol(1, vector); - vector[0] = 6.0; - vector[1] = 2.0; - vector[2] = 5.0; - matrix1.setCol(2, vector); - for(int i = 0; i < 3; i++) { - a1[i] = matrix1.element(i, 0); - a2[i] = matrix1.element(i, 1); - a3[i] = matrix1.element(i, 2); - } - matrix1.swapCols(i1, i2); - for(int i = 0; i < 3; i++) { - b1[i] = matrix1.element(i, 0); - b2[i] = matrix1.element(i, 1); - b3[i] = matrix1.element(i, 2); - } - ASSERT_TRUE((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0)); + PIMathMatrix origMatr; + PIMathMatrix matrix1; + PIMathVector vector; + uint i1 = 0; uint i2 = 1; + double a1[3], a2[3], a3[3]; + double b1[3], b2[3], b3[3]; + vector.resize(3, 3.0); + vector[0] = 3.0; + vector[1] = 6.0; + vector[2] = 8.0; + matrix1 = origMatr.identity(3, 3); + matrix1.setCol(0, vector); + vector[0] = 2.0; + vector[1] = 1.0; + vector[2] = 4.0; + matrix1.setCol(1, vector); + vector[0] = 6.0; + vector[1] = 2.0; + vector[2] = 5.0; + matrix1.setCol(2, vector); + for(int i = 0; i < 3; i++) { + a1[i] = matrix1.element(i, 0); + a2[i] = matrix1.element(i, 1); + a3[i] = matrix1.element(i, 2); + } + matrix1.swapCols(i1, i2); + for(int i = 0; i < 3; i++) { + b1[i] = matrix1.element(i, 0); + b2[i] = matrix1.element(i, 1); + b3[i] = matrix1.element(i, 2); + } + ASSERT_TRUE((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0)); } TEST(PIMathMatrix_Test, swapRows) { - PIMathMatrix origMatr; - PIMathMatrix matrix1; - PIMathVector vector; - uint i1 = 0; uint i2 = 1; - double a1[3], a2[3], a3[3]; - double b1[3], b2[3], b3[3]; - vector.resize(3, 3.0); - vector[0] = 3.0; - vector[1] = 6.0; - vector[2] = 8.0; - matrix1 = origMatr.identity(3, 3); - matrix1.setCol(0, vector); - vector[0] = 2.0; - vector[1] = 1.0; - vector[2] = 4.0; - matrix1.setCol(1, vector); - vector[0] = 6.0; - vector[1] = 2.0; - vector[2] = 5.0; - matrix1.setCol(2, vector); - for(int i = 0; i < 3; i++) { - a1[i] = matrix1.element(0, i); - a2[i] = matrix1.element(1, i); - a3[i] = matrix1.element(2, i); - } - matrix1.swapRows(i1, i2); - for(int i = 0; i < 3; i++) { - b1[i] = matrix1.element(0, i); - b2[i] = matrix1.element(1, i); - b3[i] = matrix1.element(2, i); - } - ASSERT_TRUE((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0)); + PIMathMatrix origMatr; + PIMathMatrix matrix1; + PIMathVector vector; + uint i1 = 0; uint i2 = 1; + double a1[3], a2[3], a3[3]; + double b1[3], b2[3], b3[3]; + vector.resize(3, 3.0); + vector[0] = 3.0; + vector[1] = 6.0; + vector[2] = 8.0; + matrix1 = origMatr.identity(3, 3); + matrix1.setCol(0, vector); + vector[0] = 2.0; + vector[1] = 1.0; + vector[2] = 4.0; + matrix1.setCol(1, vector); + vector[0] = 6.0; + vector[1] = 2.0; + vector[2] = 5.0; + matrix1.setCol(2, vector); + for(int i = 0; i < 3; i++) { + a1[i] = matrix1.element(0, i); + a2[i] = matrix1.element(1, i); + a3[i] = matrix1.element(2, i); + } + matrix1.swapRows(i1, i2); + for(int i = 0; i < 3; i++) { + b1[i] = matrix1.element(0, i); + b2[i] = matrix1.element(1, i); + b3[i] = matrix1.element(2, i); + } + ASSERT_TRUE((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0)); } TEST(PIMathMatrix_Test, fill) { - PIMathMatrix matrix(3, 3, 5.0); - matrix.fill(7.0); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, 7.0, 3)); + PIMathMatrix matrix(3, 3, 5.0); + matrix.fill(7.0); + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, 7.0, 3)); } TEST(PIMathMatrix_Test, isSquareTrue) { - PIMathMatrix matrix(3, 3, 1.0); - ASSERT_TRUE(matrix.isSquare()); + PIMathMatrix matrix(3, 3, 1.0); + ASSERT_TRUE(matrix.isSquare()); } TEST(PIMathMatrix_Test, isSquareFalse) { - PIMathMatrix matrix(2, 4, 1.0); - ASSERT_FALSE(matrix.isSquare()); + PIMathMatrix matrix(2, 4, 1.0); + ASSERT_FALSE(matrix.isSquare()); } TEST(PIMathMatrix_Test, isIdentityTrue) { - auto matrix = PIMathMatrix::identity(3, 3); - ASSERT_TRUE(matrix.isIdentity()); + auto matrix = PIMathMatrix::identity(3, 3); + ASSERT_TRUE(matrix.isIdentity()); } TEST(PIMathMatrix_Test, isIdentityFalse) { - PIMathMatrix matrix(3, 3, 5.0); - ASSERT_FALSE(matrix.isIdentity()); + PIMathMatrix matrix(3, 3, 5.0); + ASSERT_FALSE(matrix.isIdentity()); } TEST(PIMathMatrix_Test, isNullTrue) { - PIMathMatrix matrix(3, 3, 0.0); - ASSERT_TRUE(matrix.isNull()); + PIMathMatrix matrix(3, 3, 0.0); + ASSERT_TRUE(matrix.isNull()); } TEST(PIMathMatrix_Test, isNullFalse) { - PIMathMatrix matrix(3, 3, 5.0); - ASSERT_FALSE(matrix.isNull()); + PIMathMatrix matrix(3, 3, 5.0); + ASSERT_FALSE(matrix.isNull()); } TEST(PIMathMatrix_Test, isValidTrue) { - PIMathMatrix matrix(3, 3, 1.62); - ASSERT_TRUE(matrix.isValid()); + PIMathMatrix matrix(3, 3, 1.62); + ASSERT_TRUE(matrix.isValid()); } TEST(PIMathMatrix_Test, isValidFalse) { - PIMathMatrix matrix; - ASSERT_FALSE(matrix.isValid()); + PIMathMatrix matrix; + ASSERT_FALSE(matrix.isValid()); } TEST(PIMathMatrix_Test, operator_Assignment) { - PIMathMatrix matrix1(3, 3, 5.72); - PIMathMatrix matrix2(3, 3, 7.12); - matrix1 = matrix2; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.12, 3)); + PIMathMatrix matrix1(3, 3, 5.72); + PIMathMatrix matrix2(3, 3, 7.12); + matrix1 = matrix2; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.12, 3)); } TEST(PIMathMatrix_Test, operator_EqualTrue) { - PIMathMatrix matrix1(2, 2, 2.0); - PIMathMatrix matrix2(2, 2, 2.0); - matrix1.element(0, 0) = 5.1; - matrix1.element(0, 1) = 1.21; - matrix1.element(1, 1) = 0.671; - matrix1.element(1, 0) = 2.623; - matrix2.element(0, 0) = 5.1; - matrix2.element(0, 1) = 1.21; - matrix2.element(1, 1) = 0.671; - matrix2.element(1, 0) = 2.623; - ASSERT_TRUE(matrix1 == matrix2); + PIMathMatrix matrix1(2, 2, 2.0); + PIMathMatrix matrix2(2, 2, 2.0); + matrix1.element(0, 0) = 5.1; + matrix1.element(0, 1) = 1.21; + matrix1.element(1, 1) = 0.671; + matrix1.element(1, 0) = 2.623; + matrix2.element(0, 0) = 5.1; + matrix2.element(0, 1) = 1.21; + matrix2.element(1, 1) = 0.671; + matrix2.element(1, 0) = 2.623; + ASSERT_TRUE(matrix1 == matrix2); } TEST(PIMathMatrix_Test, operator_EqualFalse) { - PIMathMatrix matrix1(2, 2, 2.0); - PIMathMatrix matrix2(2, 2, 2.0); - matrix1.element(0, 0) = 5.1; - matrix1.element(0, 1) = 1.21; - matrix1.element(1, 1) = 0.671; - matrix1.element(1, 0) = 2.623; - matrix2.element(0, 0) = 5.1; - matrix2.element(0, 1) = 1.21; - matrix2.element(1, 1) = 665.671; - matrix2.element(1, 0) = 2.623; - ASSERT_FALSE(matrix1 == matrix2); + PIMathMatrix matrix1(2, 2, 2.0); + PIMathMatrix matrix2(2, 2, 2.0); + matrix1.element(0, 0) = 5.1; + matrix1.element(0, 1) = 1.21; + matrix1.element(1, 1) = 0.671; + matrix1.element(1, 0) = 2.623; + matrix2.element(0, 0) = 5.1; + matrix2.element(0, 1) = 1.21; + matrix2.element(1, 1) = 665.671; + matrix2.element(1, 0) = 2.623; + ASSERT_FALSE(matrix1 == matrix2); } TEST(PIMathMatrix_Test, operator_Not_EqualTrue) { - PIMathMatrix matrix1(2, 2, 2.0); - PIMathMatrix matrix2(2, 2, 2.0); - matrix1.element(0, 0) = 5.1; - matrix1.element(0, 1) = 1.21; - matrix1.element(1, 1) = 0.671; - matrix1.element(1, 0) = 2.623; - matrix2.element(0, 0) = 5.1; - matrix2.element(0, 1) = 1.21; - matrix2.element(1, 1) = 665.671; - matrix2.element(1, 0) = 2.623; - ASSERT_TRUE(matrix1 != matrix2); + PIMathMatrix matrix1(2, 2, 2.0); + PIMathMatrix matrix2(2, 2, 2.0); + matrix1.element(0, 0) = 5.1; + matrix1.element(0, 1) = 1.21; + matrix1.element(1, 1) = 0.671; + matrix1.element(1, 0) = 2.623; + matrix2.element(0, 0) = 5.1; + matrix2.element(0, 1) = 1.21; + matrix2.element(1, 1) = 665.671; + matrix2.element(1, 0) = 2.623; + ASSERT_TRUE(matrix1 != matrix2); } TEST(PIMathMatrix_Test, operator_Not_EqualFalse) { - PIMathMatrix matrix1(2, 2, 2.0); - PIMathMatrix matrix2(2, 2, 2.0); - matrix1.element(0, 0) = 5.1; - matrix1.element(0, 1) = 1.21; - matrix1.element(1, 1) = 0.671; - matrix1.element(1, 0) = 2.623; - matrix2.element(0, 0) = 5.1; - matrix2.element(0, 1) = 1.21; - matrix2.element(1, 1) = 0.671; - matrix2.element(1, 0) = 2.623; - ASSERT_FALSE(matrix1 != matrix2); + PIMathMatrix matrix1(2, 2, 2.0); + PIMathMatrix matrix2(2, 2, 2.0); + matrix1.element(0, 0) = 5.1; + matrix1.element(0, 1) = 1.21; + matrix1.element(1, 1) = 0.671; + matrix1.element(1, 0) = 2.623; + matrix2.element(0, 0) = 5.1; + matrix2.element(0, 1) = 1.21; + matrix2.element(1, 1) = 0.671; + matrix2.element(1, 0) = 2.623; + ASSERT_FALSE(matrix1 != matrix2); } TEST(PIMathMatrix_Test, operator_Addition_Aassignment) { - PIMathMatrix matrix1(3, 3, 6.72); - PIMathMatrix matrix2(3, 3, 1.0); - matrix1 += matrix2; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.72, 3)); + PIMathMatrix matrix1(3, 3, 6.72); + PIMathMatrix matrix2(3, 3, 1.0); + matrix1 += matrix2; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.72, 3)); } TEST(PIMathMatrix_Test, operator_Subtraction_Assignment) { - PIMathMatrix matrix1(3, 3, 1.0); - PIMathMatrix matrix2(3, 3, 6.72); - matrix1 -= matrix2; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, -5.72, 3)); + PIMathMatrix matrix1(3, 3, 1.0); + PIMathMatrix matrix2(3, 3, 6.72); + matrix1 -= matrix2; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, -5.72, 3)); } TEST(PIMathMatrix_Test, operator_Multiplication_Assignment) { - PIMathMatrix matrix1(3, 3, 6.72); - matrix1 *= 2.0; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 13.44, 3)); + PIMathMatrix matrix1(3, 3, 6.72); + matrix1 *= 2.0; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 13.44, 3)); } TEST(PIMathMatrix_Test, operator_Division_Assignment) { - PIMathMatrix matrix1(3, 3, 6.72); - matrix1 /= 2.0; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 3.36, 3)); + PIMathMatrix matrix1(3, 3, 6.72); + matrix1 /= 2.0; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 3.36, 3)); } TEST(PIMathMatrix_Test, operator_Addition) { - PIMathMatrix matrix1(3, 3, 6.72); - PIMathMatrix matrix2(3, 3, 8.28); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 + matrix2, 15.0, 3)); + PIMathMatrix matrix1(3, 3, 6.72); + PIMathMatrix matrix2(3, 3, 8.28); + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 + matrix2, 15.0, 3)); } TEST(PIMathMatrix_Test, operator_Subtraction) { - PIMathMatrix matrix1(3, 3, 6.0); - PIMathMatrix matrix2(3, 3, 5.0); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 - matrix2, 1.0, 3)); + PIMathMatrix matrix1(3, 3, 6.0); + PIMathMatrix matrix2(3, 3, 5.0); + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 - matrix2, 1.0, 3)); } TEST(PIMathMatrix_Test, operator_Multiplication) { - PIMathMatrix matrix1(3, 3, 6.72); - PIMathMatrix matrix2(3, 3, 5.0); - matrix2 = matrix1*4.0; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix2, 26.88, 3)); + PIMathMatrix matrix1(3, 3, 6.72); + PIMathMatrix matrix2(3, 3, 5.0); + matrix2 = matrix1*4.0; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix2, 26.88, 3)); } TEST(PIMathMatrix_Test, operator_Division) { - PIMathMatrix matrix1(3, 3, 6.72); - PIMathMatrix matrix2(3, 3, 5.0); - matrix2 = matrix1/4.0; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix2, 1.68, 3)); + PIMathMatrix matrix1(3, 3, 6.72); + PIMathMatrix matrix2(3, 3, 5.0); + matrix2 = matrix1/4.0; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix2, 1.68, 3)); } TEST(PIMathMatrix_Test, determinantIfSquare) { - double d; - double i = 59.0; - PIMathMatrix matrix(3, 3, 0.0); - PIMathVector vector; - vector.resize(3, 3.0); - vector[0] = 3.0; - vector[1] = 6.0; - vector[2] = 8.0; - matrix.setCol(0, vector); - vector[0] = 2.0; - vector[1] = 1.0; - vector[2] = 4.0; - matrix.setCol(1, vector); - vector[0] = 6.0; - vector[1] = 2.0; - vector[2] = 5.0; - matrix.setCol(2, vector); - d = matrix.determinant(); - ASSERT_DOUBLE_EQ(d, i); + double d; + double i = 59.0; + PIMathMatrix matrix(3, 3, 0.0); + PIMathVector vector; + vector.resize(3, 3.0); + vector[0] = 3.0; + vector[1] = 6.0; + vector[2] = 8.0; + matrix.setCol(0, vector); + vector[0] = 2.0; + vector[1] = 1.0; + vector[2] = 4.0; + matrix.setCol(1, vector); + vector[0] = 6.0; + vector[1] = 2.0; + vector[2] = 5.0; + matrix.setCol(2, vector); + d = matrix.determinant(); + ASSERT_DOUBLE_EQ(d, i); } TEST(PIMathMatrix_Test, determinantIfNotSquare) { - PIMathMatrix matrix(3, 5, 1.0); - matrix.element(1,1) = 5.0; - ASSERT_FALSE(matrix.determinant()); + PIMathMatrix matrix(3, 5, 1.0); + matrix.element(1,1) = 5.0; + ASSERT_FALSE(matrix.determinant()); } TEST(PIMathMatrix_Test, trace) { - PIMathMatrix matrix(3, 3, 0.0); - double t; - double i = 9.0; - PIMathVector vector; - vector.resize(3, 3.0); - vector[0] = 3.0; - vector[1] = 6.0; - vector[2] = 8.0; - matrix.setCol(0, vector); - vector[0] = 2.0; - vector[1] = 1.0; - vector[2] = 4.0; - matrix.setCol(1, vector); - vector[0] = 6.0; - vector[1] = 2.0; - vector[2] = 5.0; - matrix.setCol(2, vector); - t = matrix.trace(); - ASSERT_DOUBLE_EQ(t, i); + PIMathMatrix matrix(3, 3, 0.0); + double t; + double i = 9.0; + PIMathVector vector; + vector.resize(3, 3.0); + vector[0] = 3.0; + vector[1] = 6.0; + vector[2] = 8.0; + matrix.setCol(0, vector); + vector[0] = 2.0; + vector[1] = 1.0; + vector[2] = 4.0; + matrix.setCol(1, vector); + vector[0] = 6.0; + vector[1] = 2.0; + vector[2] = 5.0; + matrix.setCol(2, vector); + t = matrix.trace(); + ASSERT_DOUBLE_EQ(t, i); } TEST(PIMathMatrix_Test, traceIfNotSquare) { - PIMathMatrix matrix(3, 5, 1.0); - matrix.element(1,1) = 5.0; - ASSERT_FALSE(matrix.trace()); + PIMathMatrix matrix(3, 5, 1.0); + matrix.element(1,1) = 5.0; + ASSERT_FALSE(matrix.trace()); } TEST(PIMathMatrix_Test, toUpperTriangular) { - PIMathMatrix matrix(3, 3, 0.0); - double d1, d2 = 1; - int i; - PIMathVector vector; - vector.resize(3, 3.0); - vector[0] = 3.0; - vector[1] = 6.0; - vector[2] = 8.0; - matrix.setCol(0, vector); - vector[0] = 2.0; - vector[1] = 1.0; - vector[2] = 4.0; - matrix.setCol(1, vector); - vector[0] = 6.0; - vector[1] = 2.0; - vector[2] = 5.0; - matrix.setCol(2, vector); - d1 = matrix.determinant(); - matrix.toUpperTriangular(); - for(i = 0; i < 3; i++) - { - d2 = d2 * matrix.element(i, i); - } - ASSERT_DOUBLE_EQ(d1, d2); + PIMathMatrix matrix(3, 3, 0.0); + double d1, d2 = 1; + int i; + PIMathVector vector; + vector.resize(3, 3.0); + vector[0] = 3.0; + vector[1] = 6.0; + vector[2] = 8.0; + matrix.setCol(0, vector); + vector[0] = 2.0; + vector[1] = 1.0; + vector[2] = 4.0; + matrix.setCol(1, vector); + vector[0] = 6.0; + vector[1] = 2.0; + vector[2] = 5.0; + matrix.setCol(2, vector); + d1 = matrix.determinant(); + matrix.toUpperTriangular(); + for(i = 0; i < 3; i++) + { + d2 = d2 * matrix.element(i, i); + } + ASSERT_DOUBLE_EQ(d1, d2); } TEST(PIMathMatrix_Test, invert) { - double d1, d2; - PIMathMatrix matrix1(3, 3, 0.0); - PIMathMatrix matrix2(3, 3, 0.0); - PIMathMatrix matrix3(3, 3, 0.0); - PIMathMatrix matrix4(3, 3, 0.0); - PIMathVector vector; - vector.resize(3, 3.0); - vector[0] = 3.0; - vector[1] = 6.0; - vector[2] = 8.0; - matrix1.setCol(0, vector); - vector[0] = 2.0; - vector[1] = 1.0; - vector[2] = 4.0; - matrix1.setCol(1, vector); - vector[0] = 6.0; - vector[1] = 2.0; - vector[2] = 5.0; - matrix1.setCol(2, vector); - d1 = matrix1.determinant(); - matrix2 = matrix1; - matrix2.invert(); - d2 = matrix2.determinant(); - matrix4.invert(); - ASSERT_TRUE((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000)); + double d1, d2; + PIMathMatrix matrix1(3, 3, 0.0); + PIMathMatrix matrix2(3, 3, 0.0); + PIMathMatrix matrix3(3, 3, 0.0); + PIMathMatrix matrix4(3, 3, 0.0); + PIMathVector vector; + vector.resize(3, 3.0); + vector[0] = 3.0; + vector[1] = 6.0; + vector[2] = 8.0; + matrix1.setCol(0, vector); + vector[0] = 2.0; + vector[1] = 1.0; + vector[2] = 4.0; + matrix1.setCol(1, vector); + vector[0] = 6.0; + vector[1] = 2.0; + vector[2] = 5.0; + matrix1.setCol(2, vector); + d1 = matrix1.determinant(); + matrix2 = matrix1; + matrix2.invert(); + d2 = matrix2.determinant(); + matrix4.invert(); + ASSERT_TRUE((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000)); } TEST(PIMathMatrix_Test, inverted) { - double d1, d2; - PIMathMatrix matrix1(3, 3, 0.0); - PIMathMatrix matrix2(3, 3, 0.0); - PIMathMatrix matrix3(3, 3, 0.0); - PIMathMatrix matrix4(3, 3, 0.0); - PIMathVector vector; - vector.resize(3, 3.0); - vector[0] = 3.0; - vector[1] = 6.0; - vector[2] = 8.0; - matrix1.setCol(0, vector); - vector[0] = 2.0; - vector[1] = 1.0; - vector[2] = 4.0; - matrix1.setCol(1, vector); - vector[0] = 6.0; - vector[1] = 2.0; - vector[2] = 5.0; - matrix1.setCol(2, vector); - d1 = matrix1.determinant(); - matrix2 = matrix1; - matrix1 = matrix2.invert(); - d2 = matrix1.determinant(); - matrix3 = matrix4.invert(); - ASSERT_TRUE((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000)); + double d1, d2; + PIMathMatrix matrix1(3, 3, 0.0); + PIMathMatrix matrix2(3, 3, 0.0); + PIMathMatrix matrix3(3, 3, 0.0); + PIMathMatrix matrix4(3, 3, 0.0); + PIMathVector vector; + vector.resize(3, 3.0); + vector[0] = 3.0; + vector[1] = 6.0; + vector[2] = 8.0; + matrix1.setCol(0, vector); + vector[0] = 2.0; + vector[1] = 1.0; + vector[2] = 4.0; + matrix1.setCol(1, vector); + vector[0] = 6.0; + vector[1] = 2.0; + vector[2] = 5.0; + matrix1.setCol(2, vector); + d1 = matrix1.determinant(); + matrix2 = matrix1; + matrix1 = matrix2.invert(); + d2 = matrix1.determinant(); + matrix3 = matrix4.invert(); + ASSERT_TRUE((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000)); } TEST(PIMathMatrix_Test, transposed) { - PIMathMatrix origMatr; - double d1, d2; - PIMathMatrix matrix1; - PIMathMatrix matrix2; - PIMathMatrix matrix3; - PIMathVector vector; - vector.resize(3, 3.0); - vector[0] = 3.0; - vector[1] = 6.0; - vector[2] = 8.0; - matrix1.setCol(0, vector); - vector[0] = 2.0; - vector[1] = 1.0; - vector[2] = 4.0; - matrix1.setCol(1, vector); - vector[0] = 6.0; - vector[1] = 2.0; - vector[2] = 5.0; - matrix1.setCol(2, vector); - d1 = matrix1.determinant(); - matrix2 = matrix1.transposed(); - d2 = matrix2.determinant(); - matrix3 = matrix2.transposed(); - ASSERT_TRUE((d1 == d2) && (matrix1 == matrix3)); + PIMathMatrix origMatr; + double d1, d2; + PIMathMatrix matrix1; + PIMathMatrix matrix2; + PIMathMatrix matrix3; + PIMathVector vector; + vector.resize(3, 3.0); + vector[0] = 3.0; + vector[1] = 6.0; + vector[2] = 8.0; + matrix1.setCol(0, vector); + vector[0] = 2.0; + vector[1] = 1.0; + vector[2] = 4.0; + matrix1.setCol(1, vector); + vector[0] = 6.0; + vector[1] = 2.0; + vector[2] = 5.0; + matrix1.setCol(2, vector); + d1 = matrix1.determinant(); + matrix2 = matrix1.transposed(); + d2 = matrix2.determinant(); + matrix3 = matrix2.transposed(); + ASSERT_TRUE((d1 == d2) && (matrix1 == matrix3)); } TEST(PIMathMatrix_Test, matrixMultiplication) { - PIMathMatrix matrix1(2, 2, 1.5); - PIMathMatrix matrix2(2, 2, 2.5); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 7.5, 2)); + PIMathMatrix matrix1(2, 2, 1.5); + PIMathMatrix matrix2(2, 2, 2.5); + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 7.5, 2)); } TEST(PIMathMatrix_Test, matrixAndVectorMultiplication) { - PIMathMatrix matrix1(2, 2, 1.5); - PIMathVector vector; - vector.resize(2, 2.5); - for(uint i = 0; i < 2; i++) { - if((matrix1 * vector)[i] != 7.5) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + PIMathMatrix matrix1(2, 2, 1.5); + PIMathVector vector; + vector.resize(2, 2.5); + for(uint i = 0; i < 2; i++) { + if((matrix1 * vector)[i] != 7.5) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrix_Test, vectorAndMatrixMultiplication) { - PIMathMatrix matrix1(2, 2, 1.5); - PIMathVector vector; - vector.resize(2, 2.5); - for(uint i = 0; i < 2; i++) { - if((vector * matrix1)[i] != 7.5) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + PIMathMatrix matrix1(2, 2, 1.5); + PIMathVector vector; + vector.resize(2, 2.5); + for(uint i = 0; i < 2; i++) { + if((vector * matrix1)[i] != 7.5) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrix_Test, valAndMatrixMultiplication) { - PIMathMatrix matrix1(3, 3, 1.5); - ASSERT_TRUE(cmpSquareMatrixWithValue(25.0*matrix1, 37.5, 3)); + PIMathMatrix matrix1(3, 3, 1.5); + ASSERT_TRUE(cmpSquareMatrixWithValue(25.0*matrix1, 37.5, 3)); } TEST(PIMathMatrix_Test, hermitian) { - complex val; - complex res; - val.imag(1.0); - val.real(1.0); - PIMathMatrix> matrix(3, 3, val); - res.imag(-1.0); - res.real(1.0); - auto matr = hermitian(matrix); - for(uint i = 0; i < 3; i++) { - for(uint j = 0; j < 3; j++) { - if(matr.element(i, j) != res) { - ASSERT_TRUE(false); - } - } - } - ASSERT_TRUE(true); + complex val; + complex res; + val.imag(1.0); + val.real(1.0); + PIMathMatrix> matrix(3, 3, val); + res.imag(-1.0); + res.real(1.0); + auto matr = hermitian(matrix); + for(uint i = 0; i < 3; i++) { + for(uint j = 0; j < 3; j++) { + if(matr.element(i, j) != res) { + ASSERT_TRUE(false); + } + } + } + ASSERT_TRUE(true); } diff --git a/tests/math/testpimathmatrixt.cpp b/tests/math/testpimathmatrixt.cpp index 013672ba..59cd14c9 100644 --- a/tests/math/testpimathmatrixt.cpp +++ b/tests/math/testpimathmatrixt.cpp @@ -5,558 +5,558 @@ const uint rows = 3; const uint cols = 3; bool cmpSquareMatrixWithValue(PIMathMatrixT matrix, double val, int num) { - bool b = true; - for(int i = 0; i < num; i++) { - for(int j = 0; j < num; j++) { - if(matrix[i][j] - val >= double(1E-200)) { - b = false; - } - } - } - return b; + bool b = true; + for(int i = 0; i < num; i++) { + for(int j = 0; j < num; j++) { + if(matrix[i][j] - val >= double(1E-200)) { + b = false; + } + } + } + return b; } TEST(PIMathMatrixT_Test, 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); - } - } - else { - if(matrix[i][i] != 1.0){ - ASSERT_TRUE(false); - } - } - } - } - ASSERT_TRUE(true); + 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); + } + } + else { + if(matrix[i][i] != 1.0){ + ASSERT_TRUE(false); + } + } + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrixT_Test, at) { - auto matrix1 = PIMathMatrixT::identity(); - for(uint i = 0; i < rows; i++) { - if(matrix1.at(i,i) != 1.0) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + auto matrix1 = PIMathMatrixT::identity(); + for(uint i = 0; i < rows; i++) { + if(matrix1.at(i,i) != 1.0) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrixT_Test, filled) { - auto matr = PIMathMatrixT::filled(1.0); - ASSERT_TRUE(cmpSquareMatrixWithValue(matr, 1.0, rows)); + auto matr = PIMathMatrixT::filled(1.0); + ASSERT_TRUE(cmpSquareMatrixWithValue(matr, 1.0, rows)); } TEST(PIMathMatrixT_Test, cols) { - PIMathMatrixT matr; - ASSERT_EQ(cols,matr.cols()); + PIMathMatrixT matr; + ASSERT_EQ(cols,matr.cols()); } TEST(PIMathMatrixT_Test, rows) { - PIMathMatrixT matr; - ASSERT_EQ(rows,matr.rows()); + PIMathMatrixT matr; + ASSERT_EQ(rows,matr.rows()); } TEST(PIMathMatrixT_Test, col) { - PIMathMatrixT matr; - PIMathVectorT vect; - uint g = 2; - matr[0][0] = 3; - matr[0][1] = 6; - matr[0][2] = 8; - matr[1][0] = 2; - matr[1][1] = 1; - matr[1][2] = 4; - matr[2][0] = 6; - matr[2][1] = 2; - matr[2][2] = 5; - vect = matr.col(g); - for(uint i = 0; i < matr.cols(); i++) { - if(matr.at(i, g) != vect.at(i)) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + PIMathMatrixT matr; + PIMathVectorT vect; + uint g = 2; + matr[0][0] = 3; + matr[0][1] = 6; + matr[0][2] = 8; + matr[1][0] = 2; + matr[1][1] = 1; + matr[1][2] = 4; + matr[2][0] = 6; + matr[2][1] = 2; + matr[2][2] = 5; + vect = matr.col(g); + for(uint i = 0; i < matr.cols(); i++) { + if(matr.at(i, g) != vect.at(i)) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrixT_Test, row) { - PIMathMatrixT matr; - PIMathVectorT vect; - uint g = 2; - matr[0][0] = 3; - matr[0][1] = 6; - matr[0][2] = 8; - matr[1][0] = 2; - matr[1][1] = 1; - matr[1][2] = 4; - matr[2][0] = 6; - matr[2][1] = 2; - matr[2][2] = 5; - vect = matr.row(g); - for(uint i = 0; i < matr.rows(); i++) { - if(matr.at(g, i) != vect.at(i)) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + PIMathMatrixT matr; + PIMathVectorT vect; + uint g = 2; + matr[0][0] = 3; + matr[0][1] = 6; + matr[0][2] = 8; + matr[1][0] = 2; + matr[1][1] = 1; + matr[1][2] = 4; + matr[2][0] = 6; + matr[2][1] = 2; + matr[2][2] = 5; + vect = matr.row(g); + for(uint i = 0; i < matr.rows(); i++) { + if(matr.at(g, i) != vect.at(i)) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrixT_Test, setCol) { - PIMathMatrixT matr; - PIMathVectorT vect; - vect[0] = 1.0; - vect[1] = 3.0; - vect[2] = 5.0; - uint g = 1; - matr.setCol(g, vect); - for(uint i = 0; i < vect.size(); i++) { - if(matr.at(i, g) != vect.at(i)) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + PIMathMatrixT matr; + PIMathVectorT vect; + vect[0] = 1.0; + vect[1] = 3.0; + vect[2] = 5.0; + uint g = 1; + matr.setCol(g, vect); + for(uint i = 0; i < vect.size(); i++) { + if(matr.at(i, g) != vect.at(i)) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrixT_Test, setRow) { - PIMathMatrixT matr; - PIMathVectorT vect; - vect[0] = 1.0; - vect[1] = 3.0; - vect[2] = 5.0; - uint g = 1; - matr.setRow(g, vect); - for(uint i = 0; i < vect.size(); i++) { - if(matr.at(g,i) != vect.at(i)) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + PIMathMatrixT matr; + PIMathVectorT vect; + vect[0] = 1.0; + vect[1] = 3.0; + vect[2] = 5.0; + uint g = 1; + matr.setRow(g, vect); + for(uint i = 0; i < vect.size(); i++) { + if(matr.at(g,i) != vect.at(i)) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrixT_Test, swapCols) { - PIMathMatrixT matr; - int g1 = 1, g2 = 2; - matr[0][0] = 3; - matr[0][1] = 6; - matr[0][2] = 8; - matr[1][0] = 2; - matr[1][1] = 1; - matr[1][2] = 4; - matr[2][0] = 6; - matr[2][1] = 2; - matr[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); - if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1)) { - ASSERT_TRUE(true); - } - else { - ASSERT_TRUE(false); - } + PIMathMatrixT matr; + int g1 = 1, g2 = 2; + matr[0][0] = 3; + matr[0][1] = 6; + matr[0][2] = 8; + matr[1][0] = 2; + matr[1][1] = 1; + matr[1][2] = 4; + matr[2][0] = 6; + matr[2][1] = 2; + matr[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); + if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1)) { + ASSERT_TRUE(true); + } + else { + ASSERT_TRUE(false); + } } TEST(PIMathMatrixT_Test, swapRows) { - PIMathMatrixT matr; - int g1 = 1, g2 = 2; - matr[0][0] = 3; - matr[0][1] = 6; - matr[0][2] = 8; - matr[1][0] = 2; - matr[1][1] = 1; - matr[1][2] = 4; - matr[2][0] = 6; - matr[2][1] = 2; - matr[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); - if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1)) { - ASSERT_TRUE(true); - } - else { - ASSERT_TRUE(false); - } + PIMathMatrixT matr; + int g1 = 1, g2 = 2; + matr[0][0] = 3; + matr[0][1] = 6; + matr[0][2] = 8; + matr[1][0] = 2; + matr[1][1] = 1; + matr[1][2] = 4; + matr[2][0] = 6; + matr[2][1] = 2; + matr[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); + if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1)) { + ASSERT_TRUE(true); + } + else { + ASSERT_TRUE(false); + } } TEST(PIMathMatrixT_Test, fill) { - PIMathMatrixT matr; - PIMathMatrixT matrix1; - double g = 1.0; - matr.fill(g); - for(uint i = 0; i < cols; i++) { - for(uint j = 0; j < rows; j++) { - matrix1[j][i] = g; - } - } - ASSERT_TRUE(matr == matrix1); + PIMathMatrixT matr; + PIMathMatrixT matrix1; + double g = 1.0; + matr.fill(g); + for(uint i = 0; i < cols; i++) { + for(uint j = 0; j < rows; j++) { + matrix1[j][i] = g; + } + } + ASSERT_TRUE(matr == matrix1); } TEST(PIMathMatrixT_Test, isSquareTrue) { - PIMathMatrixT matrix1; - ASSERT_TRUE(matrix1.isSquare()); + PIMathMatrixT matrix1; + ASSERT_TRUE(matrix1.isSquare()); } TEST(PIMathMatrixT_Test, isSquareFalse) { - const uint new_Cols = 4; - PIMathMatrixT matrix2; - ASSERT_FALSE(matrix2.isSquare()); + const uint new_Cols = 4; + PIMathMatrixT matrix2; + ASSERT_FALSE(matrix2.isSquare()); } TEST(PIMathMatrixT_Test, isIdentityTrue) { - auto matrix1 = PIMathMatrixT::identity(); - ASSERT_TRUE(matrix1.isIdentity()); + auto matrix1 = PIMathMatrixT::identity(); + ASSERT_TRUE(matrix1.isIdentity()); } TEST(PIMathMatrixT_Test, isIdentityFalse) { - auto matrix1 = PIMathMatrixT::filled(2.5); - ASSERT_FALSE(matrix1.isIdentity()); + auto matrix1 = PIMathMatrixT::filled(2.5); + ASSERT_FALSE(matrix1.isIdentity()); } TEST(PIMathMatrixT_Test, isNullTrue) { - PIMathMatrixT matrix1; - ASSERT_TRUE(matrix1.isNull()); + PIMathMatrixT matrix1; + ASSERT_TRUE(matrix1.isNull()); } TEST(PIMathMatrixT_Test, isNullFalse) { - auto matrix1 = PIMathMatrixT::identity(); - ASSERT_FALSE(matrix1.isNull()); + auto matrix1 = PIMathMatrixT::identity(); + ASSERT_FALSE(matrix1.isNull()); } TEST(PIMathMatrixT_Test, operator_Assignment) { - PIMathMatrixT matrix1; - auto matrix2 = PIMathMatrixT::filled(6.72); - matrix1 = matrix2; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 6.72, rows)); + PIMathMatrixT matrix1; + auto matrix2 = PIMathMatrixT::filled(6.72); + matrix1 = matrix2; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 6.72, rows)); } TEST(PIMathMatrixT_Test, operator_EqualTrue) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; - matrix1[0][0] = 5.1; - matrix1[0][1] = 1.21; - matrix1[1][1] = 0.671; - matrix1[1][0] = 2.623; - matrix2[0][0] = 5.1; - matrix2[0][1] = 1.21; - matrix2[1][1] = 0.671; - matrix2[1][0] = 2.623; - ASSERT_TRUE(matrix1 == matrix2); + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; + matrix1[0][0] = 5.1; + matrix1[0][1] = 1.21; + matrix1[1][1] = 0.671; + matrix1[1][0] = 2.623; + matrix2[0][0] = 5.1; + matrix2[0][1] = 1.21; + matrix2[1][1] = 0.671; + matrix2[1][0] = 2.623; + ASSERT_TRUE(matrix1 == matrix2); } TEST(PIMathMatrixT_Test, operator_EqualFalse) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; - matrix1[0][0] = 5.1; - matrix1[0][1] = 1.21; - matrix1[1][1] = 0.671; - matrix1[1][0] = 2.623; - matrix2[0][0] = 5.1; - matrix2[0][1] = 1.21; - matrix2[1][1] = 665.671; - matrix2[1][0] = 2.623; - ASSERT_FALSE(matrix1 == matrix2); + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; + matrix1[0][0] = 5.1; + matrix1[0][1] = 1.21; + matrix1[1][1] = 0.671; + matrix1[1][0] = 2.623; + matrix2[0][0] = 5.1; + matrix2[0][1] = 1.21; + matrix2[1][1] = 665.671; + matrix2[1][0] = 2.623; + ASSERT_FALSE(matrix1 == matrix2); } TEST(PIMathMatrixT_Test, operator_Not_EqualTrue) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; - matrix1[0][0] = 5.1; - matrix1[0][1] = 1.21; - matrix1[1][1] = 0.671; - matrix1[1][0] = 2.623; - matrix2[0][0] = 5.1; - matrix2[0][1] = 1.21; - matrix2[1][1] = 665.671; - matrix2[1][0] = 2.623; - ASSERT_TRUE(matrix1 != matrix2); + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; + matrix1[0][0] = 5.1; + matrix1[0][1] = 1.21; + matrix1[1][1] = 0.671; + matrix1[1][0] = 2.623; + matrix2[0][0] = 5.1; + matrix2[0][1] = 1.21; + matrix2[1][1] = 665.671; + matrix2[1][0] = 2.623; + ASSERT_TRUE(matrix1 != matrix2); } TEST(PIMathMatrixT_Test, operator_Not_EqualFalse) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; - matrix1[0][0] = 5.1; - matrix1[0][1] = 1.21; - matrix1[1][1] = 0.671; - matrix1[1][0] = 2.623; - matrix2[0][0] = 5.1; - matrix2[0][1] = 1.21; - matrix2[1][1] = 0.671; - matrix2[1][0] = 2.623; - ASSERT_FALSE(matrix1 != matrix2); + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; + matrix1[0][0] = 5.1; + matrix1[0][1] = 1.21; + matrix1[1][1] = 0.671; + matrix1[1][0] = 2.623; + matrix2[0][0] = 5.1; + matrix2[0][1] = 1.21; + matrix2[1][1] = 0.671; + matrix2[1][0] = 2.623; + ASSERT_FALSE(matrix1 != matrix2); } TEST(PIMathMatrixT_Test, operator_Addition_Assignment) { - auto matrix1 = PIMathMatrixT::filled(6.72) ; - auto matrix2 = PIMathMatrixT::filled(1.0) ; - matrix1 += matrix2; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.72, rows)); + auto matrix1 = PIMathMatrixT::filled(6.72) ; + auto matrix2 = PIMathMatrixT::filled(1.0) ; + matrix1 += matrix2; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.72, rows)); } TEST(PIMathMatrixT_Test, operator_Subtraction_Assignment) { - auto matrix1 = PIMathMatrixT::filled(1.0); - auto matrix2 = PIMathMatrixT::filled(6.72); - matrix1 -= matrix2; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, -5.72, rows)); + auto matrix1 = PIMathMatrixT::filled(1.0); + auto matrix2 = PIMathMatrixT::filled(6.72); + matrix1 -= matrix2; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, -5.72, rows)); } TEST(PIMathMatrixT_Test, operator_Multiplication_Assignment) { - auto matrix1 = PIMathMatrixT::filled(6.72); - matrix1 *= 2.0; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 13.44, rows)); + auto matrix1 = PIMathMatrixT::filled(6.72); + matrix1 *= 2.0; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 13.44, rows)); } TEST(PIMathMatrixT_Test, operator_Division_Assignment) { - auto matrix1 = PIMathMatrixT::filled(6.72); - matrix1 /= 2.0; - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 3.36, rows)); + auto matrix1 = PIMathMatrixT::filled(6.72); + matrix1 /= 2.0; + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 3.36, rows)); } TEST(PIMathMatrixT_Test, operator_Addition) { - auto matrix1 = PIMathMatrixT::filled(6.72); - auto matrix2 = PIMathMatrixT::filled(8.28); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 + matrix2, 15.0, rows)); + auto matrix1 = PIMathMatrixT::filled(6.72); + auto matrix2 = PIMathMatrixT::filled(8.28); + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 + matrix2, 15.0, rows)); } TEST(PIMathMatrixT_Test, operator_Subtraction) { - auto matrix1 = PIMathMatrixT::filled(6.0); - auto matrix2 = PIMathMatrixT::filled(5.0); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 - matrix2, 1.0, rows)); + auto matrix1 = PIMathMatrixT::filled(6.0); + auto matrix2 = PIMathMatrixT::filled(5.0); + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 - matrix2, 1.0, rows)); } TEST(PIMathMatrixT_Test, operator_Multiplication) { - auto matrix1 = PIMathMatrixT::filled(6.72); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * 4.0, 26.88, rows)); + auto matrix1 = PIMathMatrixT::filled(6.72); + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * 4.0, 26.88, rows)); } TEST(PIMathMatrixT_Test, operator_Division) { - auto matrix1 = PIMathMatrixT::filled(6.72); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 / 4.0, 1.68, rows)); + auto matrix1 = PIMathMatrixT::filled(6.72); + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 / 4.0, 1.68, rows)); } TEST(PIMathMatrixT_Test, determinantIfSquare) { - double d; - double i = 59.0; - PIMathMatrixT matr; - matr[0][0] = 3; - matr[0][1] = 6; - matr[0][2] = 8; - matr[1][0] = 2; - matr[1][1] = 1; - matr[1][2] = 4; - matr[2][0] = 6; - matr[2][1] = 2; - matr[2][2] = 5; - d = matr.determinant(); - ASSERT_DOUBLE_EQ(i, d); + double d; + double i = 59.0; + PIMathMatrixT matr; + matr[0][0] = 3; + matr[0][1] = 6; + matr[0][2] = 8; + matr[1][0] = 2; + matr[1][1] = 1; + matr[1][2] = 4; + matr[2][0] = 6; + matr[2][1] = 2; + matr[2][2] = 5; + d = matr.determinant(); + ASSERT_DOUBLE_EQ(i, d); } TEST(PIMathMatrixT_Test, determinantIfNotSquare) { - PIMathMatrixT matr; - matr[0][0] = 3; - matr[0][1] = 6; - matr[0][2] = 8; - matr[1][0] = 2; - matr[1][1] = 1; - matr[1][2] = 4; - matr[2][0] = 6; - matr[2][1] = 2; - matr[2][2] = 5; - ASSERT_FALSE(matr.determinant()); + PIMathMatrixT matr; + matr[0][0] = 3; + matr[0][1] = 6; + matr[0][2] = 8; + matr[1][0] = 2; + matr[1][1] = 1; + matr[1][2] = 4; + matr[2][0] = 6; + matr[2][1] = 2; + matr[2][2] = 5; + ASSERT_FALSE(matr.determinant()); } TEST(PIMathMatrixT_Test, invert) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; - PIMathMatrixT matrix3; - PIMathMatrixT matr; - double d1, d2; - matr[0][0] = 3; - matr[0][1] = 6; - matr[0][2] = 8; - matr[1][0] = 2; - matr[1][1] = 1; - matr[1][2] = 4; - matr[2][0] = 6; - matr[2][1] = 2; - matr[2][2] = 5; - matrix2 = matr; - matr.invert(); - d1 = matr.determinant(); - d2 = matrix2.determinant(); - matrix3 = matrix1; - matrix1.invert(); - ASSERT_TRUE((matrix1 == matrix3) && (d1 == 1/d2)); + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; + PIMathMatrixT matrix3; + PIMathMatrixT matr; + double d1, d2; + matr[0][0] = 3; + matr[0][1] = 6; + matr[0][2] = 8; + matr[1][0] = 2; + matr[1][1] = 1; + matr[1][2] = 4; + matr[2][0] = 6; + matr[2][1] = 2; + matr[2][2] = 5; + matrix2 = matr; + matr.invert(); + d1 = matr.determinant(); + d2 = matrix2.determinant(); + matrix3 = matrix1; + matrix1.invert(); + ASSERT_TRUE((matrix1 == matrix3) && (d1 == 1/d2)); } TEST(PIMathMatrixT_Test, inverted) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; - PIMathMatrixT matrix3; - PIMathMatrixT matr; - double d1, d2; - matrix1 = matr.identity(); - matr[0][0] = 3; - matr[0][1] = 6; - matr[0][2] = 8; - matr[1][0] = 2; - matr[1][1] = 1; - matr[1][2] = 4; - matr[2][0] = 6; - matr[2][1] = 2; - matr[2][2] = 5; - matrix2 = matr.inverted(); - d1 = matr.determinant(); - d2 = matrix2.determinant(); - matrix3 = matrix1.inverted(); - ASSERT_TRUE((matrix1 == matrix3) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000)); + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; + PIMathMatrixT matrix3; + PIMathMatrixT matr; + double d1, d2; + matrix1 = matr.identity(); + matr[0][0] = 3; + matr[0][1] = 6; + matr[0][2] = 8; + matr[1][0] = 2; + matr[1][1] = 1; + matr[1][2] = 4; + matr[2][0] = 6; + matr[2][1] = 2; + matr[2][2] = 5; + matrix2 = matr.inverted(); + d1 = matr.determinant(); + d2 = matrix2.determinant(); + matrix3 = matrix1.inverted(); + ASSERT_TRUE((matrix1 == matrix3) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000)); } TEST(PIMathMatrixT_Test, toUpperTriangular) { - PIMathMatrixT matrix; - double d1, d2 = 1; - PIMathMatrixT matr; - matr[0][0] = 3; - matr[0][1] = 6; - matr[0][2] = 8; - matr[1][0] = 2; - matr[1][1] = 1; - matr[1][2] = 4; - matr[2][0] = 6; - matr[2][1] = 2; - matr[2][2] = 5; - matrix = matr.toUpperTriangular(); - d1 = matrix.determinant(); - for(uint i = 0; i < cols; i++) - { - d2 = d2*matrix.at(i,i); - } - ASSERT_DOUBLE_EQ(d1, d2); + PIMathMatrixT matrix; + double d1, d2 = 1; + PIMathMatrixT matr; + matr[0][0] = 3; + matr[0][1] = 6; + matr[0][2] = 8; + matr[1][0] = 2; + matr[1][1] = 1; + matr[1][2] = 4; + matr[2][0] = 6; + matr[2][1] = 2; + matr[2][2] = 5; + matrix = matr.toUpperTriangular(); + d1 = matrix.determinant(); + for(uint i = 0; i < cols; i++) + { + d2 = d2*matrix.at(i,i); + } + ASSERT_DOUBLE_EQ(d1, d2); } TEST(PIMathMatrixT_Test, transposed) { - PIMathMatrixT matrix1; - PIMathMatrixT matrix2; - PIMathMatrixT matr; - double d1, d2; - matr[0][0] = 3; - matr[0][1] = 6; - matr[0][2] = 8; - matr[1][0] = 2; - matr[1][1] = 1; - matr[1][2] = 4; - matr[2][0] = 6; - matr[2][1] = 2; - matr[2][2] = 5; - d1 = matr.determinant(); - matrix1 = matr.transposed(); - d2 = matrix1.determinant(); - matrix2 = matrix1.transposed(); - ASSERT_TRUE((d1 == d2) && (matr == matrix2)); + PIMathMatrixT matrix1; + PIMathMatrixT matrix2; + PIMathMatrixT matr; + double d1, d2; + matr[0][0] = 3; + matr[0][1] = 6; + matr[0][2] = 8; + matr[1][0] = 2; + matr[1][1] = 1; + matr[1][2] = 4; + matr[2][0] = 6; + matr[2][1] = 2; + matr[2][2] = 5; + d1 = matr.determinant(); + matrix1 = matr.transposed(); + d2 = matrix1.determinant(); + matrix2 = matrix1.transposed(); + ASSERT_TRUE((d1 == d2) && (matr == matrix2)); } TEST(PIMathMatrixT_Test, scaleX_two) { - double factor = 5.64; - PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleX(factor); - ASSERT_TRUE((1.0 == matrix.at(1u,1u)) && (factor == matrix.at(0u,0u))); + double factor = 5.64; + PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleX(factor); + ASSERT_TRUE((1.0 == matrix.at(1u,1u)) && (factor == matrix.at(0u,0u))); } TEST(PIMathMatrixT_Test, scaleY_two) { - double factor = 5.64; - PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleY(factor); - ASSERT_TRUE((factor == matrix.at(1u,1u)) && (1.0 == matrix.at(0u,0u))); + double factor = 5.64; + PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleY(factor); + ASSERT_TRUE((factor == matrix.at(1u,1u)) && (1.0 == matrix.at(0u,0u))); } TEST(PIMathMatrixT_Test, rotation_2x2) { - double angle = 1.0; - PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::rotation(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))); + double angle = 1.0; + PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::rotation(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))); } TEST(PIMathMatrixT_Test, rotation_3x3) { - double angle = 1.0; - PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotation(angle); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, 0.0, rows)); + double angle = 1.0; + PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotation(angle); + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, 0.0, rows)); } TEST(PIMathMatrixT_Test, rotationX) { - double angle = 1.0; - double c = cos(angle); - double s = sin(angle); - PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationX(angle); - ASSERT_TRUE((1.0 == matrix.at(0u,0u)) && (c == matrix.at(1u,1u)) && (c == matrix.at(2u,2u)) && (s == matrix.at(2u,1u)) && (-s == matrix.at(1u,2u))); + double angle = 1.0; + double c = cos(angle); + double s = sin(angle); + PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationX(angle); + ASSERT_TRUE((1.0 == matrix.at(0u,0u)) && (c == matrix.at(1u,1u)) && (c == matrix.at(2u,2u)) && (s == matrix.at(2u,1u)) && (-s == matrix.at(1u,2u))); } TEST(PIMathMatrixT_Test, rotationY) { - double angle = 1.0; - double c = cos(angle); - double s = sin(angle); - PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationY(angle); - ASSERT_TRUE((1.0 == matrix.at(1u,1u)) && (c == matrix.at(0u,0u)) && (c == matrix.at(2u,2u)) && (s == matrix.at(0u,2u)) && (-s == matrix.at(2u,0u))); + double angle = 1.0; + double c = cos(angle); + double s = sin(angle); + PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationY(angle); + ASSERT_TRUE((1.0 == matrix.at(1u,1u)) && (c == matrix.at(0u,0u)) && (c == matrix.at(2u,2u)) && (s == matrix.at(0u,2u)) && (-s == matrix.at(2u,0u))); } TEST(PIMathMatrixT_Test, rotationZ) { - double angle = 1.0; - double c = cos(angle); - double s = sin(angle); - PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationZ(angle); - ASSERT_TRUE((1.0 == matrix.at(2u,2u)) && (c == matrix.at(0u,0u)) && (c == matrix.at(1u,1u)) && (s == matrix.at(1u,0u)) && (-s == matrix.at(0u,1u))); + double angle = 1.0; + double c = cos(angle); + double s = sin(angle); + PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationZ(angle); + ASSERT_TRUE((1.0 == matrix.at(2u,2u)) && (c == matrix.at(0u,0u)) && (c == matrix.at(1u,1u)) && (s == matrix.at(1u,0u)) && (-s == matrix.at(0u,1u))); } TEST(PIMathMatrixT_Test, scaleX_three) { - double factor = 23.65; - PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleX(factor); - ASSERT_TRUE((1.0 == matrix.at(2u,2u)) && (factor == matrix.at(0u,0u)) && (1.0 == matrix.at(1u,1u))); + double factor = 23.65; + PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleX(factor); + ASSERT_TRUE((1.0 == matrix.at(2u,2u)) && (factor == matrix.at(0u,0u)) && (1.0 == matrix.at(1u,1u))); } TEST(PIMathMatrixT_Test, scaleY_three) { - double factor = 23.65; - PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleY(factor); - ASSERT_TRUE((1.0 == matrix.at(2u,2u)) && (1.0 == matrix.at(0u,0u)) && (factor == matrix.at(1u,1u))); + double factor = 23.65; + PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleY(factor); + ASSERT_TRUE((1.0 == matrix.at(2u,2u)) && (1.0 == matrix.at(0u,0u)) && (factor == matrix.at(1u,1u))); } TEST(PIMathMatrixT_Test, scaleZ_three) { - double factor = 23.65; - PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleZ(factor); - ASSERT_TRUE((factor == matrix.at(2u,2u)) && (1.0 == matrix.at(0u,0u)) && (1.0 == matrix.at(1u,1u))); + double factor = 23.65; + PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleZ(factor); + ASSERT_TRUE((factor == matrix.at(2u,2u)) && (1.0 == matrix.at(0u,0u)) && (1.0 == matrix.at(1u,1u))); } TEST(PIMathMatrixT_Test, matrixMultiplication) { - auto matrix1 = PIMathMatrixT::filled(1.5); - auto matrix2 = PIMathMatrixT::filled(2.5); - ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 11.25, 3)); + auto matrix1 = PIMathMatrixT::filled(1.5); + auto matrix2 = PIMathMatrixT::filled(2.5); + ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 11.25, 3)); } TEST(PIMathMatrixT_Test, matrixAndVectorMultiplication) { - auto matrix1 = PIMathMatrixT::filled(1.5); - auto vector = PIMathVectorT::filled(2.5); - for(uint i = 0; i < 2; i++) { - if((matrix1 * vector)[i] != 11.25) { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + auto matrix1 = PIMathMatrixT::filled(1.5); + auto vector = PIMathVectorT::filled(2.5); + for(uint i = 0; i < 2; i++) { + if((matrix1 * vector)[i] != 11.25) { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathMatrixT_Test, vectorAndMatrixMultiplication) { - auto matrix1 = PIMathMatrixT::filled(1.5); - auto vector = PIMathVectorT::filled(2.5); - for(uint i = 0; i < 2; i++) { - if((vector * matrix1)[i] != 11.25) { - ASSERT_TRUE(false); - } - } + auto matrix1 = PIMathMatrixT::filled(1.5); + auto vector = PIMathVectorT::filled(2.5); + for(uint i = 0; i < 2; i++) { + if((vector * matrix1)[i] != 11.25) { + ASSERT_TRUE(false); + } + } } TEST(PIMathMatrixT_Test, valAndMatrixMultiplication) { - auto matrix1 = PIMathMatrixT::filled(1.5); - ASSERT_TRUE(cmpSquareMatrixWithValue(25.0*matrix1, 37.5, 3)); + auto matrix1 = PIMathMatrixT::filled(1.5); + ASSERT_TRUE(cmpSquareMatrixWithValue(25.0*matrix1, 37.5, 3)); } diff --git a/tests/math/testpimathvector.cpp b/tests/math/testpimathvector.cpp index 3556ac55..9ac59f1a 100644 --- a/tests/math/testpimathvector.cpp +++ b/tests/math/testpimathvector.cpp @@ -2,446 +2,622 @@ #include "pimathvector.h" const uint SIZE = 3u; +const double angle45DegInRad = 0.78539816339744830961566084581988; bool cmpVectorWithValue(PIMathVector vector, double val, int num) { - bool b = true; - for(int i = 0; i < num; i++) { - if(vector[i] - val >= double(1E-200)) { - b = false; - } - } - return b; + bool b = true; + for(int i = 0; i < num; i++) { + if(vector[i] - val >= double(1E-200)) { + b = false; + } + } + return b; } TEST(PIMathVector_Test, size) { - auto vector = PIMathVector(SIZE); - ASSERT_TRUE(vector.size() == SIZE); + auto vector = PIMathVector(SIZE); + ASSERT_TRUE(vector.size() == SIZE); } TEST(PIMathVector_Test, resize) { - uint newSize = 4u; - double a = 5.0; - PIMathVector vector; - vector.resize(newSize, a); - ASSERT_TRUE(cmpVectorWithValue(vector, a, vector.size())); - ASSERT_TRUE(vector.size() == newSize); + uint newSize = 4u; + double a = 5.0; + PIMathVector vector; + vector.resize(newSize, a); + ASSERT_TRUE(cmpVectorWithValue(vector, a, vector.size())); + ASSERT_TRUE(vector.size() == newSize); } TEST(PIMathVector_Test, resized) { - uint newSize = 4u; - double a = 5.0; - PIMathVector vector; - auto vect = vector.resized(newSize, a); - ASSERT_TRUE(cmpVectorWithValue(vect, a, vect.size()) && vect.size() == newSize); - ASSERT_TRUE(vect.size() == newSize); + uint newSize = 4u; + double a = 5.0; + PIMathVector vector; + auto vect = vector.resized(newSize, a); + ASSERT_TRUE(cmpVectorWithValue(vect, a, vect.size())); + ASSERT_TRUE(vect.size() == newSize); } TEST(PIMathVector_Test, fill) { - double a = 5.0; - PIMathVector vector(SIZE); - vector.fill(a); - ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); + double a = 5.0; + PIMathVector vector(SIZE); + vector.fill(a); + ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); } TEST(PIMathVector_Test, moveVal) { - double a = 5.0; - PIMathVector vector(SIZE); - vector.fill(a); - vector.move(a); - ASSERT_TRUE(cmpVectorWithValue(vector, 2 * a, SIZE)); + double a = 5.0; + PIMathVector vector(SIZE); + vector.fill(a); + vector.move(a); + ASSERT_TRUE(cmpVectorWithValue(vector, 2 * a, SIZE)); } TEST(PIMathVector_Test, moveVec) { - double a = 5.0; - double b = 7.0; - PIMathVector vector(SIZE); - PIMathVector vec(SIZE); - vector.fill(a); - vec.fill(b); - vector.move(vec); - ASSERT_TRUE(cmpVectorWithValue(vector, a + b, SIZE)); + double a = 5.0; + double b = 7.0; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE); + vector.fill(a); + vec.fill(b); + vector.move(vec); + ASSERT_TRUE(cmpVectorWithValue(vector, a + b, SIZE)); +} + +TEST(PIMathVector_Test, moveVecSizeNotEq) { + double a = 5.0; + double b = 7.0; + uint bias = 2u; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE + bias); + vector.fill(a); + vec.fill(b); + vector.move(vec); + ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); + ASSERT_TRUE(vector.size() == SIZE); } TEST(PIMathVector_Test, swap) { - double b = 5.12; - double c = 3.32; - double d = 7.12; - PIMathVector vector(SIZE); - double a[3]; - vector[0] = b; - vector[1] = c; - vector[2] = d; - a[0] = vector[0]; - a[1] = vector[1]; - a[2] = vector[2]; - vector.swap(0u, 1u); - ASSERT_DOUBLE_EQ(a[0], vector[1]); - ASSERT_DOUBLE_EQ(a[1], vector[0]); - ASSERT_DOUBLE_EQ(a[2], vector[2]); + double b = 5.12; + double c = 3.32; + double d = 7.12; + PIMathVector vector(SIZE); + double a[3]; + vector[0] = b; + vector[1] = c; + vector[2] = d; + a[0] = vector[0]; + a[1] = vector[1]; + a[2] = vector[2]; + vector.swap(0u, 1u); + ASSERT_DOUBLE_EQ(a[0], vector[1]); + ASSERT_DOUBLE_EQ(a[1], vector[0]); + ASSERT_DOUBLE_EQ(a[2], vector[2]); } TEST(PIMathVector_Test, lengthSqr) { - double a = 3.0; - PIMathVector vector(SIZE); - vector.fill(a); - ASSERT_DOUBLE_EQ(SIZE * a * a, vector.lengthSqr()); + double a = 3.0; + PIMathVector vector(SIZE); + vector.fill(a); + ASSERT_DOUBLE_EQ(SIZE * a * a, vector.lengthSqr()); } TEST(PIMathVector_Test, length) { - double a = 3.32; - PIMathVector vector(SIZE); - vector.fill(a); - ASSERT_DOUBLE_EQ(sqrt(SIZE * a * a), vector.length()); + double a = 3.32; + PIMathVector vector(SIZE); + vector.fill(a); + ASSERT_DOUBLE_EQ(sqrt(SIZE * a * a), vector.length()); } TEST(PIMathVector_Test, manhattanLength) { - double a = 3.32; - PIMathVector vector(SIZE); - vector.fill(a); - ASSERT_DOUBLE_EQ(SIZE * a, vector.manhattanLength()); + double a = 3.32; + PIMathVector vector(SIZE); + vector.fill(a); + ASSERT_DOUBLE_EQ(SIZE * a, vector.manhattanLength()); } TEST(PIMathVector_Test, angleCos) { - double a = 3.32; - double angle = 0.78539816339744830961566084581988; - PIMathVector vector(SIZE); - PIMathVector vec(SIZE); - vector[0] = a; - vector[1] = a; - vec[1] = a; - ASSERT_DOUBLE_EQ(cos(angle), vector.angleCos(vec)); + double a = 3.32; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE); + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_DOUBLE_EQ(cos(angle45DegInRad), vector.angleCos(vec)); +} + +TEST(PIMathVector_Test, angleCosSizeNotEq) { + double a = 3.32; + uint bias = 2u; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE + bias); + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_FALSE(vector.angleCos(vec)); } TEST(PIMathVector_Test, angleSin) { - double a = 3.32; - double angle = 0.78539816339744830961566084581988; - PIMathVector vector(SIZE); - PIMathVector vec(SIZE); - vector[0] = a; - vector[1] = a; - vec[1] = a; - ASSERT_DOUBLE_EQ(sin(angle), vector.angleSin(vec)); + double a = 3.32; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE); + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_DOUBLE_EQ(sin(angle45DegInRad), vector.angleSin(vec)); +} + +TEST(PIMathVector_Test, angleSinSizeNotEq) { + double a = 3.32; + uint bias = 2u; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE + bias); + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_FALSE(vector.angleSin(vec)); } TEST(PIMathVector_Test, angleRad) { - double a = 3.32; - double angle = 0.78539816339744830961566084581988; - PIMathVector vector(SIZE); - PIMathVector vec(SIZE); - vector[0] = a; - vector[1] = a; - vec[1] = a; - ASSERT_DOUBLE_EQ(angle, vector.angleRad(vec)); + double a = 3.32; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE); + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_DOUBLE_EQ(angle45DegInRad, vector.angleRad(vec)); +} + +TEST(PIMathVector_Test, angleRadSizeNotEq) { + double a = 3.32; + uint bias = 2u; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE + bias); + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_FALSE(vector.angleRad(vec)); } TEST(PIMathVector_Test, angleDeg) { - double a = 3.32; - double angle = 45.0; - PIMathVector vector(SIZE); - PIMathVector vec(SIZE); - vector[0] = a; - vector[1] = a; - vec[1] = a; - ASSERT_DOUBLE_EQ(angle, vector.angleDeg(vec)); + double a = 3.32; + double angle45Deg = 45.0; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE); + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_DOUBLE_EQ(angle45Deg, vector.angleDeg(vec)); +} + +TEST(PIMathVector_Test, angleDegSizeNotEq) { + double a = 3.32; + uint bias = 2u; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE + bias); + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_FALSE(vector.angleDeg(vec)); } TEST(PIMathVector_Test, projection) { - double a = 2.0; - double b = 2.0; - double res = sqrt(32.0); - PIMathVector vector(SIZE); - PIMathVector vec(SIZE); - vec[0] = a; - vec[2] = b; - vector[0] = a; - vector[1] = b; - vector[2] = a; - auto vecProj = vector.projection(vec); - ASSERT_DOUBLE_EQ(res, vecProj[0]); - ASSERT_DOUBLE_EQ(0.0, vecProj[1]); - ASSERT_DOUBLE_EQ(res, vecProj[2]); + double a = 2.0; + double b = 2.0; + double res = sqrt(32.0); + PIMathVector vector(SIZE); + PIMathVector vec(SIZE); + vec[0] = a; + vec[2] = b; + vector[0] = a; + vector[1] = b; + vector[2] = a; + auto vecProj = vector.projection(vec); + ASSERT_DOUBLE_EQ(res, vecProj[0]); + ASSERT_DOUBLE_EQ(0.0, vecProj[1]); + ASSERT_DOUBLE_EQ(res, vecProj[2]); +} + +TEST(PIMathVector_Test, projectionSizeNotEq) { + double a = 2.0; + double b = 2.0; + uint bias = 2u; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE + bias); + vec[0] = a; + vec[2] = b; + vector[0] = a; + vector[1] = b; + vector[2] = a; + auto vecProj = vector.projection(vec); + ASSERT_DOUBLE_EQ(a, vecProj[0]); + ASSERT_DOUBLE_EQ(b, vecProj[1]); + ASSERT_DOUBLE_EQ(a, vecProj[2]); } TEST(PIMathVector_Test, normalize) { - double a = 5.0; - PIMathVector vector(SIZE); - vector.fill(a); - ASSERT_TRUE(cmpVectorWithValue(vector.normalize(), a / sqrt(SIZE * a * a), SIZE)); + double a = 5.0; + PIMathVector vector(SIZE); + vector.fill(a); + ASSERT_TRUE(cmpVectorWithValue(vector.normalize(), a / sqrt(SIZE * a * a), SIZE)); } TEST(PIMathVector_Test, normalized) { - double a = 5.0; - PIMathVector vector(SIZE); - PIMathVector vectorNew(SIZE); - vector.fill(a); - vectorNew = vector.normalized(); - ASSERT_TRUE(cmpVectorWithValue(vectorNew, a / sqrt(SIZE * a * a), SIZE)); + double a = 5.0; + PIMathVector vector(SIZE); + PIMathVector vectorNew(SIZE); + vector.fill(a); + vectorNew = vector.normalized(); + ASSERT_TRUE(cmpVectorWithValue(vectorNew, a / sqrt(SIZE * a * a), SIZE)); } TEST(PIMathVector_Test, isNullTrue) { - PIMathVector vector(SIZE); - ASSERT_TRUE(vector.isNull()); + PIMathVector vector(SIZE); + ASSERT_TRUE(vector.isNull()); } TEST(PIMathVector_Test, isNullFalse) { - PIMathVector vector(SIZE); - vector[0] = 6.273; - ASSERT_FALSE(vector.isNull()); + PIMathVector vector(SIZE); + vector[0] = 6.273; + ASSERT_FALSE(vector.isNull()); } TEST(PIMathVector_Test, isValidTrue) { - PIMathVector vector(SIZE); - ASSERT_TRUE(vector.isValid()); + PIMathVector vector(SIZE); + ASSERT_TRUE(vector.isValid()); } TEST(PIMathVector_Test, isValidFalse) { - PIMathVector vector; - ASSERT_FALSE(vector.isValid()); + PIMathVector vector; + ASSERT_FALSE(vector.isValid()); } TEST(PIMathVector_Test, isOrthoTrue) { - uint sizeNew = 2u; - double a = 2.0; - double b = 1.0; - PIMathVector vector(sizeNew); - PIMathVector vect(sizeNew); - vector[0] = a; - vect[1] = b; - ASSERT_TRUE(vector.isOrtho(vect)); + uint sizeNew = 2u; + double a = 2.0; + double b = 1.0; + PIMathVector vector(sizeNew); + PIMathVector vect(sizeNew); + vector[0] = a; + vect[1] = b; + ASSERT_TRUE(vector.isOrtho(vect)); } TEST(PIMathVector_Test, isOrthoFalse) { - uint sizeNew = 2u; - double a = 2.0; - double b = 1.0; - double c = 5.0; - PIMathVector vector(sizeNew); - PIMathVector vect(sizeNew); - vector[0] = a; - vect[0] = c; - vect[1] = b; - ASSERT_FALSE(vector.isOrtho(vect)); + uint sizeNew = 2u; + double a = 2.0; + double b = 1.0; + double c = 5.0; + PIMathVector vector(sizeNew); + PIMathVector vect(sizeNew); + vector[0] = a; + vect[0] = c; + vect[1] = b; + ASSERT_FALSE(vector.isOrtho(vect)); } TEST(PIMathVector_Test, at) { - double a = 5.5; - PIMathVector vector(SIZE); - vector.fill(a); - for(uint i = 0; i < SIZE; i++){ - if(vector.at(i) - a >= double(1E-200)){ - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + double a = 5.5; + PIMathVector vector(SIZE); + vector.fill(a); + for(uint i = 0; i < SIZE; i++){ + if(vector.at(i) - a >= double(1E-200)){ + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathVector_Test, operator_AssignmentValue) { - double a = 5.5; - PIMathVector vector(SIZE); - vector = a; - ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); + double a = 5.5; + PIMathVector vector(SIZE); + vector = a; + ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); } TEST(PIMathVector_Test, operator_AssignmentVector) { - double a = 5.5; - PIMathVector vector(SIZE); - PIMathVector vec(SIZE); - vec = a; - vector = vec; - ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); + double a = 5.5; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE); + vec = a; + vector = vec; + ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); +} + +TEST(PIMathVector_Test, operator_AssignmentVectorSizeNotEq) { + double a = 5.5; + double b = 1.43; + uint bias = 2u; + PIMathVector vector(SIZE); + PIMathVector vec(SIZE + bias); + vector = b; + vec = a; + vector = vec; + ASSERT_TRUE(cmpVectorWithValue(vector, b, SIZE)); } TEST(PIMathVector_Test, operator_EqualTrue) { - double a = 5.12; - double b = 7.34; - uint newSize = 2u; - PIMathVector vector(newSize); - PIMathVector vec(newSize); - vector[0] = a; - vector[1] = b; - vec[0] = a; - vec[1] = b; - ASSERT_TRUE(vec == vector); + double a = 5.12; + double b = 7.34; + uint newSize = 2u; + PIMathVector vector(newSize); + PIMathVector vec(newSize); + vector[0] = a; + vector[1] = b; + vec[0] = a; + vec[1] = b; + ASSERT_TRUE(vec == vector); } TEST(PIMathVector_Test, operator_EqualFalse) { - double a = 5.12; - double b = 7.34; - double c = 7.332; - uint newSize = 2u; - PIMathVector vector(newSize); - PIMathVector vec(newSize); - vector[0] = a; - vector[1] = b; - vec[0] = a; - vec[1] = c; - ASSERT_FALSE(vec == vector); + double a = 5.12; + double b = 7.34; + double c = 7.332; + uint newSize = 2u; + PIMathVector vector(newSize); + PIMathVector vec(newSize); + vector[0] = a; + vector[1] = b; + vec[0] = a; + vec[1] = c; + ASSERT_FALSE(vec == vector); } TEST(PIMathVector_Test, operator_Not_EqualTrue) { - double a = 5.12; - double b = 7.34; - double c = 7.332; - uint newSize = 2u; - PIMathVector vector(newSize); - PIMathVector vec(newSize); - vector[0] = a; - vector[1] = b; - vec[0] = a; - vec[1] = c; - ASSERT_TRUE(vec != vector); + double a = 5.12; + double b = 7.34; + double c = 7.332; + uint newSize = 2u; + PIMathVector vector(newSize); + PIMathVector vec(newSize); + vector[0] = a; + vector[1] = b; + vec[0] = a; + vec[1] = c; + ASSERT_TRUE(vec != vector); } TEST(PIMathVector_Test, operator_Not_EqualFalse) { - double a = 5.12; - double b = 7.34; - uint newSize = 2u; - PIMathVector vector(newSize); - PIMathVector vec(newSize); - vector[0] = a; - vector[1] = b; - vec[0] = a; - vec[1] = b; - ASSERT_FALSE(vec != vector); + double a = 5.12; + double b = 7.34; + uint newSize = 2u; + PIMathVector vector(newSize); + PIMathVector vec(newSize); + vector[0] = a; + vector[1] = b; + vec[0] = a; + vec[1] = b; + ASSERT_FALSE(vec != vector); } -TEST(PIMathVector_Test, operator_Addition_Aassignment) { - double a = 6.0; - double b = 1.72; - PIMathVector vector1(SIZE); - PIMathVector vector2(SIZE); - vector1.fill(a); - vector2.fill(b); - vector1 += vector2; - ASSERT_TRUE(cmpVectorWithValue(vector1, a + b, SIZE)); +TEST(PIMathVector_Test, operator_Addition_Assignment) { + double a = 6.0; + double b = 1.72; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE); + vector1.fill(a); + vector2.fill(b); + vector1 += vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a + b, SIZE)); +} + +TEST(PIMathVector_Test, operator_Addition_Assignment_sizeNotEq) { + double a = 6.0; + double b = 1.72; + uint bias = 2u; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE + bias); + vector1.fill(a); + vector2.fill(b); + vector1 += vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a, SIZE)); } TEST(PIMathVector_Test, operator_Subtraction_Assignment) { - double a = 6.0; - double b = 1.72; - PIMathVector vector1(SIZE); - PIMathVector vector2(SIZE); - vector1.fill(a); - vector2.fill(b); - vector1 -= vector2; - ASSERT_TRUE(cmpVectorWithValue(vector1, a - b, SIZE)); + double a = 6.0; + double b = 1.72; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE); + vector1.fill(a); + vector2.fill(b); + vector1 -= vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a - b, SIZE)); +} + +TEST(PIMathVector_Test, operator_Subtraction_Assignment_sizeNotEq) { + double a = 6.0; + double b = 1.72; + uint bias = 2u; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE + bias); + vector1.fill(a); + vector2.fill(b); + vector1 -= vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a, SIZE)); } TEST(PIMathVector_Test, operator_Multiplication_AssignmentValue) { - double a = 6.0; - double b = 4.0; - PIMathVector vector1(SIZE); - vector1.fill(a); - vector1 *= b; - ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); + double a = 6.0; + double b = 4.0; + PIMathVector vector1(SIZE); + vector1.fill(a); + vector1 *= b; + ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); } TEST(PIMathVector_Test, operator_Multiplication_AssignmentVector) { - double a = 6.0; - double b = 1.72; - PIMathVector vector1(SIZE); - PIMathVector vector2(SIZE); - vector1.fill(a); - vector2.fill(b); - vector1 *= vector2; - ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); + double a = 6.0; + double b = 1.72; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE); + vector1.fill(a); + vector2.fill(b); + vector1 *= vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); +} + +TEST(PIMathVector_Test, operator_Multiplication_AssignmentVector_sizeNotEq) { + double a = 6.0; + double b = 1.72; + uint bias = 2u; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE + bias); + vector1.fill(a); + vector2.fill(b); + vector1 *= vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a, SIZE)); } TEST(PIMathVector_Test, operator_Division_AssignmentValue) { - double a = 6.0; - double b = 4.0; - PIMathVector vector1(SIZE); - vector1.fill(a); - vector1 /= b; - ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); + double a = 6.0; + double b = 4.0; + PIMathVector vector1(SIZE); + vector1.fill(a); + vector1 /= b; + ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); } TEST(PIMathVector_Test, operator_Division_AssignmentVector) { - double a = 6.0; - double b = 1.5; - PIMathVector vector1(SIZE); - PIMathVector vector2(SIZE); - vector1.fill(a); - vector2.fill(b); - vector1 /= vector2; - ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); + double a = 6.0; + double b = 1.5; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE); + vector1.fill(a); + vector2.fill(b); + vector1 /= vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); +} + +TEST(PIMathVector_Test, operator_Division_AssignmentVector_sizeNotEq) { + double a = 6.0; + double b = 1.72; + uint bias = 2u; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE + bias); + vector1.fill(a); + vector2.fill(b); + vector1 /= vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a, SIZE)); } TEST(PIMathVector_Test, operator_Addition) { - double a = 6.0; - double b = 1.72; - PIMathVector vector1(SIZE); - PIMathVector vector2(SIZE); - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(cmpVectorWithValue(vector1 + vector2, a + b, SIZE)); + double a = 6.0; + double b = 1.72; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE); + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue(vector1 + vector2, a + b, SIZE)); +} + +TEST(PIMathVector_Test, operator_AdditionSizeNotEq) { + double a = 6.0; + double b = 1.72; + uint bias = 2u; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE + bias); + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue(vector1 + vector2, a, SIZE)); } TEST(PIMathVector_Test, operator_Subtraction) { - double a = 6.0; - double b = 1.72; - PIMathVector vector1(SIZE); - PIMathVector vector2(SIZE); - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(cmpVectorWithValue(vector1 - vector2, a - b, SIZE)); + double a = 6.0; + double b = 1.72; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE); + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue(vector1 - vector2, a - b, SIZE)); +} + +TEST(PIMathVector_Test, operator_SubtractionSizeNotEq) { + double a = 6.0; + double b = 1.72; + uint bias = 2u; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE + bias); + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue(vector1 - vector2, a, SIZE)); } TEST(PIMathVector_Test, operator_MultiplicationValue) { - double a = 6.0; - double b = 4.0; - PIMathVector vector1(SIZE); - PIMathVector vector2(SIZE); - vector1.fill(a); - ASSERT_TRUE(cmpVectorWithValue(vector1 * b, a * b, SIZE)); + double a = 6.0; + double b = 4.0; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE); + vector1.fill(a); + ASSERT_TRUE(cmpVectorWithValue(vector1 * b, a * b, SIZE)); } TEST(PIMathVector_Test, operator_MultiplicationVector1) { - double a = 6.0; - double b = 1.72; - PIMathVector vector1(SIZE); - PIMathVector vector2(SIZE); - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(cmpVectorWithValue((vector1 * vector2), 0.0, SIZE)); + double a = 6.0; + double b = 1.72; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE); + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue((vector1 * vector2), 0.0, SIZE)); } TEST(PIMathVector_Test, operator_MultiplicationVector2) { - double a = 1.0; - PIMathVector vector1(SIZE); - PIMathVector vector2(SIZE); - vector1[0] = a; - vector2[1] = a; - auto crossVec = vector1 * vector2; - ASSERT_DOUBLE_EQ(crossVec[0], 0.0); - ASSERT_DOUBLE_EQ(crossVec[1], 0.0); - ASSERT_DOUBLE_EQ(crossVec[2], a); + double a = 1.0; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE); + vector1[0] = a; + vector2[1] = a; + auto crossVec = vector1 * vector2; + ASSERT_DOUBLE_EQ(crossVec[0], 0.0); + ASSERT_DOUBLE_EQ(crossVec[1], 0.0); + ASSERT_DOUBLE_EQ(crossVec[2], a); } TEST(PIMathVector_Test, operator_DivisionValue) { - double a = 6.0; - double b = 4.0; - PIMathVector vector1(SIZE); - vector1.fill(a); - ASSERT_TRUE(cmpVectorWithValue(vector1 / b, a / b, SIZE)); + double a = 6.0; + double b = 4.0; + PIMathVector vector1(SIZE); + vector1.fill(a); + ASSERT_TRUE(cmpVectorWithValue(vector1 / b, a / b, SIZE)); } TEST(PIMathVector_Test, operator_MultiplVect) { - double a = 6.0; - double b = 5.0; - PIMathVector vector1(SIZE); - PIMathVector vector2(SIZE); - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(cmpVectorWithValue(vector1 & vector2, a * b, SIZE)); + double a = 6.0; + double b = 5.0; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE); + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue(vector1 & vector2, a * b, SIZE)); +} + +TEST(PIMathVector_Test, operator_MultiplVectSizeNotEq) { + double a = 6.0; + double b = 5.0; + uint bias = 2u; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE + bias); + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue(vector1 & vector2, a , SIZE)); } TEST(PIMathVector_Test, operator_DotProduct) { - double a = 6.0; - double b = 5.0; - PIMathVector vector1(SIZE); - PIMathVector vector2(SIZE); - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(SIZE * a * b == (vector1 ^ vector2)); + double a = 6.0; + double b = 5.0; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE); + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(SIZE * a * b == (vector1 ^ vector2)); +} + +TEST(PIMathVector_Test, operator_DotProductSizeNotEq) { + double a = 6.0; + double b = 5.0; + uint bias = 2u; + PIMathVector vector1(SIZE); + PIMathVector vector2(SIZE + bias); + vector1.fill(a); + vector2.fill(b); + ASSERT_FALSE(vector1 ^ vector2); } diff --git a/tests/math/testpimathvectort.cpp b/tests/math/testpimathvectort.cpp index 738c663d..f29a7527 100644 --- a/tests/math/testpimathvectort.cpp +++ b/tests/math/testpimathvectort.cpp @@ -3,509 +3,507 @@ #include "pimathmatrix.h" const uint SIZE = 3u; +const double angle45DegInRad = 0.78539816339744830961566084581988; bool cmpVectorWithValue(PIMathVectorT vector, double val, int num) { - bool b = true; - for(int i = 0; i < num; i++) { - if(vector[i] - val >= double(1E-200)) { - b = false; - } - } - return b; + bool b = true; + for(int i = 0; i < num; i++) { + if(vector[i] - val >= double(1E-200)) { + b = false; + } + } + return b; } TEST(PIMathVectorT_Test, size) { - PIMathVectorT vector; - ASSERT_TRUE(vector.size() == SIZE); + PIMathVectorT vector; + ASSERT_TRUE(vector.size() == SIZE); } TEST(PIMathVectorT_Test, fill) { - double a = 5.0; - PIMathVectorT vector; - ASSERT_TRUE(cmpVectorWithValue(vector.fill(a), a, SIZE)); + double a = 5.0; + PIMathVectorT vector; + ASSERT_TRUE(cmpVectorWithValue(vector.fill(a), a, SIZE)); } TEST(PIMathVectorT_Test, set) { - double a = 5.0; - double b = 3.0; - PIMathVectorT vector; - PIMathVectorT vector1; - PIMathVectorT vector2; - ASSERT_TRUE(cmpVectorWithValue(vector.set(vector1.fill(a), vector2.fill(b)), b - a, SIZE)); + double a = 5.0; + double b = 3.0; + PIMathVectorT vector; + PIMathVectorT vector1; + PIMathVectorT vector2; + ASSERT_TRUE(cmpVectorWithValue(vector.set(vector1.fill(a), vector2.fill(b)), b - a, SIZE)); } TEST(PIMathVectorT_Test, MoveVal) { - double a = 4.0; - PIMathVectorT vector; - ASSERT_TRUE(cmpVectorWithValue(vector.move(a), a, SIZE)); + double a = 4.0; + PIMathVectorT vector; + ASSERT_TRUE(cmpVectorWithValue(vector.move(a), a, SIZE)); } TEST(PIMathVectorT_Test, MoveVector) { - double a = 5.0; - PIMathVectorT vector; - PIMathVectorT vector1; - ASSERT_TRUE(cmpVectorWithValue(vector.move(vector1.fill(a)), a, SIZE)); + double a = 5.0; + PIMathVectorT vector; + PIMathVectorT vector1; + ASSERT_TRUE(cmpVectorWithValue(vector.move(vector1.fill(a)), a, SIZE)); } TEST(PIMathVectorT_Test, lengthSqr) { - double a = 1.0; - PIMathVectorT vector; - vector.fill(a); - ASSERT_DOUBLE_EQ(SIZE * a, vector.lengthSqr()); + double a = 1.0; + PIMathVectorT vector; + vector.fill(a); + ASSERT_DOUBLE_EQ(SIZE * a, vector.lengthSqr()); } TEST(PIMathVectorT_Test, length) { - double a = 1.0; - PIMathVectorT vector; - vector.fill(a); - ASSERT_DOUBLE_EQ(sqrt(SIZE * a), vector.length()); + double a = 1.0; + PIMathVectorT vector; + vector.fill(a); + ASSERT_DOUBLE_EQ(sqrt(SIZE * a), vector.length()); } TEST(PIMathVectorT_Test, manhattanLength) { - double a = 5.0; - PIMathVectorT vector; - vector.fill(a); - ASSERT_DOUBLE_EQ(SIZE * a, vector.manhattanLength()); + double a = 5.0; + PIMathVectorT vector; + vector.fill(a); + ASSERT_DOUBLE_EQ(SIZE * a, vector.manhattanLength()); } TEST(PIMathVectorT_Test, angleCos) { - double a = 1.0; - double angle = 0.78539816339744830961566084581988; - PIMathVectorT vector; - PIMathVectorT vec; - vector[0] = a; - vector[1] = a; - vec[1] = a; - ASSERT_DOUBLE_EQ(cos(angle), vector.angleCos(vec)); + double a = 1.0; + PIMathVectorT vector; + PIMathVectorT vec; + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_DOUBLE_EQ(cos(angle45DegInRad), vector.angleCos(vec)); } TEST(PIMathVectorT_Test, angleSin) { - double a = 1.0; - double angle = 0.78539816339744830961566084581988; - PIMathVectorT vector; - PIMathVectorT vec; - vector[0] = a; - vector[1] = a; - vec[1] = a; - ASSERT_DOUBLE_EQ(sin(angle), vector.angleSin(vec)); + double a = 1.0; + PIMathVectorT vector; + PIMathVectorT vec; + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_DOUBLE_EQ(sin(angle45DegInRad), vector.angleSin(vec)); } TEST(PIMathVectorT_Test, angleRad) { - double a = 1.0; - double angle = 0.78539816339744830961566084581988; - PIMathVectorT vector; - PIMathVectorT vec; - vector[0] = a; - vector[1] = a; - vec[1] = a; - ASSERT_DOUBLE_EQ(angle, vector.angleRad(vec)); + double a = 1.0; + PIMathVectorT vector; + PIMathVectorT vec; + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_DOUBLE_EQ(angle45DegInRad, vector.angleRad(vec)); } TEST(PIMathVectorT_Test, angleDeg) { - double a = 1.0; - double angle = 45.0; - PIMathVectorT vector; - PIMathVectorT vec; - vector[0] = a; - vector[1] = a; - vec[1] = a; - ASSERT_DOUBLE_EQ(angle, vector.angleDeg(vec)); + double a = 1.0; + double angle45inDeg = 45.0; + PIMathVectorT vector; + PIMathVectorT vec; + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_DOUBLE_EQ(angle45inDeg, vector.angleDeg(vec)); } TEST(PIMathVectorT_Test, angleElevation) { - double a = 1.0; - double angle = 45.0; - PIMathVectorT vector; - PIMathVectorT vec; - vector[0] = a; - vector[1] = a; - vec[1] = a; - ASSERT_DOUBLE_EQ(-angle, vector.angleElevation(vec)); + double a = 1.0; + double angle45inDeg = 45.0; + PIMathVectorT vector; + PIMathVectorT vec; + vector[0] = a; + vector[1] = a; + vec[1] = a; + ASSERT_DOUBLE_EQ(-angle45inDeg, vector.angleElevation(vec)); } TEST(PIMathVectorT_Test, projection) { - double a = 2.0; - double b = 2.0; - double res = sqrt(32.0); - PIMathVectorT vector; - PIMathVectorT vec; - vec[0] = a; - vec[2] = b; - vector[0] = a; - vector[1] = b; - vector[2] = a; - auto vecProj = vector.projection(vec); - ASSERT_DOUBLE_EQ(res, vecProj[0]); - ASSERT_DOUBLE_EQ(0.0, vecProj[1]); - ASSERT_DOUBLE_EQ(res, vecProj[2]); + double a = 2.0; + double b = 2.0; + double res = sqrt(32.0); + PIMathVectorT vector; + PIMathVectorT vec; + vec[0] = a; + vec[2] = b; + vector[0] = a; + vector[1] = b; + vector[2] = a; + auto vecProj = vector.projection(vec); + ASSERT_DOUBLE_EQ(res, vecProj[0]); + ASSERT_DOUBLE_EQ(0.0, vecProj[1]); + ASSERT_DOUBLE_EQ(res, vecProj[2]); } TEST(PIMathVectorT_Test, normalize) { - double a = 5.0; - PIMathVectorT vector; - vector.fill(a); - ASSERT_TRUE(cmpVectorWithValue(vector.normalize(), a / sqrt(SIZE * a * a), SIZE)); + double a = 5.0; + PIMathVectorT vector; + vector.fill(a); + ASSERT_TRUE(cmpVectorWithValue(vector.normalize(), a / sqrt(SIZE * a * a), SIZE)); } TEST(PIMathVectorT_Test, normalized) { - double a = 5.0; - PIMathVectorT vector; - PIMathVectorT vectorNew; - vector.fill(a); - vectorNew = vector.normalized(); - ASSERT_TRUE(cmpVectorWithValue(vectorNew, a / sqrt(SIZE * a * a), SIZE)); + double a = 5.0; + PIMathVectorT vector; + PIMathVectorT vectorNew; + vector.fill(a); + vectorNew = vector.normalized(); + ASSERT_TRUE(cmpVectorWithValue(vectorNew, a / sqrt(SIZE * a * a), SIZE)); } TEST(PIMathVectorT_Test, cross1) { - PIMathVectorT vector1; - PIMathVectorT vector2; - double a = 5.0; - double b = 1.72; - double c = 0.0; - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(cmpVectorWithValue(vector1.cross(vector2), c, SIZE)); + PIMathVectorT vector1; + PIMathVectorT vector2; + double a = 5.0; + double b = 1.72; + double c = 0.0; + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue(vector1.cross(vector2), c, SIZE)); } TEST(PIMathVectorT_Test, cross2) { - PIMathVectorT vector1; - PIMathVectorT vector2; - double a = 1.0; - vector1[0] = a; - vector2[1] = a; - auto crossVec = vector1 * vector2; - ASSERT_DOUBLE_EQ(crossVec[0], 0.0); - ASSERT_DOUBLE_EQ(crossVec[1], 0.0); - ASSERT_DOUBLE_EQ(crossVec[2], a); + PIMathVectorT vector1; + PIMathVectorT vector2; + double a = 1.0; + vector1[0] = a; + vector2[1] = a; + auto crossVec = vector1 * vector2; + ASSERT_DOUBLE_EQ(crossVec[0], 0.0); + ASSERT_DOUBLE_EQ(crossVec[1], 0.0); + ASSERT_DOUBLE_EQ(crossVec[2], a); } TEST(PIMathVectorT_Test, dot) { - double a = 6.0; - double b = 5.0; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - ASSERT_DOUBLE_EQ(vector1.dot(vector2), SIZE * a * b); + double a = 6.0; + double b = 5.0; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + ASSERT_DOUBLE_EQ(vector1.dot(vector2), SIZE * a * b); } TEST(PIMathVectorT_Test, isNullTrue) { - PIMathVectorT vector; - ASSERT_TRUE(vector.isNull()); + PIMathVectorT vector; + ASSERT_TRUE(vector.isNull()); } TEST(PIMathVectorT_Test, isNullFalse) { - double a = 6.273; - PIMathVectorT vector; - vector[0] = a; - ASSERT_FALSE(vector.isNull()); + double a = 6.273; + PIMathVectorT vector; + vector[0] = a; + ASSERT_FALSE(vector.isNull()); } TEST(PIMathVectorT_Test, isOrthoTrue) { - double a = 2.0; - double b = 1.0; - PIMathVectorT vector; - PIMathVectorT vect; - vector[0] = a; - vect[1] = b; - ASSERT_TRUE(vector.isOrtho(vect)); + double a = 2.0; + double b = 1.0; + PIMathVectorT vector; + PIMathVectorT vect; + vector[0] = a; + vect[1] = b; + ASSERT_TRUE(vector.isOrtho(vect)); } TEST(PIMathVectorT_Test, isOrthoFalse) { - double a = 2.0; - double b = 5.0; - double c = 1.0; - PIMathVectorT vector; - PIMathVectorT vect; - vector[0] = a; - vect[0] = b; - vect[1] = c; - ASSERT_FALSE(vector.isOrtho(vect)); + double a = 2.0; + double b = 5.0; + double c = 1.0; + PIMathVectorT vector; + PIMathVectorT vect; + vector[0] = a; + vect[0] = b; + vect[1] = c; + ASSERT_FALSE(vector.isOrtho(vect)); } TEST(PIMathVectorT_Test, at) { - double a = 5.5; - PIMathVectorT vector; - vector.fill(a); - for(uint i = 0; i < SIZE; i++){ - if(vector.at(i) != a){ - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + double a = 5.5; + PIMathVectorT vector; + vector.fill(a); + for(uint i = 0; i < SIZE; i++){ + if(vector.at(i) != a){ + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathVectorT_Test, operator_AssignmentValue) { - double a = 3.0; - PIMathVectorT vector; - vector = a; - ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); + double a = 3.0; + PIMathVectorT vector; + vector = a; + ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); } TEST(PIMathVectorT_Test, operator_AssignmentVector) { - double a = 5.0; - PIMathVectorT vector; - PIMathVectorT vec; - vec = a; - vector = vec; - ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); + double a = 5.0; + PIMathVectorT vector; + PIMathVectorT vec; + vec = a; + vector = vec; + ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); } TEST(PIMathVectorT_Test, operator_EqualTrue) { - double a = 5.12; - double b = 7.34; - PIMathVectorT vector; - PIMathVectorT vec; - vector[0] = a; - vector[1] = b; - vec[0] = a; - vec[1] = b; - ASSERT_TRUE(vec == vector); + double a = 5.12; + double b = 7.34; + PIMathVectorT vector; + PIMathVectorT vec; + vector[0] = a; + vector[1] = b; + vec[0] = a; + vec[1] = b; + ASSERT_TRUE(vec == vector); } TEST(PIMathVectorT_Test, operator_EqualFalse) { - double a = 5.12; - double b = 7.34; - double c = 0.34; - PIMathVectorT vector; - PIMathVectorT vec; - vector[0] = a; - vector[1] = b; - vec[0] = a; - vec[1] = c; - ASSERT_FALSE(vec == vector); + double a = 5.12; + double b = 7.34; + double c = 0.34; + PIMathVectorT vector; + PIMathVectorT vec; + vector[0] = a; + vector[1] = b; + vec[0] = a; + vec[1] = c; + ASSERT_FALSE(vec == vector); } TEST(PIMathVectorT_Test, operator_Not_EqualTrue) { - double a = 5.12; - double b = 7.34; - double c = 0.34; - PIMathVectorT vector; - PIMathVectorT vec; - vector[0] = a; - vector[1] = b; - vec[0] = a; - vec[1] = c; - ASSERT_TRUE(vec != vector); + double a = 5.12; + double b = 7.34; + double c = 0.34; + PIMathVectorT vector; + PIMathVectorT vec; + vector[0] = a; + vector[1] = b; + vec[0] = a; + vec[1] = c; + ASSERT_TRUE(vec != vector); } TEST(PIMathVectorT_Test, operator_Not_EqualFalse) { - double a = 5.12; - double b = 7.34; - PIMathVectorT vector; - PIMathVectorT vec; - vector[0] = a; - vector[1] = b; - vec[0] = a; - vec[1] = b; - ASSERT_FALSE(vec != vector); + double a = 5.12; + double b = 7.34; + PIMathVectorT vector; + PIMathVectorT vec; + vector[0] = a; + vector[1] = b; + vec[0] = a; + vec[1] = b; + ASSERT_FALSE(vec != vector); } -TEST(PIMathVectorT_Test, operator_Addition_Aassignment) { - double a = 6.0; - double b = 1.72; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - vector1 += vector2; - ASSERT_TRUE(cmpVectorWithValue(vector1, a + b, SIZE)); +TEST(PIMathVectorT_Test, operator_Addition_Assignment) { + double a = 6.0; + double b = 1.72; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + vector1 += vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a + b, SIZE)); } TEST(PIMathVectorT_Test, operator_Subtraction_Assignment) { - double a = 6.0; - double b = 1.72; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - vector1 -= vector2; - ASSERT_TRUE(cmpVectorWithValue(vector1, a - b, SIZE)); + double a = 6.0; + double b = 1.72; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + vector1 -= vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a - b, SIZE)); } TEST(PIMathVectorT_Test, operator_Multiplication_AssignmentValue) { - double a = 6.0; - double b = 4.0; - PIMathVectorT vector1; - vector1.fill(a); - vector1 *= b; - ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); + double a = 6.0; + double b = 4.0; + PIMathVectorT vector1; + vector1.fill(a); + vector1 *= b; + ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); } TEST(PIMathVectorT_Test, operator_Multiplication_AssignmentVector) { - double a = 6.0; - double b = 1.72; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - vector1 *= vector2; - ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); + double a = 6.0; + double b = 1.72; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + vector1 *= vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); } TEST(PIMathVectorT_Test, operator_Division_AssignmentValue) { - double a = 6.0; - double b = 4.0; - PIMathVectorT vector1; - vector1.fill(a); - vector1 /= b; - ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); + double a = 6.0; + double b = 4.0; + PIMathVectorT vector1; + vector1.fill(a); + vector1 /= b; + ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); } TEST(PIMathVectorT_Test, operator_Division_AssignmentVector) { - double a = 6.0; - double b = 1.5; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - vector1 /= vector2; - ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); + double a = 6.0; + double b = 1.5; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + vector1 /= vector2; + ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); } TEST(PIMathVectorT_Test, operator_Addition) { - double a = 6.0; - double b = 1.72; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(cmpVectorWithValue(vector1 + vector2, a + b, SIZE)); + double a = 6.0; + double b = 1.72; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue(vector1 + vector2, a + b, SIZE)); } TEST(PIMathVectorT_Test, operator_Subtraction) { - double a = 6.0; - double b = 1.72; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(cmpVectorWithValue(vector1 - vector2, a - b, SIZE)); + double a = 6.0; + double b = 1.72; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue(vector1 - vector2, a - b, SIZE)); } TEST(PIMathVectorT_Test, operator_MultiplicationValue) { - double a = 6.0; - double b = 4.0; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - ASSERT_TRUE(cmpVectorWithValue(vector1 * b, a * b, SIZE)); + double a = 6.0; + double b = 4.0; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + ASSERT_TRUE(cmpVectorWithValue(vector1 * b, a * b, SIZE)); } TEST(PIMathVectorT_Test, operator_MultiplicationVector1) { - double a = 6.0; - double b = 1.72; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(cmpVectorWithValue((vector1 * vector2), 0.0, SIZE)); + double a = 6.0; + double b = 1.72; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue((vector1 * vector2), 0.0, SIZE)); } TEST(PIMathVectorT_Test, operator_MultiplicationVector2) { - double a = 1.0; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1[0] = a; - vector2[1] = a; - ASSERT_TRUE(((vector1 * vector2)[0] < double(1E-200)) && ((vector1 * vector2)[1] < double(1E-200)) && ((vector1 * vector2)[2] - a < double(1E-200))); + double a = 1.0; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1[0] = a; + vector2[1] = a; + ASSERT_TRUE(((vector1 * vector2)[0] < double(1E-200)) && ((vector1 * vector2)[1] < double(1E-200)) && ((vector1 * vector2)[2] - a < double(1E-200))); } TEST(PIMathVectorT_Test, operator_DivisionVal) { - double a = 6.0; - double b = 4.0; - PIMathVectorT vector1; - vector1.fill(a); - ASSERT_TRUE(cmpVectorWithValue(vector1 / b, a / b, SIZE)); + double a = 6.0; + double b = 4.0; + PIMathVectorT vector1; + vector1.fill(a); + ASSERT_TRUE(cmpVectorWithValue(vector1 / b, a / b, SIZE)); } TEST(PIMathVectorT_Test, operator_DivisionVector) { - double a = 6.0; - double b = 4.0; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(cmpVectorWithValue(vector1 / vector2, a / b, SIZE)); + double a = 6.0; + double b = 4.0; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue(vector1 / vector2, a / b, SIZE)); } TEST(PIMathVectorT_Test, operator_MultiplVect) { - double a = 6.0; - double b = 5.0; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(cmpVectorWithValue(vector1 & vector2, a * b, SIZE)); + double a = 6.0; + double b = 5.0; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(cmpVectorWithValue(vector1 & vector2, a * b, SIZE)); } TEST(PIMathVectorT_Test, operator_absDotProduct) { - double a = 6.0; - double b = 5.0; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - ASSERT_DOUBLE_EQ(vector1 ^ vector2, SIZE * a * b); + double a = 6.0; + double b = 5.0; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + ASSERT_DOUBLE_EQ(vector1 ^ vector2, SIZE * a * b); } TEST(PIMathVectorT_Test, transposed) { - double a = 6.0; - PIMathVectorT vector; - vector.fill(a); - auto matrix = vector.transposed(); - for(int i = 0; i < SIZE; i++){ - if(matrix[0][i] != a) - { - ASSERT_TRUE(false); - } - } - ASSERT_TRUE(true); + double a = 6.0; + PIMathVectorT vector; + vector.fill(a); + auto matrix = vector.transposed(); + for(int i = 0; i < SIZE; i++){ + if(matrix[0][i] != a) + { + ASSERT_TRUE(false); + } + } + ASSERT_TRUE(true); } TEST(PIMathVectorT_Test, filled) { - double a = 6.0; - auto vector = PIMathVectorT::filled(a); - ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); + double a = 6.0; + auto vector = PIMathVectorT::filled(a); + ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); } TEST(PIMathVectorT_Test, turnTo) { - double a = 6.0; - PIMathVectorT vect; - vect.fill(a); - auto vector = vect.turnTo<2u, double>(); - ASSERT_TRUE(vector.size() == 2); + double a = 6.0; + PIMathVectorT vect; + vect.fill(a); + auto vector = vect.turnTo<2u, double>(); + ASSERT_TRUE(vector.size() == 2); } TEST(PIMathVectorT_Test, LogicalOrTrue) { - double a = 6.0; - double b = 1.72; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1.fill(a); - vector2.fill(b); - ASSERT_TRUE(vector1 || vector2); + double a = 6.0; + double b = 1.72; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1.fill(a); + vector2.fill(b); + ASSERT_TRUE(vector1 || vector2); } TEST(PIMathVectorT_Test, LogicalOrFalse) { - double a = 1.0; - PIMathVectorT vector1; - PIMathVectorT vector2; - vector1[0] = a; - vector2[1] = a; - ASSERT_FALSE(vector1 || vector2); + double a = 1.0; + PIMathVectorT vector1; + PIMathVectorT vector2; + vector1[0] = a; + vector2[1] = a; + ASSERT_FALSE(vector1 || vector2); } TEST(PIMathVectorT_Test, sqrt) { - double a = 36.0; - PIMathVectorT vector1; - vector1.fill(a); - ASSERT_TRUE(cmpVectorWithValue(sqrt(vector1), sqrt(a), SIZE)); + double a = 36.0; + PIMathVectorT vector1; + vector1.fill(a); + ASSERT_TRUE(cmpVectorWithValue(sqrt(vector1), sqrt(a), SIZE)); } TEST(PIMathVectorT_Test, sqr) { - double a = 6.0; - PIMathVectorT vector1; - vector1.fill(a); - ASSERT_TRUE(cmpVectorWithValue(sqr(vector1), sqr(a), SIZE)); + double a = 6.0; + PIMathVectorT vector1; + vector1.fill(a); + ASSERT_TRUE(cmpVectorWithValue(sqr(vector1), sqr(a), SIZE)); }