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

indentation in strings

Browse Source
This commit is contained in:
Шишов Максим Денисович
2020-09-10 17:13:02 +03:00
committed by Gama
parent 2b2ad436f0
commit 9f6fa4cb8e
2 changed files with 98 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
tests/math/testpimathmatrix.cpp
View File

@@ -2,8 +2,7 @@
#include "pimathmatrix.h"
template<typename Type>
bool cmpSquareMatrixWithValue(PIMathMatrix<double> matrix, Type val, int num)
{
bool cmpSquareMatrixWithValue(PIMathMatrix<double> matrix, Type val, int num) {
bool b = true;
for(int i = 0; i < num; i++) {
for(int j = 0; j < num; j++) {
@@ -15,8 +14,7 @@ bool cmpSquareMatrixWithValue(PIMathMatrix<double> matrix, Type val, int num)
return b;
}
TEST(PIMathMatrix_Test, identity)
{
TEST(PIMathMatrix_Test, identity) {
auto matrix = PIMathMatrix<double>::identity(3, 3);
for(int i = 0; i < 3; i++){
if(matrix[i][i] != 1.0){
@@ -35,8 +33,7 @@ TEST(PIMathMatrix_Test, identity)
ASSERT_TRUE(true);
}
TEST(PIMathMatrixT_Test, element)
{
TEST(PIMathMatrixT_Test, element) {
auto matrix = PIMathMatrix<double>::identity(3, 3);
for(uint i = 0; i < 3; i++) {
if(matrix.element(i,i) != 1.0) {
@@ -55,8 +52,7 @@ TEST(PIMathMatrixT_Test, element)
ASSERT_TRUE(true);
}
TEST(PIMathMatrix_Test, matrixRow)
{
TEST(PIMathMatrix_Test, matrixRow) {
PIMathVector<double> vector;
vector.resize(3, 3.0);
auto matrix = PIMathMatrix<double>::matrixRow(vector);
@@ -68,8 +64,7 @@ TEST(PIMathMatrix_Test, matrixRow)
ASSERT_TRUE(true);
}
TEST(PIMathMatrix_Test, matrixCol)
{
TEST(PIMathMatrix_Test, matrixCol) {
PIMathVector<double> vector;
vector.resize(3, 3.0);
auto matrix = PIMathMatrix<double>::matrixCol(vector);
@@ -81,8 +76,7 @@ TEST(PIMathMatrix_Test, matrixCol)
ASSERT_TRUE(true);
}
TEST(PIMathMatrix_Test, setCol)
{
TEST(PIMathMatrix_Test, setCol) {
PIMathVector<double> vector;
vector.resize(3, 3.0);
auto matrix = PIMathMatrix<double>::matrixCol(vector);
@@ -96,8 +90,7 @@ TEST(PIMathMatrix_Test, setCol)
ASSERT_TRUE(true);
}
TEST(PIMathMatrix_Test, setRow)
{
TEST(PIMathMatrix_Test, setRow) {
PIMathVector<double> vector;
vector.resize(3, 3.0);
auto matrix = PIMathMatrix<double>::matrixRow(vector);
@@ -111,15 +104,13 @@ TEST(PIMathMatrix_Test, setRow)
ASSERT_TRUE(true);
}
TEST(PIMathMatrix_Test, swapCols)
{
TEST(PIMathMatrix_Test, swapCols) {
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];
bool b;
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
@@ -145,24 +136,16 @@ TEST(PIMathMatrix_Test, swapCols)
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);
ASSERT_TRUE((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0));
}
TEST(PIMathMatrix_Test, swapRows)
{
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];
bool b;
vector.resize(3, 3.0);
vector.at(0) = 3.0;
vector.at(1) = 6.0;
@@ -188,80 +171,63 @@ TEST(PIMathMatrix_Test, swapRows)
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);
ASSERT_TRUE((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0));
}
TEST(PIMathMatrix_Test, fill)
{
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)
{
TEST(PIMathMatrix_Test, isSquareTrue) {
PIMathMatrix<double> matrix(3, 3, 1.0);
ASSERT_TRUE(matrix.isSquare());
}
TEST(PIMathMatrix_Test, isSquareFalse)
{
TEST(PIMathMatrix_Test, isSquareFalse) {
PIMathMatrix<double> matrix(2, 4, 1.0);
ASSERT_FALSE(matrix.isSquare());
}
TEST(PIMathMatrix_Test, isIdentityTrue)
{
TEST(PIMathMatrix_Test, isIdentityTrue) {
auto matrix = PIMathMatrix<double>::identity(3, 3);
ASSERT_TRUE(matrix.isIdentity());
}
TEST(PIMathMatrix_Test, isIdentityFalse)
{
TEST(PIMathMatrix_Test, isIdentityFalse) {
PIMathMatrix<double> matrix(3, 3, 5.0);
ASSERT_FALSE(matrix.isIdentity());
}
TEST(PIMathMatrix_Test, isNullTrue)
{
TEST(PIMathMatrix_Test, isNullTrue) {
PIMathMatrix<double> matrix(3, 3, 0.0);
ASSERT_TRUE(matrix.isNull());
}
TEST(PIMathMatrix_Test, isNullFalse)
{
TEST(PIMathMatrix_Test, isNullFalse) {
PIMathMatrix<double> matrix(3, 3, 5.0);
ASSERT_FALSE(matrix.isNull());
}
TEST(PIMathMatrix_Test, isValidTrue)
{
TEST(PIMathMatrix_Test, isValidTrue) {
PIMathMatrix<double> matrix(3, 3, 1.62);
ASSERT_TRUE(matrix.isValid());
}
TEST(PIMathMatrix_Test, isValidFalse)
{
TEST(PIMathMatrix_Test, isValidFalse) {
PIMathMatrix<double> matrix;
ASSERT_FALSE(matrix.isValid());
}
TEST(PIMathMatrix_Test, operator_Assignment)
{
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)
{
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;
@@ -275,8 +241,7 @@ TEST(PIMathMatrix_Test, operator_EqualTrue)
ASSERT_TRUE(matrix1 == matrix2);
}
TEST(PIMathMatrix_Test, operator_EqualFalse)
{
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;
@@ -290,8 +255,7 @@ TEST(PIMathMatrix_Test, operator_EqualFalse)
ASSERT_FALSE(matrix1 == matrix2);
}
TEST(PIMathMatrix_Test, operator_Not_EqualTrue)
{
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;
@@ -305,8 +269,7 @@ TEST(PIMathMatrix_Test, operator_Not_EqualTrue)
ASSERT_TRUE(matrix1 != matrix2);
}
TEST(PIMathMatrix_Test, operator_Not_EqualFalse)
{
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;
@@ -320,67 +283,58 @@ TEST(PIMathMatrix_Test, operator_Not_EqualFalse)
ASSERT_FALSE(matrix1 != matrix2);
}
TEST(PIMathMatrix_Test, operator_Addition_Aassignment)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
TEST(PIMathMatrix_Test, determinantIfSquare) {
double d;
double i = 59.0;
PIMathMatrix<double> matrix(3, 3, 0.0);
@@ -402,15 +356,13 @@ TEST(PIMathMatrix_Test, determinantIfSquare)
ASSERT_DOUBLE_EQ(d, i);
}
TEST(PIMathMatrix_Test, determinantIfNotSquare)
{
TEST(PIMathMatrix_Test, determinantIfNotSquare) {
PIMathMatrix<double> matrix(3, 5, 1.0);
matrix.element(1,1) = 5.0;
ASSERT_FALSE(matrix.determinant());
}
TEST(PIMathMatrix_Test, trace)
{
TEST(PIMathMatrix_Test, trace) {
PIMathMatrix<double> matrix(3, 3, 0.0);
double t;
double i = 9.0;
@@ -432,15 +384,13 @@ TEST(PIMathMatrix_Test, trace)
ASSERT_DOUBLE_EQ(t, i);
}
TEST(PIMathMatrix_Test, traceIfNotSquare)
{
TEST(PIMathMatrix_Test, traceIfNotSquare) {
PIMathMatrix<double> matrix(3, 5, 1.0);
matrix.element(1,1) = 5.0;
ASSERT_FALSE(matrix.trace());
}
TEST(PIMathMatrix_Test, toUpperTriangular)
{
TEST(PIMathMatrix_Test, toUpperTriangular) {
PIMathMatrix<double> matrix(3, 3, 0.0);
double d1, d2 = 1;
int i;
@@ -467,8 +417,7 @@ TEST(PIMathMatrix_Test, toUpperTriangular)
ASSERT_DOUBLE_EQ(d1, d2);
}
TEST(PIMathMatrix_Test, invert)
{
TEST(PIMathMatrix_Test, invert) {
double d1, d2;
PIMathMatrix<double> matrix1(3, 3, 0.0);
PIMathMatrix<double> matrix2(3, 3, 0.0);
@@ -496,8 +445,7 @@ TEST(PIMathMatrix_Test, invert)
ASSERT_TRUE((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000));
}
TEST(PIMathMatrix_Test, inverted)
{
TEST(PIMathMatrix_Test, inverted) {
double d1, d2;
PIMathMatrix<double> matrix1(3, 3, 0.0);
PIMathMatrix<double> matrix2(3, 3, 0.0);
@@ -525,8 +473,7 @@ TEST(PIMathMatrix_Test, inverted)
ASSERT_TRUE((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000));
}
TEST(PIMathMatrix_Test, transposed)
{
TEST(PIMathMatrix_Test, transposed) {
PIMathMatrix<double> origMatr;
double d1, d2;
PIMathMatrix<double> matrix1;
@@ -554,15 +501,13 @@ TEST(PIMathMatrix_Test, transposed)
ASSERT_TRUE((d1 == d2) && (matrix1 == matrix3));
}
TEST(PIMathMatrix_Test, matrixMultiplication)
{
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)
{
TEST(PIMathMatrix_Test, matrixAndVectorMultiplication) {
PIMathMatrix<double> matrix1(2, 2, 1.5);
PIMathVector<double> vector;
vector.resize(2, 2.5);
@@ -574,8 +519,7 @@ TEST(PIMathMatrix_Test, matrixAndVectorMultiplication)
ASSERT_TRUE(true);
}
TEST(PIMathMatrix_Test, vectorAndMatrixMultiplication)
{
TEST(PIMathMatrix_Test, vectorAndMatrixMultiplication) {
PIMathMatrix<double> matrix1(2, 2, 1.5);
PIMathVector<double> vector;
vector.resize(2, 2.5);
@@ -587,14 +531,12 @@ TEST(PIMathMatrix_Test, vectorAndMatrixMultiplication)
ASSERT_TRUE(true);
}
TEST(PIMathMatrix_Test, valAndMatrixMultiplication)
{
TEST(PIMathMatrix_Test, valAndMatrixMultiplication) {
PIMathMatrix<double> matrix1(3, 3, 1.5);
ASSERT_TRUE(cmpSquareMatrixWithValue(25.0*matrix1, 37.5, 3));
}
TEST(PIMathMatrix_Test, hermitian)
{
TEST(PIMathMatrix_Test, hermitian) {
complex<double> val;
complex<double> res;
val.imag(1.0);