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

matrix tests

Browse Source
This commit is contained in:
Шишов Максим Денисович
2020-07-23 17:28:10 +03:00
parent dbb84885e3
commit d8e47afe13
2 changed files with 947 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
CMakeLists.txt
View File

@@ -185,7 +185,7 @@ set(PIP_MAIN_FOLDERS)
foreach(F ${PIP_FOLDERS})
list(APPEND PIP_MAIN_FOLDERS "\"${PROJECT_SOURCE_DIR}/${PIP_SRC_MAIN}/${F}\"")
include_directories("${PIP_SRC_MAIN}/${F}")
gather_src("${PIP_SRC_MAIN}/${F}" CPP_LIB_MAIN HDRS PHDRS)
gather_src("${PIP_SRC_MAIN}/${F}" CPP_LIB_MAIN HDRS PHDRS)
endforeach(F)
# Crypt lib
gather_src("${PIP_SRC_CRYPT}" CPP_LIB_CRYPT HDRS PHDRS)
@@ -216,6 +216,9 @@ gather_src("${PIP_SRC_CONCURRENT_TEST}" CPP_CONCURRENT_TEST HDRS PHDRS)
# Cloud lib
gather_src("${PIP_SRC_CLOUD}" CPP_LIB_CLOUD HDRS PHDRS)
#Math test lib
gather_src("${PIP_SRC_MATH_TEST}" CPP_MATH_TEST HDRS PHDRS)
if(PIP_FREERTOS)
add_definitions(-DPIP_FREERTOS)
set(ICU OFF)
@@ -605,13 +608,13 @@ if (NOT CROSSTOOLS)
target_link_libraries(pip_concurrent_test gtest_main gmock_main pip_concurrent)
add_test(NAME pip_concurrent_test COMMAND tests)
add_custom_target(pip_concurrent_test_perform ALL COMMAND pip_concurrent_test)
endif()
if(MATH_TESTS)
add_executable(pip_math_test ${CPP_MATH_TEST})
target_link_libraries(pip_math_test gtest_main gmock_main pip_math)
add_test(NAME pip_math_test COMMAND tests)
add_custom_target(pip_math_test_perform ALL COMMAND pip_math_test)
endif()
endif()
if(MATH_TESTS)
add_executable(pip_math_test ${CPP_MATH_TEST})
target_link_libraries(pip_math_test gtest_main gmock_main PIP)
add_test(NAME pip_math_test COMMAND tests)
#add_custom_target(pip_math_test_perform ALL COMMAND pip_math_test)
endif()
# Build cloud library if crypt enabled
if(sodium_FOUND)

936
lib/main/math/test/testpimathmatrix.cpp
View File

