SHS/pip
4
3
Fork 0
Code Issues 67 Pull Requests 1 Actions Releases Wiki Activity

Merge branch 'PIMathMatrixTests1-10'

Browse Source
This commit is contained in:
Пелипенко Иван
2021-10-04 22:14:38 +03:00
parent c404688bbd 948a90fcd9
commit 042366e19e
3 changed files with 70 additions and 1012 deletions
Download Patch File Download Diff File Expand all files Collapse all files

509
tests/math/testpimathmatrix.cpp
View File

@@ -1,7 +1,8 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "pimathmatrix.h" #include "pimathmatrix.h"
bool cmpSquareMatrixWithValue(PIMathMatrix<double> matrix, double val, int num) { template<typename Type>
bool cmpSquareMatrixWithValue(PIMathMatrix<Type> matrix, Type val, int num) {
bool b = true; bool b = true;
for(int i = 0; i < num; i++) { for(int i = 0; i < num; i++) {
for(int j = 0; j < num; j++) { for(int j = 0; j < num; j++) {
@@ -13,7 +14,24 @@ bool cmpSquareMatrixWithValue(PIMathMatrix<double> matrix, double val, int num)
return b; return b;
} }
TEST(PIMathMatrix_Test, identity) { TEST(PIMathMatrix_Test, constructor1) {
PIMathMatrix<double> matrix(3, 3, 5.0);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, 5.0, 3));
}
TEST(PIMathMatrix_Test, constructor2) {
PIVector<double> vector(2, 5.0);
PIMathMatrix<PIVector<double>> matrix(3, 3, vector);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, vector, 3));
}
TEST(PIMathMatrix_Test, constructor3) {
PIVector2D<double> vector(2, 2, 5.0);
PIMathMatrix<double> matrix(vector);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, 5.0, 2));
}
TEST(PIMathMatrix_Test, identity1) {
auto matrix = PIMathMatrix<double>::identity(3, 3); auto matrix = PIMathMatrix<double>::identity(3, 3);
for(int i = 0; i < 3; i++) { for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) { for(int j = 0; j < 3; j++) {
@@ -29,7 +47,24 @@ TEST(PIMathMatrix_Test, identity) {
} }
} }
} }
ASSERT_TRUE(true); }
TEST(PIMathMatrix_Test, identity2) {
auto matrix = PIMathMatrix<double>::identity(4, 3);
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 4; j++) {
if(i != j) {
if(matrix[i][j] != 0.0){
ASSERT_TRUE(false);
}
}
else {
if(matrix[i][i] != 1.0){
ASSERT_TRUE(false);
}
}
}
}
} }
TEST(PIMathMatrixT_Test, element) { TEST(PIMathMatrixT_Test, element) {
@@ -104,440 +139,36 @@ TEST(PIMathMatrix_Test, setRow) {
} }
TEST(PIMathMatrix_Test, swapCols) { TEST(PIMathMatrix_Test, swapCols) {
PIMathMatrix<double> origMatr; PIMathMatrix<double> origMatr;
PIMathMatrix<double> matrix1; PIMathMatrix<double> matrix1;
PIMathVector<double> vector; PIMathVector<double> vector;
uint i1 = 0; uint i2 = 1; uint i1 = 0; uint i2 = 1;
double a1[3], a2[3], a3[3]; double a1[3], a2[3], a3[3];
double b1[3], b2[3], b3[3]; double b1[3], b2[3], b3[3];
vector.resize(3, 3.0); vector.resize(3, 3.0);
vector[0] = 3.0; vector[0] = 3.0;
vector[1] = 6.0; vector[1] = 6.0;
vector[2] = 8.0; vector[2] = 8.0;
matrix1 = origMatr.identity(3, 3); matrix1 = origMatr.identity(3, 3);
matrix1.setCol(0, vector); matrix1.setCol(0, vector);
vector[0] = 2.0; vector[0] = 2.0;
vector[1] = 1.0; vector[1] = 1.0;
vector[2] = 4.0; vector[2] = 4.0;
matrix1.setCol(1, vector); matrix1.setCol(1, vector);
vector[0] = 6.0; vector[0] = 6.0;
vector[1] = 2.0; vector[1] = 2.0;
vector[2] = 5.0; vector[2] = 5.0;
matrix1.setCol(2, vector); matrix1.setCol(2, vector);
for(int i = 0; i < 3; i++) { for(int i = 0; i < 3; i++) {
a1[i] = matrix1.element(i, 0); a1[i] = matrix1.element(i, 0);
a2[i] = matrix1.element(i, 1); a2[i] = matrix1.element(i, 1);
a3[i] = matrix1.element(i, 2); a3[i] = matrix1.element(i, 2);
} }
matrix1.swapCols(i1, i2); matrix1.swapCols(i1, i2);
for(int i = 0; i < 3; i++) { for(int i = 0; i < 3; i++) {
b1[i] = matrix1.element(i, 0); b1[i] = matrix1.element(i, 0);
b2[i] = matrix1.element(i, 1); b2[i] = matrix1.element(i, 1);
b3[i] = matrix1.element(i, 2); 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)); 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<double> origMatr;
PIMathMatrix<double> matrix1;
PIMathVector<double> 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<double> matrix(3, 3, 5.0);
matrix.fill(7.0);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, 7.0, 3));
}
TEST(PIMathMatrix_Test, isSquareTrue) {
PIMathMatrix<double> matrix(3, 3, 1.0);
ASSERT_TRUE(matrix.isSquare());
}
TEST(PIMathMatrix_Test, isSquareFalse) {
PIMathMatrix<double> matrix(2, 4, 1.0);
ASSERT_FALSE(matrix.isSquare());
}
TEST(PIMathMatrix_Test, isIdentityTrue) {
auto matrix = PIMathMatrix<double>::identity(3, 3);
ASSERT_TRUE(matrix.isIdentity());
}
TEST(PIMathMatrix_Test, isIdentityFalse) {
PIMathMatrix<double> matrix(3, 3, 5.0);
ASSERT_FALSE(matrix.isIdentity());
}
TEST(PIMathMatrix_Test, isNullTrue) {
PIMathMatrix<double> matrix(3, 3, 0.0);
ASSERT_TRUE(matrix.isNull());
}
TEST(PIMathMatrix_Test, isNullFalse) {
PIMathMatrix<double> matrix(3, 3, 5.0);
ASSERT_FALSE(matrix.isNull());
}
TEST(PIMathMatrix_Test, isValidTrue) {
PIMathMatrix<double> matrix(3, 3, 1.62);
ASSERT_TRUE(matrix.isValid());
}
TEST(PIMathMatrix_Test, isValidFalse) {
PIMathMatrix<double> matrix;
ASSERT_FALSE(matrix.isValid());
}
TEST(PIMathMatrix_Test, operator_Assignment) {
PIMathMatrix<double> matrix1(3, 3, 5.72);
PIMathMatrix<double> matrix2(3, 3, 7.12);
matrix1 = matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.12, 3));
}
TEST(PIMathMatrix_Test, operator_EqualTrue) {
PIMathMatrix<double> matrix1(2, 2, 2.0);
PIMathMatrix<double> 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<double> matrix1(2, 2, 2.0);
PIMathMatrix<double> 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<double> matrix1(2, 2, 2.0);
PIMathMatrix<double> 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<double> matrix1(2, 2, 2.0);
PIMathMatrix<double> 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<double> matrix1(3, 3, 6.72);
PIMathMatrix<double> matrix2(3, 3, 1.0);
matrix1 += matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.72, 3));
}
TEST(PIMathMatrix_Test, operator_Subtraction_Assignment) {
PIMathMatrix<double> matrix1(3, 3, 1.0);
PIMathMatrix<double> matrix2(3, 3, 6.72);
matrix1 -= matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, -5.72, 3));
}
TEST(PIMathMatrix_Test, operator_Multiplication_Assignment) {
PIMathMatrix<double> matrix1(3, 3, 6.72);
matrix1 *= 2.0;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 13.44, 3));
}
TEST(PIMathMatrix_Test, operator_Division_Assignment) {
PIMathMatrix<double> matrix1(3, 3, 6.72);
matrix1 /= 2.0;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 3.36, 3));
}
TEST(PIMathMatrix_Test, operator_Addition) {
PIMathMatrix<double> matrix1(3, 3, 6.72);
PIMathMatrix<double> matrix2(3, 3, 8.28);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 + matrix2, 15.0, 3));
}
TEST(PIMathMatrix_Test, operator_Subtraction) {
PIMathMatrix<double> matrix1(3, 3, 6.0);
PIMathMatrix<double> matrix2(3, 3, 5.0);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 - matrix2, 1.0, 3));
}
TEST(PIMathMatrix_Test, operator_Multiplication) {
PIMathMatrix<double> matrix1(3, 3, 6.72);
PIMathMatrix<double> matrix2(3, 3, 5.0);
matrix2 = matrix1*4.0;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix2, 26.88, 3));
}
TEST(PIMathMatrix_Test, operator_Division) {
PIMathMatrix<double> matrix1(3, 3, 6.72);
PIMathMatrix<double> 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<double> matrix(3, 3, 0.0);
PIMathVector<double> 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, trace) {
PIMathMatrix<double> matrix(3, 3, 0.0);
double t;
double i = 9.0;
PIMathVector<double> 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, toUpperTriangular) {
PIMathMatrix<double> matrix(3, 3, 0.0);
double d1, d2 = 1;
int i;
PIMathVector<double> 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<double> matrix1(3, 3, 0.0);
PIMathMatrix<double> matrix2(3, 3, 0.0);
PIMathMatrix<double> matrix3(3, 3, 0.0);
PIMathMatrix<double> matrix4(3, 3, 0.0);
PIMathVector<double> 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<double> matrix1(3, 3, 0.0);
PIMathMatrix<double> matrix2(3, 3, 0.0);
PIMathMatrix<double> matrix3(3, 3, 0.0);
PIMathMatrix<double> matrix4(3, 3, 0.0);
PIMathVector<double> 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<double> origMatr;
double d1, d2;
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
PIMathMatrix<double> matrix3;
PIMathVector<double> vector;
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);
d1 = matrix1.determinant();
matrix2 = matrix1.transposed();
d2 = matrix2.determinant();
matrix3 = matrix2.transposed();
ASSERT_TRUE((d1 == d2) && (matrix1 == matrix3));
}
TEST(PIMathMatrix_Test, matrixMultiplication) {
PIMathMatrix<double> matrix1(2, 2, 1.5);
PIMathMatrix<double> matrix2(2, 2, 2.5);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 7.5, 2));
}
TEST(PIMathMatrix_Test, matrixAndVectorMultiplication) {
PIMathMatrix<double> matrix1(2, 2, 1.5);
PIMathVector<double> 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<double> matrix1(2, 2, 1.5);
PIMathVector<double> 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<double> matrix1(3, 3, 1.5);
ASSERT_TRUE(cmpSquareMatrixWithValue(25.0*matrix1, 37.5, 3));
}
TEST(PIMathMatrix_Test, hermitian) {
complex<double> val;
complex<double> res;
val.imag(1.0);
val.real(1.0);
PIMathMatrix<complex<double>> 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);
} }