@@ -0,0 +1,936 @@
#include "gtest/gtest.h"
#include "pimathmatrix.h"
using namespace std;
PIMathMatrix<double> origMatr;
TEST(PIMathMatrix_Test, identity)
{
PIMathMatrix<double> matrix;
int i;
double d;
bool a, b;
matrix = origMatr.identity(3, 3);
d = matrix.determinant();
for(i = 0; i < 3; i++)
{
if(matrix[i][i] == 1.0)
{
b = true;
}
else
{
b = false;
break;
}
}
if(d == 1.0)
{
a = true;
}
else
{
a = false;
}
ASSERT_TRUE(a && b);
}
TEST(PIMathMatrix_Test, matrixRow)
{
PIMathMatrix<double> matrix;
PIMathVector<double> vector;
uint i;
bool b;
vector.resize(3, 3.0);
vector.fill(5.0);
matrix = origMatr.matrixRow(vector);
for(i = 0; i < vector.size(); i++)
{
if(matrix[0][i] == 5.0)
{
b = true;
}
else
{
b = false;
break;
}
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, matrixCol)
{
PIMathMatrix<double> matrix;
PIMathVector<double> vector;
uint i;
bool b;
vector.resize(3, 3.0);
vector.fill(5.0);
matrix = origMatr.matrixCol(vector);
for(i = 0; i < vector.size(); i++)
{
if(matrix[i][0] == 5.0)
{
b = true;
}
else
{
b = false;
break;
}
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, setCol)
{
PIMathMatrix<double> matrix;
PIMathVector<double> vector;
uint i;
bool b;
vector.resize(3, 3.0);
vector.fill(5.0);
matrix = origMatr.matrixCol(vector);
vector.fill(10.0);
matrix.setCol(0, vector);
for(i = 0; i < vector.size(); i++)
{
if(matrix[i][0] == 10.0)
{
b = true;
}
else
{
b = false;
break;
}
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, setRow)
{
PIMathMatrix<double> matrix;
PIMathVector<double> vector;
uint i;
bool b;
vector.resize(3, 3.0);
vector.fill(5.0);
matrix = origMatr.matrixRow(vector);
vector.fill(10.0);
matrix.setRow(0, vector);
for(i = 0; i < vector.size(); i++)
{
if(matrix[0][i] == 10.0)
{
b = true;
}
else
{
b = false;
break;
}
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, swapCols)
{
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];
bool b;
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
vector.at(2) = 8.0;
matrix1 = origMatr.identity(3, 3);
matrix1.setCol(0, vector);
vector.at(0) = 2.0;
vector.at(1) = 1.0;
vector.at(2) = 4.0;
matrix1.setCol(1, vector);
vector.at(0) = 6.0;
vector.at(1) = 2.0;
vector.at(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);
}
if((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0))
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, swapRows)
{
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];
bool b;
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
vector.at(2) = 8.0;
matrix1 = origMatr.identity(3, 3);
matrix1.setCol(0, vector);
vector.at(0) = 2.0;
vector.at(1) = 1.0;
vector.at(2) = 4.0;
matrix1.setCol(1, vector);
vector.at(0) = 6.0;
vector.at(1) = 2.0;
vector.at(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);
}
if((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0))
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, fill)
{
PIMathMatrix<double> matrix;
int i = 0;
int j = 0;
int k = 0;
bool b;
matrix = origMatr.identity(3, 3);
matrix.fill(5.0);
while(i < 9)
{
if(k < 3)
{
if(matrix.element(j,k) == 5.0)
{
b = true;
}
else
{
b = false;
break;
}
k++;
if(k == 3)
{
j++;
k = 0;
}
}
i++;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, isSquare)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
bool b;
matrix1 = origMatr.identity(3,3);
matrix2 = origMatr.identity(4,3);
if((matrix1.isSquare() == true) && (matrix2.isSquare() == false))
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, isIdentity)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
bool b;
matrix1 = origMatr.identity(3,3);
matrix2 = origMatr.identity(3,3);
matrix2.fill(3.932);
if((matrix1.isIdentity() == true) && (matrix2.isIdentity() == false))
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, isNull)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
bool b;
matrix1 = origMatr.identity(3,3);
matrix2 = origMatr.identity(3,3);
matrix1.fill(0.0);
matrix2.fill(3.932);
if((matrix1.isNull() == true) && (matrix2.isNull() == false))
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, isValid)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
bool b;
matrix1 = origMatr.identity(3,3);
if((matrix1.isValid() == true) && (matrix2.isValid() == false))
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, operator_Assignment)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
int i = 0;
int j = 0;
int k = 0;
bool b;
matrix1 = origMatr.identity(3,3);
matrix2 = origMatr.identity(3,3);
matrix2.fill(6.72);
matrix1 = matrix2;
while(i < 9)
{
if(k < 3)
{
if(matrix1.element(j,k) == 6.72)
{
b = true;
}
else
{
b = false;
break;
}
k++;
if(k == 3)
{
j++;
k = 0;
}
}
i++;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, operator_Equal)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
PIMathMatrix<double> matrix3;
PIMathVector<double> vector;
bool b;
matrix1 = origMatr.identity(3,3);
matrix2 = origMatr.identity(3,3);
matrix3 = origMatr.identity(3,3);
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
vector.at(2) = 8.0;
matrix1.setCol(0, vector);
matrix2.setCol(0, vector);
matrix3.setCol(0, vector);
vector.at(0) = 2.0;
vector.at(1) = 1.0;
vector.at(2) = 4.0;
matrix1.setCol(1, vector);
matrix2.setCol(1, vector);
matrix3.setCol(1, vector);
vector.at(0) = 6.0;
vector.at(1) = 2.0;
vector.at(2) = 5.0;
matrix1.setCol(2, vector);
matrix2.setCol(2, vector);
vector.at(0) = 566.0;
vector.at(1) = 564.0;
vector.at(2) = 543.0;
matrix3.setCol(2, vector);
if(((matrix1 == matrix2) == true) && ((matrix1 == matrix3) == false))
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, operator_Not_Equal)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
PIMathMatrix<double> matrix3;
PIMathVector<double> vector;
bool b;
matrix1 = origMatr.identity(3,3);
matrix2 = origMatr.identity(3,3);
matrix3 = origMatr.identity(3,3);
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
vector.at(2) = 8.0;
matrix1.setCol(0, vector);
matrix2.setCol(0, vector);
matrix3.setCol(0, vector);
vector.at(0) = 2.0;
vector.at(1) = 1.0;
vector.at(2) = 4.0;
matrix1.setCol(1, vector);
matrix2.setCol(1, vector);
matrix3.setCol(1, vector);
vector.at(0) = 6.0;
vector.at(1) = 2.0;
vector.at(2) = 5.0;
matrix1.setCol(2, vector);
matrix2.setCol(2, vector);
vector.at(0) = 566.0;
vector.at(1) = 564.0;
vector.at(2) = 543.0;
matrix3.setCol(2, vector);
if(((matrix1 != matrix2) == false) && ((matrix1 != matrix3) == true))
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, operator_Addition_Aassignment)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
bool b;
int i = 0;
int j = 0;
int k = 0;
matrix1 = origMatr.identity(3,3);
matrix2 = origMatr.identity(3,3);
matrix2.fill(6.72);
matrix1.fill(1.0);
matrix1 += matrix2;
while(i < 9)
{
if(k < 3)
{
if(matrix1.element(j,k) == 7.72)
{
b = true;
}
else
{
b = false;
break;
}
k++;
if(k == 3)
{
j++;
k = 0;
}
}
i++;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, operator_Subtraction_Assignment)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
bool b;
int i = 0;
int j = 0;
int k = 0;
matrix1 = origMatr.identity(3,3);
matrix2 = origMatr.identity(3,3);
matrix2.fill(6.72);
matrix1.fill(1.0);
matrix1 -= matrix2;
while(i < 9)
{
if(k < 3)
{
if(matrix1.element(j,k) == -5.72)
{
b = true;
}
else
{
b = false;
break;
}
k++;
if(k == 3)
{
j++;
k = 0;
}
}
i++;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, operator_Multiplication_Assignment)
{
PIMathMatrix<double> matrix1;
bool b;
int i = 0;
int j = 0;
int k = 0;
matrix1 = origMatr.identity(3,3);
matrix1.fill(6.72);
matrix1 *= 2.0;
while(i < 9)
{
if(k < 3)
{
if(matrix1.element(j,k) == 13.44)
{
b = true;
}
else
{
b = false;
break;
}
k++;
if(k == 3)
{
j++;
k = 0;
}
}
i++;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, operator_Division_Assignment)
{
PIMathMatrix<double> matrix1;
bool b;
int i = 0;
int j = 0;
int k = 0;
matrix1 = origMatr.identity(3,3);
matrix1.fill(6.72);
matrix1 /= 2.0;
while(i < 9)
{
if(k < 3)
{
if(matrix1.element(j,k) == 3.36)
{
b = true;
}
else
{
b = false;
break;
}
k++;
if(k == 3)
{
j++;
k = 0;
}
}
i++;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, operator_Addition)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
bool b;
int i = 0;
int j = 0;
int k = 0;
matrix1 = origMatr.identity(3,3);
matrix2 = origMatr.identity(3,3);
matrix1.fill(6.72);
matrix2.fill(8.28);
while(i < 9)
{
if(k < 3)
{
if((matrix1+matrix2).element(j,k) == 15.0)
{
b = true;
}
else
{
b = false;
break;
}
k++;
if(k == 3)
{
j++;
k = 0;
}
}
i++;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, operator_Subtraction)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
bool b;
matrix1 = origMatr.identity(3, 3);
matrix2 = origMatr.identity(3, 3);
origMatr.fill(8.0);
matrix1.fill(8.28);
origMatr = origMatr - matrix1;
matrix2.fill(-0.28);
if(origMatr == matrix2)
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, operator_Multiplication)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
bool b;
int i = 0;
int j = 0;
int k = 0;
matrix1 = origMatr.identity(3,3);
matrix2 = origMatr.identity(3,3);
matrix1.fill(6.72);
matrix2 = matrix1*4.0;
while(i < 9)
{
if(k < 3)
{
if(matrix2.element(j,k) == 26.88)
{
b = true;
}
else
{
b = false;
break;
}
k++;
if(k == 3)
{
j++;
k = 0;
}
}
i++;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, operator_Division)
{
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
bool b;
int i = 0;
int j = 0;
int k = 0;
matrix1 = origMatr.identity(3,3);
matrix2 = origMatr.identity(3,3);
matrix1.fill(6.72);
matrix2 = matrix1/4.0;
while(i < 9)
{
if(k < 3)
{
if(matrix2.element(j,k) == 1.68)
{
b = true;
}
else
{
b = false;
break;
}
k++;
if(k == 3)
{
j++;
k = 0;
}
}
i++;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, determinant)
{
double d;
double i = 59.0;
PIMathMatrix<double> matrix;
PIMathVector<double> vector;
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
vector.at(2) = 8.0;
matrix = origMatr.identity(3, 3);
matrix.setCol(0, vector);
vector.at(0) = 2.0;
vector.at(1) = 1.0;
vector.at(2) = 4.0;
matrix.setCol(1, vector);
vector.at(0) = 6.0;
vector.at(1) = 2.0;
vector.at(2) = 5.0;
matrix.setCol(2, vector);
d = matrix.determinant();
ASSERT_DOUBLE_EQ(d, i);
}
TEST(PIMathMatrix_Test, trace)
{
double t;
double i = 9.0;
PIMathMatrix<double> matrix;
PIMathVector<double> vector;
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
vector.at(2) = 8.0;
matrix = origMatr.identity(3, 3);
matrix.setCol(0, vector);
vector.at(0) = 2.0;
vector.at(1) = 1.0;
vector.at(2) = 4.0;
matrix.setCol(1, vector);
vector.at(0) = 6.0;
vector.at(1) = 2.0;
vector.at(2) = 5.0;
matrix.setCol(2, vector);
t = matrix.trace();
ASSERT_DOUBLE_EQ(t, i);
}
TEST(PIMathMatrix_Test, toUpperTriangular)
{
double d1, d2 = 1;
int i;
PIMathMatrix<double> matrix;
PIMathVector<double> vector;
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
vector.at(2) = 8.0;
matrix = origMatr.identity(3, 3);
matrix.setCol(0, vector);
vector.at(0) = 2.0;
vector.at(1) = 1.0;
vector.at(2) = 4.0;
matrix.setCol(1, vector);
vector.at(0) = 6.0;
vector.at(1) = 2.0;
vector.at(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;
bool b;
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
PIMathMatrix<double> matrix3;
PIMathMatrix<double> matrix4;
PIMathVector<double> vector;
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
vector.at(2) = 8.0;
matrix1 = origMatr.identity(3, 3);
matrix1.setCol(0, vector);
vector.at(0) = 2.0;
vector.at(1) = 1.0;
vector.at(2) = 4.0;
matrix1.setCol(1, vector);
vector.at(0) = 6.0;
vector.at(1) = 2.0;
vector.at(2) = 5.0;
matrix1.setCol(2, vector);
d1 = matrix1.determinant();
matrix2 = matrix1;
matrix2.invert();
d2 = matrix2.determinant();
matrix3 = origMatr.identity(3, 3);
matrix4 = origMatr.identity(3, 3);
matrix4.invert();
if((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000))
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, inverted)
{
double d1, d2;
bool b;
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
PIMathMatrix<double> matrix3;
PIMathMatrix<double> matrix4;
PIMathVector<double> vector;
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
vector.at(2) = 8.0;
matrix1 = origMatr.identity(3, 3);
matrix1.setCol(0, vector);
vector.at(0) = 2.0;
vector.at(1) = 1.0;
vector.at(2) = 4.0;
matrix1.setCol(1, vector);
vector.at(0) = 6.0;
vector.at(1) = 2.0;
vector.at(2) = 5.0;
matrix1.setCol(2, vector);
d1 = matrix1.determinant();
matrix2 = matrix1;
matrix1 = matrix2.invert();
d2 = matrix1.determinant();
matrix3 = origMatr.identity(3, 3);
matrix4 = origMatr.identity(3, 3);
matrix3 = matrix4.invert();
if((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000))
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}
TEST(PIMathMatrix_Test, transposed)
{
double d1, d2;
bool b;
PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2;
PIMathMatrix<double> matrix3;
PIMathVector<double> vector;
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
vector.at(2) = 8.0;
matrix1 = origMatr.identity(3, 3);
matrix1.setCol(0, vector);
vector.at(0) = 2.0;
vector.at(1) = 1.0;
vector.at(2) = 4.0;
matrix1.setCol(1, vector);
vector.at(0) = 6.0;
vector.at(1) = 2.0;
vector.at(2) = 5.0;
matrix1.setCol(2, vector);
d1 = matrix1.determinant();
matrix2 = matrix1.transposed();
d2 = matrix2.determinant();
matrix3 = matrix2.transposed();
if((d1 == d2) && (matrix1 == matrix3))
{
b = true;
}
else
{
b = false;
}
ASSERT_TRUE(b);
}