489
tests/math/testpimathmatrixt.cpp
View File

@@ -1,489 +0,0 @@
#include "gtest/gtest.h"
#include "pimathmatrix.h"
const uint rows = 3;
const uint cols = 3;
bool cmpSquareMatrixWithValue(PIMathMatrixT<rows, cols, double> matrix, double val, int num) {
bool b = true;
for(int i = 0; i < num; i++) {
for(int j = 0; j < num; j++) {
if(matrix.at(i, j) != val) {
b = false;
}
}
}
return b;
}
TEST(PIMathMatrixT_Test, identity) {
auto matrix = PIMathMatrixT<rows, cols, double>::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<rows, cols, double>::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<rows, cols, double>(1.0);
ASSERT_TRUE(cmpSquareMatrixWithValue(matr, 1.0, rows));
}
TEST(PIMathMatrixT_Test, cols) {
PIMathMatrixT<rows, cols, double> matr;
ASSERT_EQ(cols,matr.cols());
}
TEST(PIMathMatrixT_Test, rows) {
PIMathMatrixT<rows, cols, double> matr;
ASSERT_EQ(rows,matr.rows());
}
TEST(PIMathMatrixT_Test, col) {
PIMathMatrixT<rows, cols, double> matr;
PIMathVectorT<rows, double> vect;
uint g = 2;
matr.element(0,0) = 3;
matr.element(0,1) = 6;
matr.element(0,2) = 8;
matr.element(1,0) = 2;
matr.element(1,1) = 1;
matr.element(1,2) = 4;
matr.element(2,0) = 6;
matr.element(2,1) = 2;
matr.element(2,2) = 5;
vect = matr.col(g);
for(uint i = 0; i < matr.cols(); i++) {
if(matr.element(i, g) != vect[i]) {
ASSERT_TRUE(false);
}
}
ASSERT_TRUE(true);
}
TEST(PIMathMatrixT_Test, row) {
PIMathMatrixT<rows, cols, double> matr;
PIMathVectorT<rows, double> vect;
uint g = 2;
matr.element(0,0) = 3;
matr.element(0,1) = 6;
matr.element(0,2) = 8;
matr.element(1,0) = 2;
matr.element(1,1) = 1;
matr.element(1,2) = 4;
matr.element(2,0) = 6;
matr.element(2,1) = 2;
matr.element(2,2) = 5;
vect = matr.row(g);
for(uint i = 0; i < matr.rows(); i++) {
if(matr.element(g, i) != vect[i]) {
ASSERT_TRUE(false);
}
}
ASSERT_TRUE(true);
}
TEST(PIMathMatrixT_Test, setCol) {
PIMathMatrixT<rows, cols, double> matr;
PIMathVectorT<rows, double> 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.element(i, g) != vect[i]) {
ASSERT_TRUE(false);
}
}
ASSERT_TRUE(true);
}
TEST(PIMathMatrixT_Test, setRow) {
PIMathMatrixT<rows, cols, double> matr;
PIMathVectorT<rows, double> 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.element(g,i) != vect[i]) {
ASSERT_TRUE(false);
}
}
ASSERT_TRUE(true);
}
TEST(PIMathMatrixT_Test, swapCols) {
PIMathMatrixT<rows, cols, double> matr;
int g1 = 1, g2 = 2;
matr.element(0,0) = 3;
matr.element(0,1) = 6;
matr.element(0,2) = 8;
matr.element(1,0) = 2;
matr.element(1,1) = 1;
matr.element(1,2) = 4;
matr.element(2,0) = 6;
matr.element(2,1) = 2;
matr.element(2,2) = 5;
const PIMathVectorT<rows, double> before_Vect1 = matr.col(g1);
const PIMathVectorT<rows, double> before_Vect2 = matr.col(g2);
matr.swapCols(g1, g2);
const PIMathVectorT<rows, double> after_Vect1 = matr.col(g1);
const PIMathVectorT<rows, double> 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<rows, cols, double> matr;
int g1 = 1, g2 = 2;
matr.element(0,0) = 3;
matr.element(0,1) = 6;
matr.element(0,2) = 8;
matr.element(1,0) = 2;
matr.element(1,1) = 1;
matr.element(1,2) = 4;
matr.element(2,0) = 6;
matr.element(2,1) = 2;
matr.element(2,2) = 5;
const PIMathVectorT<rows, double> before_Vect1 = matr.row(g1);
const PIMathVectorT<rows, double> before_Vect2 = matr.row(g2);
matr.swapRows(g1, g2);
const PIMathVectorT<rows, double> after_Vect1 = matr.row(g1);
const PIMathVectorT<rows, double> 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<rows, cols, double> matr;
PIMathMatrixT<rows, cols, double> matrix1;
double g = 1.0;
matr.fill(g);
for(uint i = 0; i < cols; i++) {
for(uint j = 0; j < rows; j++) {
matrix1.element(j,i) = g;
}
}
ASSERT_TRUE(matr == matrix1);
}
TEST(PIMathMatrixT_Test, isSquareTrue) {
PIMathMatrixT<rows, cols, double> matrix1;
ASSERT_TRUE(matrix1.isSquare());
}
TEST(PIMathMatrixT_Test, isSquareFalse) {
const uint new_Cols = 4;
PIMathMatrixT<rows, new_Cols, double> matrix2;
ASSERT_FALSE(matrix2.isSquare());
}
TEST(PIMathMatrixT_Test, isIdentityTrue) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::identity();
ASSERT_TRUE(matrix1.isIdentity());
}
TEST(PIMathMatrixT_Test, isIdentityFalse) {
auto matrix1 = PIMathMatrixT<rows, cols, double>(2.5);
ASSERT_FALSE(matrix1.isIdentity());
}
TEST(PIMathMatrixT_Test, isNullTrue) {
PIMathMatrixT<rows, cols, double> matrix1;
ASSERT_TRUE(matrix1.isNull());
}
TEST(PIMathMatrixT_Test, isNullFalse) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::identity();
ASSERT_FALSE(matrix1.isNull());
}
TEST(PIMathMatrixT_Test, operator_Assignment) {
PIMathMatrixT<rows, cols, double> matrix1;
auto matrix2 = PIMathMatrixT<rows, cols, double>(6.72);
matrix1 = matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 6.72, rows));
}
TEST(PIMathMatrixT_Test, operator_EqualTrue) {
PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2;
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(PIMathMatrixT_Test, operator_EqualFalse) {
PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2;
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(PIMathMatrixT_Test, operator_Not_EqualTrue) {
PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2;
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(PIMathMatrixT_Test, operator_Not_EqualFalse) {
PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2;
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(PIMathMatrixT_Test, operator_Addition_Assignment) {
auto matrix1 = PIMathMatrixT<rows, cols, double>(6.72) ;
auto matrix2 = PIMathMatrixT<rows, cols, double>(1.0) ;
matrix1 += matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.72, rows));
}
TEST(PIMathMatrixT_Test, operator_Subtraction_Assignment) {
auto matrix1 = PIMathMatrixT<rows, cols, double>(1.0);
auto matrix2 = PIMathMatrixT<rows, cols, double>(6.72);
matrix1 -= matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, -5.72, rows));
}
TEST(PIMathMatrixT_Test, operator_Multiplication_Assignment) {
auto matrix1 = PIMathMatrixT<rows, cols, double>(6.72);
matrix1 *= 2.0;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 13.44, rows));
}
TEST(PIMathMatrixT_Test, operator_Division_Assignment) {
auto matrix1 = PIMathMatrixT<rows, cols, double>(6.72);
matrix1 /= 2.0;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 3.36, rows));
}
TEST(PIMathMatrixT_Test, operator_Addition) {
auto matrix1 = PIMathMatrixT<rows, cols, double>(6.72);
auto matrix2 = PIMathMatrixT<rows, cols, double>(8.28);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 + matrix2, 15.0, rows));
}
TEST(PIMathMatrixT_Test, operator_Subtraction) {
auto matrix1 = PIMathMatrixT<rows, cols, double>(6.0);
auto matrix2 = PIMathMatrixT<rows, cols, double>(5.0);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 - matrix2, 1.0, rows));
}
TEST(PIMathMatrixT_Test, operator_Multiplication) {
auto matrix1 = PIMathMatrixT<rows, cols, double>(6.72);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * 4.0, 26.88, rows));
}
TEST(PIMathMatrixT_Test, operator_Division) {
auto matrix1 = PIMathMatrixT<rows, cols, double>(6.72);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 / 4.0, 1.68, rows));
}
TEST(PIMathMatrixT_Test, determinantIfSquare) {
double d;
double i = 59.0;
PIMathMatrixT<rows, cols, double> matr;
matr.element(0,0) = 3;
matr.element(0,1) = 6;
matr.element(0,2) = 8;
matr.element(1,0) = 2;
matr.element(1,1) = 1;
matr.element(1,2) = 4;
matr.element(2,0) = 6;
matr.element(2,1) = 2;
matr.element(2,2) = 5;
d = matr.determinant();
ASSERT_DOUBLE_EQ(i, d);
}
TEST(PIMathMatrixT_Test, invert) {
PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2;
PIMathMatrixT<rows, cols, double> matrix3;
PIMathMatrixT<rows, cols, double> matr;
double d1, d2;
matr.element(0,0) = 3;
matr.element(0,1) = 6;
matr.element(0,2) = 8;
matr.element(1,0) = 2;
matr.element(1,1) = 1;
matr.element(1,2) = 4;
matr.element(2,0) = 6;
matr.element(2,1) = 2;
matr.element(2,2) = 5;
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<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2;
PIMathMatrixT<rows, cols, double> matrix3;
PIMathMatrixT<rows, cols, double> matr;
double d1, d2;
matrix1 = matr.identity();
matr.element(0,0) = 3;
matr.element(0,1) = 6;
matr.element(0,2) = 8;
matr.element(1,0) = 2;
matr.element(1,1) = 1;
matr.element(1,2) = 4;
matr.element(2,0) = 6;
matr.element(2,1) = 2;
matr.element(2,2) = 5;
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<rows, cols, double> matrix;
double d1, d2 = 1;
PIMathMatrixT<rows, cols, double> matr;
matr.element(0,0) = 3;
matr.element(0,1) = 6;
matr.element(0,2) = 8;
matr.element(1,0) = 2;
matr.element(1,1) = 1;
matr.element(1,2) = 4;
matr.element(2,0) = 6;
matr.element(2,1) = 2;
matr.element(2,2) = 5;
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<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2;
PIMathMatrixT<rows, cols, double> matr;
double d1, d2;
matr.element(0,0) = 3;
matr.element(0,1) = 6;
matr.element(0,2) = 8;
matr.element(1,0) = 2;
matr.element(1,1) = 1;
matr.element(1,2) = 4;
matr.element(2,0) = 6;
matr.element(2,1) = 2;
matr.element(2,2) = 5;
d1 = matr.determinant();
matrix1 = matr.transposed();
d2 = matrix1.determinant();
matrix2 = matrix1.transposed();
ASSERT_TRUE((d1 == d2) && (matr == matrix2));
}
TEST(PIMathMatrixT_Test, rotation_2x2) {
double angle = 1.0;
auto matrix = PIMathMatrixT<2u, 2u, double>::identity();
matrix.rotate(angle);
double c = cos(angle);
double s = sin(angle);
ASSERT_TRUE((c == matrix.at(1u,1u)) && (c == matrix.at(0u,0u)) && (-s == matrix.at(0u,1u)) && (s == matrix.at(1u,0u)));
}
TEST(PIMathMatrixT_Test, matrixMultiplication)
{
auto matrix1 = PIMathMatrixT<rows, cols, double>(1.5);
auto matrix2 = PIMathMatrixT<rows, cols, double>(2.5);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 11.25, 3));
}
TEST(PIMathMatrixT_Test, matrixAndVectorMultiplication) {
auto matrix1 = PIMathMatrixT<rows, cols, double>(1.5);
auto vector = PIMathVectorT<rows, double>(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<rows, cols, double>(1.5);
auto vector = PIMathVectorT<rows, double>(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<rows, cols, double>(1.5);
ASSERT_TRUE(cmpSquareMatrixWithValue(25.0*matrix1, 37.5, 3));
}

84
tests/math/testpivector2d.cpp
View File

@@ -1,84 +0,0 @@
#include "gtest/gtest.h"
#include "pivector2d.h"
int ROWS_COUNT_INIT = 31;
int ROWS_COUNT_INCREASE = 41;
int ROWS_COUNT_REDUCE = 22;
int COLS_COUNT_INIT = 34;
int COLS_COUNT_INCREASE = 44;
int COLS_COUNT_REDUCE = 13;
void assert_fill_with(PIVector2D<int> vec, int rows, int cols) {
for(int r = 0; r < rows; r++) {
for(int c = 0; c < cols; c++) {
ASSERT_EQ(vec.element(r, c), r * COLS_COUNT_INIT + c);
}
}
}
class Vector2D : public ::testing::Test {
protected:
PIVector2D<int> vec = PIVector2D<int>(ROWS_COUNT_INIT, COLS_COUNT_INIT);
void SetUp() override {
for (int r = 0; r < ROWS_COUNT_INIT; ++r) {
for (int c = 0; c < COLS_COUNT_INIT; ++c) {
vec.element(r, c) = r * COLS_COUNT_INIT + c;
}
}
}
void resize_reduce_is_data_stay_consistent(int newRowsCount, int newColsCount) {
vec.resize(newRowsCount, newColsCount, 0);
assert_fill_with(vec, newRowsCount, newColsCount);
}
void resize_increase_is_data_stay_consistent(int newRowsCount, int newColsCount) {
vec.resize(newRowsCount, newColsCount, 0);
assert_fill_with(vec, ROWS_COUNT_INIT, COLS_COUNT_INIT);
for (int r = 0; r < newRowsCount; ++r) {
for (int c = 0; c < newColsCount; ++c) {
if (r < ROWS_COUNT_INIT || c < COLS_COUNT_INIT) continue;
ASSERT_EQ(vec.element(r, c), 0);
}
}
}
};
TEST_F(Vector2D, resize_is_increase_col_count) {
vec.resize(ROWS_COUNT_INIT, COLS_COUNT_INCREASE, 0);
ASSERT_EQ(vec.cols(), COLS_COUNT_INCREASE);
}
TEST_F(Vector2D, resize_is_reduce_col_count) {
vec.resize(ROWS_COUNT_INIT, COLS_COUNT_REDUCE, 0);
ASSERT_EQ(vec.cols(), COLS_COUNT_REDUCE);
}
TEST_F(Vector2D, resize_is_increase_rows_count) {
vec.resize(ROWS_COUNT_INCREASE, COLS_COUNT_INIT, 0);
ASSERT_EQ(vec.rows(), ROWS_COUNT_INCREASE);
}
TEST_F(Vector2D, resize_is_reduce_rows_count) {
vec.resize(ROWS_COUNT_REDUCE, COLS_COUNT_INIT, 0);
ASSERT_EQ(vec.rows(), ROWS_COUNT_REDUCE);
}
TEST_F(Vector2D, resize_increase_both_is_data_stay_consistent) {
resize_increase_is_data_stay_consistent(ROWS_COUNT_INCREASE, COLS_COUNT_INCREASE);
}
TEST_F(Vector2D, resize_reduce_cols_is_data_stay_consistent) {
resize_reduce_is_data_stay_consistent(ROWS_COUNT_INIT, COLS_COUNT_REDUCE);
}
TEST_F(Vector2D, resize_reduce_rows_is_data_stay_consistent) {
resize_reduce_is_data_stay_consistent(ROWS_COUNT_REDUCE, COLS_COUNT_INIT);
}
TEST_F(Vector2D, resize_reduce_both_is_data_stay_consistent) {
resize_reduce_is_data_stay_consistent(ROWS_COUNT_REDUCE, COLS_COUNT_REDUCE);
}