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

new tests fo PIMathVector.h and tab correction

Browse Source
This commit is contained in:
Максим Шишов
2020-10-06 17:07:34 +03:00
parent 49905a3de0
commit d6637047b2
4 changed files with 1654 additions and 1480 deletions
Download Patch File Download Diff File Expand all files Collapse all files

842
tests/math/testpimathmatrix.cpp
View File

@@ -2,553 +2,553 @@
#include "pimathmatrix.h" #include "pimathmatrix.h"
bool cmpSquareMatrixWithValue(PIMathMatrix<double> matrix, double val, int num) { bool cmpSquareMatrixWithValue(PIMathMatrix<double> matrix, double 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++) {
if(matrix.element(i, j) - val >= double(1E-200)) { if(matrix.element(i, j) - val >= double(1E-200)) {
b = false; b = false;
} }
} }
} }
return b; return b;
} }
TEST(PIMathMatrix_Test, identity) { TEST(PIMathMatrix_Test, identity) {
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++) {
if(i != j) { if(i != j) {
if(matrix[i][j] != 0.0){ if(matrix[i][j] != 0.0){
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
else { else {
if(matrix[i][i] != 1.0){ if(matrix[i][i] != 1.0){
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrixT_Test, element) { TEST(PIMathMatrixT_Test, element) {
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++){
if(i != j){ if(i != j){
if(matrix[i][j] != 0.0){ if(matrix[i][j] != 0.0){
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
else { else {
if(matrix.element(i,i) != 1.0) { if(matrix.element(i,i) != 1.0) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrix_Test, matrixRow) { TEST(PIMathMatrix_Test, matrixRow) {
PIMathVector<double> vector; PIMathVector<double> vector;
vector.resize(3, 3.0); vector.resize(3, 3.0);
auto matrix = PIMathMatrix<double>::matrixRow(vector); auto matrix = PIMathMatrix<double>::matrixRow(vector);
for(uint i = 0; i < vector.size(); i++) { for(uint i = 0; i < vector.size(); i++) {
if(matrix[0][i] != 3.0) { if(matrix[0][i] != 3.0) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrix_Test, matrixCol) { TEST(PIMathMatrix_Test, matrixCol) {
PIMathVector<double> vector; PIMathVector<double> vector;
vector.resize(3, 3.0); vector.resize(3, 3.0);
auto matrix = PIMathMatrix<double>::matrixCol(vector); auto matrix = PIMathMatrix<double>::matrixCol(vector);
for(uint i = 0; i < vector.size(); i++) { for(uint i = 0; i < vector.size(); i++) {
if(matrix[i][0] != 3.0) { if(matrix[i][0] != 3.0) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrix_Test, setCol) { TEST(PIMathMatrix_Test, setCol) {
PIMathVector<double> vector; PIMathVector<double> vector;
vector.resize(3, 3.0); vector.resize(3, 3.0);
auto matrix = PIMathMatrix<double>::matrixCol(vector); auto matrix = PIMathMatrix<double>::matrixCol(vector);
vector.fill(10.0); vector.fill(10.0);
matrix.setCol(0, vector); matrix.setCol(0, vector);
for(uint i = 0; i < vector.size(); i++) { for(uint i = 0; i < vector.size(); i++) {
if(matrix[i][0] != 10.0) { if(matrix[i][0] != 10.0) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrix_Test, setRow) { TEST(PIMathMatrix_Test, setRow) {
PIMathVector<double> vector; PIMathVector<double> vector;
vector.resize(3, 3.0); vector.resize(3, 3.0);
auto matrix = PIMathMatrix<double>::matrixRow(vector); auto matrix = PIMathMatrix<double>::matrixRow(vector);
vector.fill(10.0); vector.fill(10.0);
matrix.setRow(0, vector); matrix.setRow(0, vector);
for(uint i = 0; i < vector.size(); i++) { for(uint i = 0; i < vector.size(); i++) {
if(matrix[0][i] != 10.0) { if(matrix[0][i] != 10.0) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
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) { TEST(PIMathMatrix_Test, swapRows) {
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(0, i); a1[i] = matrix1.element(0, i);
a2[i] = matrix1.element(1, i); a2[i] = matrix1.element(1, i);
a3[i] = matrix1.element(2, i); a3[i] = matrix1.element(2, i);
} }
matrix1.swapRows(i1, i2); matrix1.swapRows(i1, i2);
for(int i = 0; i < 3; i++) { for(int i = 0; i < 3; i++) {
b1[i] = matrix1.element(0, i); b1[i] = matrix1.element(0, i);
b2[i] = matrix1.element(1, i); b2[i] = matrix1.element(1, i);
b3[i] = matrix1.element(2, 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)); 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); PIMathMatrix<double> matrix(3, 3, 5.0);
matrix.fill(7.0); matrix.fill(7.0);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, 7.0, 3)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, 7.0, 3));
} }
TEST(PIMathMatrix_Test, isSquareTrue) { TEST(PIMathMatrix_Test, isSquareTrue) {
PIMathMatrix<double> matrix(3, 3, 1.0); PIMathMatrix<double> matrix(3, 3, 1.0);
ASSERT_TRUE(matrix.isSquare()); ASSERT_TRUE(matrix.isSquare());
} }
TEST(PIMathMatrix_Test, isSquareFalse) { TEST(PIMathMatrix_Test, isSquareFalse) {
PIMathMatrix<double> matrix(2, 4, 1.0); PIMathMatrix<double> matrix(2, 4, 1.0);
ASSERT_FALSE(matrix.isSquare()); ASSERT_FALSE(matrix.isSquare());
} }
TEST(PIMathMatrix_Test, isIdentityTrue) { TEST(PIMathMatrix_Test, isIdentityTrue) {
auto matrix = PIMathMatrix<double>::identity(3, 3); auto matrix = PIMathMatrix<double>::identity(3, 3);
ASSERT_TRUE(matrix.isIdentity()); ASSERT_TRUE(matrix.isIdentity());
} }
TEST(PIMathMatrix_Test, isIdentityFalse) { TEST(PIMathMatrix_Test, isIdentityFalse) {
PIMathMatrix<double> matrix(3, 3, 5.0); PIMathMatrix<double> matrix(3, 3, 5.0);
ASSERT_FALSE(matrix.isIdentity()); ASSERT_FALSE(matrix.isIdentity());
} }
TEST(PIMathMatrix_Test, isNullTrue) { TEST(PIMathMatrix_Test, isNullTrue) {
PIMathMatrix<double> matrix(3, 3, 0.0); PIMathMatrix<double> matrix(3, 3, 0.0);
ASSERT_TRUE(matrix.isNull()); ASSERT_TRUE(matrix.isNull());
} }
TEST(PIMathMatrix_Test, isNullFalse) { TEST(PIMathMatrix_Test, isNullFalse) {
PIMathMatrix<double> matrix(3, 3, 5.0); PIMathMatrix<double> matrix(3, 3, 5.0);
ASSERT_FALSE(matrix.isNull()); ASSERT_FALSE(matrix.isNull());
} }
TEST(PIMathMatrix_Test, isValidTrue) { TEST(PIMathMatrix_Test, isValidTrue) {
PIMathMatrix<double> matrix(3, 3, 1.62); PIMathMatrix<double> matrix(3, 3, 1.62);
ASSERT_TRUE(matrix.isValid()); ASSERT_TRUE(matrix.isValid());
} }
TEST(PIMathMatrix_Test, isValidFalse) { TEST(PIMathMatrix_Test, isValidFalse) {
PIMathMatrix<double> matrix; PIMathMatrix<double> matrix;
ASSERT_FALSE(matrix.isValid()); ASSERT_FALSE(matrix.isValid());
} }
TEST(PIMathMatrix_Test, operator_Assignment) { TEST(PIMathMatrix_Test, operator_Assignment) {
PIMathMatrix<double> matrix1(3, 3, 5.72); PIMathMatrix<double> matrix1(3, 3, 5.72);
PIMathMatrix<double> matrix2(3, 3, 7.12); PIMathMatrix<double> matrix2(3, 3, 7.12);
matrix1 = matrix2; matrix1 = matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.12, 3)); 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> matrix1(2, 2, 2.0);
PIMathMatrix<double> matrix2(2, 2, 2.0); PIMathMatrix<double> matrix2(2, 2, 2.0);
matrix1.element(0, 0) = 5.1; matrix1.element(0, 0) = 5.1;
matrix1.element(0, 1) = 1.21; matrix1.element(0, 1) = 1.21;
matrix1.element(1, 1) = 0.671; matrix1.element(1, 1) = 0.671;
matrix1.element(1, 0) = 2.623; matrix1.element(1, 0) = 2.623;
matrix2.element(0, 0) = 5.1; matrix2.element(0, 0) = 5.1;
matrix2.element(0, 1) = 1.21; matrix2.element(0, 1) = 1.21;
matrix2.element(1, 1) = 0.671; matrix2.element(1, 1) = 0.671;
matrix2.element(1, 0) = 2.623; matrix2.element(1, 0) = 2.623;
ASSERT_TRUE(matrix1 == matrix2); ASSERT_TRUE(matrix1 == matrix2);
} }
TEST(PIMathMatrix_Test, operator_EqualFalse) { TEST(PIMathMatrix_Test, operator_EqualFalse) {
PIMathMatrix<double> matrix1(2, 2, 2.0); PIMathMatrix<double> matrix1(2, 2, 2.0);
PIMathMatrix<double> matrix2(2, 2, 2.0); PIMathMatrix<double> matrix2(2, 2, 2.0);
matrix1.element(0, 0) = 5.1; matrix1.element(0, 0) = 5.1;
matrix1.element(0, 1) = 1.21; matrix1.element(0, 1) = 1.21;
matrix1.element(1, 1) = 0.671; matrix1.element(1, 1) = 0.671;
matrix1.element(1, 0) = 2.623; matrix1.element(1, 0) = 2.623;
matrix2.element(0, 0) = 5.1; matrix2.element(0, 0) = 5.1;
matrix2.element(0, 1) = 1.21; matrix2.element(0, 1) = 1.21;
matrix2.element(1, 1) = 665.671; matrix2.element(1, 1) = 665.671;
matrix2.element(1, 0) = 2.623; matrix2.element(1, 0) = 2.623;
ASSERT_FALSE(matrix1 == matrix2); 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> matrix1(2, 2, 2.0);
PIMathMatrix<double> matrix2(2, 2, 2.0); PIMathMatrix<double> matrix2(2, 2, 2.0);
matrix1.element(0, 0) = 5.1; matrix1.element(0, 0) = 5.1;
matrix1.element(0, 1) = 1.21; matrix1.element(0, 1) = 1.21;
matrix1.element(1, 1) = 0.671; matrix1.element(1, 1) = 0.671;
matrix1.element(1, 0) = 2.623; matrix1.element(1, 0) = 2.623;
matrix2.element(0, 0) = 5.1; matrix2.element(0, 0) = 5.1;
matrix2.element(0, 1) = 1.21; matrix2.element(0, 1) = 1.21;
matrix2.element(1, 1) = 665.671; matrix2.element(1, 1) = 665.671;
matrix2.element(1, 0) = 2.623; matrix2.element(1, 0) = 2.623;
ASSERT_TRUE(matrix1 != matrix2); 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> matrix1(2, 2, 2.0);
PIMathMatrix<double> matrix2(2, 2, 2.0); PIMathMatrix<double> matrix2(2, 2, 2.0);
matrix1.element(0, 0) = 5.1; matrix1.element(0, 0) = 5.1;
matrix1.element(0, 1) = 1.21; matrix1.element(0, 1) = 1.21;
matrix1.element(1, 1) = 0.671; matrix1.element(1, 1) = 0.671;
matrix1.element(1, 0) = 2.623; matrix1.element(1, 0) = 2.623;
matrix2.element(0, 0) = 5.1; matrix2.element(0, 0) = 5.1;
matrix2.element(0, 1) = 1.21; matrix2.element(0, 1) = 1.21;
matrix2.element(1, 1) = 0.671; matrix2.element(1, 1) = 0.671;
matrix2.element(1, 0) = 2.623; matrix2.element(1, 0) = 2.623;
ASSERT_FALSE(matrix1 != matrix2); 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> matrix1(3, 3, 6.72);
PIMathMatrix<double> matrix2(3, 3, 1.0); PIMathMatrix<double> matrix2(3, 3, 1.0);
matrix1 += matrix2; matrix1 += matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.72, 3)); 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> matrix1(3, 3, 1.0);
PIMathMatrix<double> matrix2(3, 3, 6.72); PIMathMatrix<double> matrix2(3, 3, 6.72);
matrix1 -= matrix2; matrix1 -= matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, -5.72, 3)); 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); PIMathMatrix<double> matrix1(3, 3, 6.72);
matrix1 *= 2.0; matrix1 *= 2.0;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 13.44, 3)); 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); PIMathMatrix<double> matrix1(3, 3, 6.72);
matrix1 /= 2.0; matrix1 /= 2.0;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 3.36, 3)); 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> matrix1(3, 3, 6.72);
PIMathMatrix<double> matrix2(3, 3, 8.28); PIMathMatrix<double> matrix2(3, 3, 8.28);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 + matrix2, 15.0, 3)); 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> matrix1(3, 3, 6.0);
PIMathMatrix<double> matrix2(3, 3, 5.0); PIMathMatrix<double> matrix2(3, 3, 5.0);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 - matrix2, 1.0, 3)); 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> matrix1(3, 3, 6.72);
PIMathMatrix<double> matrix2(3, 3, 5.0); PIMathMatrix<double> matrix2(3, 3, 5.0);
matrix2 = matrix1*4.0; matrix2 = matrix1*4.0;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix2, 26.88, 3)); 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> matrix1(3, 3, 6.72);
PIMathMatrix<double> matrix2(3, 3, 5.0); PIMathMatrix<double> matrix2(3, 3, 5.0);
matrix2 = matrix1/4.0; matrix2 = matrix1/4.0;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix2, 1.68, 3)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix2, 1.68, 3));
} }
TEST(PIMathMatrix_Test, determinantIfSquare) { TEST(PIMathMatrix_Test, determinantIfSquare) {
double d; double d;
double i = 59.0; double i = 59.0;
PIMathMatrix<double> matrix(3, 3, 0.0); PIMathMatrix<double> matrix(3, 3, 0.0);
PIMathVector<double> vector; PIMathVector<double> vector;
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;
matrix.setCol(0, vector); matrix.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;
matrix.setCol(1, vector); matrix.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;
matrix.setCol(2, vector); matrix.setCol(2, vector);
d = matrix.determinant(); d = matrix.determinant();
ASSERT_DOUBLE_EQ(d, i); ASSERT_DOUBLE_EQ(d, i);
} }
TEST(PIMathMatrix_Test, determinantIfNotSquare) { TEST(PIMathMatrix_Test, determinantIfNotSquare) {
PIMathMatrix<double> matrix(3, 5, 1.0); PIMathMatrix<double> matrix(3, 5, 1.0);
matrix.element(1,1) = 5.0; matrix.element(1,1) = 5.0;
ASSERT_FALSE(matrix.determinant()); ASSERT_FALSE(matrix.determinant());
} }
TEST(PIMathMatrix_Test, trace) { TEST(PIMathMatrix_Test, trace) {
PIMathMatrix<double> matrix(3, 3, 0.0); PIMathMatrix<double> matrix(3, 3, 0.0);
double t; double t;
double i = 9.0; double i = 9.0;
PIMathVector<double> vector; PIMathVector<double> vector;
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;
matrix.setCol(0, vector); matrix.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;
matrix.setCol(1, vector); matrix.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;
matrix.setCol(2, vector); matrix.setCol(2, vector);
t = matrix.trace(); t = matrix.trace();
ASSERT_DOUBLE_EQ(t, i); ASSERT_DOUBLE_EQ(t, i);
} }
TEST(PIMathMatrix_Test, traceIfNotSquare) { TEST(PIMathMatrix_Test, traceIfNotSquare) {
PIMathMatrix<double> matrix(3, 5, 1.0); PIMathMatrix<double> matrix(3, 5, 1.0);
matrix.element(1,1) = 5.0; matrix.element(1,1) = 5.0;
ASSERT_FALSE(matrix.trace()); ASSERT_FALSE(matrix.trace());
} }
TEST(PIMathMatrix_Test, toUpperTriangular) { TEST(PIMathMatrix_Test, toUpperTriangular) {
PIMathMatrix<double> matrix(3, 3, 0.0); PIMathMatrix<double> matrix(3, 3, 0.0);
double d1, d2 = 1; double d1, d2 = 1;
int i; int i;
PIMathVector<double> vector; PIMathVector<double> vector;
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;
matrix.setCol(0, vector); matrix.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;
matrix.setCol(1, vector); matrix.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;
matrix.setCol(2, vector); matrix.setCol(2, vector);
d1 = matrix.determinant(); d1 = matrix.determinant();
matrix.toUpperTriangular(); matrix.toUpperTriangular();
for(i = 0; i < 3; i++) for(i = 0; i < 3; i++)
{ {
d2 = d2 * matrix.element(i, i); d2 = d2 * matrix.element(i, i);
} }
ASSERT_DOUBLE_EQ(d1, d2); ASSERT_DOUBLE_EQ(d1, d2);
} }
TEST(PIMathMatrix_Test, invert) { TEST(PIMathMatrix_Test, invert) {
double d1, d2; double d1, d2;
PIMathMatrix<double> matrix1(3, 3, 0.0); PIMathMatrix<double> matrix1(3, 3, 0.0);
PIMathMatrix<double> matrix2(3, 3, 0.0); PIMathMatrix<double> matrix2(3, 3, 0.0);
PIMathMatrix<double> matrix3(3, 3, 0.0); PIMathMatrix<double> matrix3(3, 3, 0.0);
PIMathMatrix<double> matrix4(3, 3, 0.0); PIMathMatrix<double> matrix4(3, 3, 0.0);
PIMathVector<double> vector; PIMathVector<double> vector;
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.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);
d1 = matrix1.determinant(); d1 = matrix1.determinant();
matrix2 = matrix1; matrix2 = matrix1;
matrix2.invert(); matrix2.invert();
d2 = matrix2.determinant(); d2 = matrix2.determinant();
matrix4.invert(); matrix4.invert();
ASSERT_TRUE((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000)); ASSERT_TRUE((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000));
} }
TEST(PIMathMatrix_Test, inverted) { TEST(PIMathMatrix_Test, inverted) {
double d1, d2; double d1, d2;
PIMathMatrix<double> matrix1(3, 3, 0.0); PIMathMatrix<double> matrix1(3, 3, 0.0);
PIMathMatrix<double> matrix2(3, 3, 0.0); PIMathMatrix<double> matrix2(3, 3, 0.0);
PIMathMatrix<double> matrix3(3, 3, 0.0); PIMathMatrix<double> matrix3(3, 3, 0.0);
PIMathMatrix<double> matrix4(3, 3, 0.0); PIMathMatrix<double> matrix4(3, 3, 0.0);
PIMathVector<double> vector; PIMathVector<double> vector;
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.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);
d1 = matrix1.determinant(); d1 = matrix1.determinant();
matrix2 = matrix1; matrix2 = matrix1;
matrix1 = matrix2.invert(); matrix1 = matrix2.invert();
d2 = matrix1.determinant(); d2 = matrix1.determinant();
matrix3 = matrix4.invert(); matrix3 = matrix4.invert();
ASSERT_TRUE((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000)); ASSERT_TRUE((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000));
} }
TEST(PIMathMatrix_Test, transposed) { TEST(PIMathMatrix_Test, transposed) {
PIMathMatrix<double> origMatr; PIMathMatrix<double> origMatr;
double d1, d2; double d1, d2;
PIMathMatrix<double> matrix1; PIMathMatrix<double> matrix1;
PIMathMatrix<double> matrix2; PIMathMatrix<double> matrix2;
PIMathMatrix<double> matrix3; PIMathMatrix<double> matrix3;
PIMathVector<double> vector; PIMathVector<double> vector;
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.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);
d1 = matrix1.determinant(); d1 = matrix1.determinant();
matrix2 = matrix1.transposed(); matrix2 = matrix1.transposed();
d2 = matrix2.determinant(); d2 = matrix2.determinant();
matrix3 = matrix2.transposed(); matrix3 = matrix2.transposed();
ASSERT_TRUE((d1 == d2) && (matrix1 == matrix3)); ASSERT_TRUE((d1 == d2) && (matrix1 == matrix3));
} }
TEST(PIMathMatrix_Test, matrixMultiplication) { TEST(PIMathMatrix_Test, matrixMultiplication) {
PIMathMatrix<double> matrix1(2, 2, 1.5); PIMathMatrix<double> matrix1(2, 2, 1.5);
PIMathMatrix<double> matrix2(2, 2, 2.5); PIMathMatrix<double> matrix2(2, 2, 2.5);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 7.5, 2)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 7.5, 2));
} }
TEST(PIMathMatrix_Test, matrixAndVectorMultiplication) { TEST(PIMathMatrix_Test, matrixAndVectorMultiplication) {
PIMathMatrix<double> matrix1(2, 2, 1.5); PIMathMatrix<double> matrix1(2, 2, 1.5);
PIMathVector<double> vector; PIMathVector<double> vector;
vector.resize(2, 2.5); vector.resize(2, 2.5);
for(uint i = 0; i < 2; i++) { for(uint i = 0; i < 2; i++) {
if((matrix1 * vector)[i] != 7.5) { if((matrix1 * vector)[i] != 7.5) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrix_Test, vectorAndMatrixMultiplication) { TEST(PIMathMatrix_Test, vectorAndMatrixMultiplication) {
PIMathMatrix<double> matrix1(2, 2, 1.5); PIMathMatrix<double> matrix1(2, 2, 1.5);
PIMathVector<double> vector; PIMathVector<double> vector;
vector.resize(2, 2.5); vector.resize(2, 2.5);
for(uint i = 0; i < 2; i++) { for(uint i = 0; i < 2; i++) {
if((vector * matrix1)[i] != 7.5) { if((vector * matrix1)[i] != 7.5) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrix_Test, valAndMatrixMultiplication) { TEST(PIMathMatrix_Test, valAndMatrixMultiplication) {
PIMathMatrix<double> matrix1(3, 3, 1.5); PIMathMatrix<double> matrix1(3, 3, 1.5);
ASSERT_TRUE(cmpSquareMatrixWithValue(25.0*matrix1, 37.5, 3)); ASSERT_TRUE(cmpSquareMatrixWithValue(25.0*matrix1, 37.5, 3));
} }
TEST(PIMathMatrix_Test, hermitian) { TEST(PIMathMatrix_Test, hermitian) {
complex<double> val; complex<double> val;
complex<double> res; complex<double> res;
val.imag(1.0); val.imag(1.0);
val.real(1.0); val.real(1.0);
PIMathMatrix<complex<double>> matrix(3, 3, val); PIMathMatrix<complex<double>> matrix(3, 3, val);
res.imag(-1.0); res.imag(-1.0);
res.real(1.0); res.real(1.0);
auto matr = hermitian(matrix); auto matr = hermitian(matrix);
for(uint i = 0; i < 3; i++) { for(uint i = 0; i < 3; i++) {
for(uint j = 0; j < 3; j++) { for(uint j = 0; j < 3; j++) {
if(matr.element(i, j) != res) { if(matr.element(i, j) != res) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }

804
tests/math/testpimathmatrixt.cpp
View File

@@ -5,558 +5,558 @@ const uint rows = 3;
const uint cols = 3; const uint cols = 3;
bool cmpSquareMatrixWithValue(PIMathMatrixT<rows, cols, double> matrix, double val, int num) { bool cmpSquareMatrixWithValue(PIMathMatrixT<rows, cols, double> matrix, double 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++) {
if(matrix[i][j] - val >= double(1E-200)) { if(matrix[i][j] - val >= double(1E-200)) {
b = false; b = false;
} }
} }
} }
return b; return b;
} }
TEST(PIMathMatrixT_Test, identity) { TEST(PIMathMatrixT_Test, identity) {
auto matrix = PIMathMatrixT<rows, cols, double>::identity(); auto matrix = PIMathMatrixT<rows, cols, double>::identity();
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++){
if(i != j){ if(i != j){
if(matrix[i][j] != 0.0){ if(matrix[i][j] != 0.0){
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
else { else {
if(matrix[i][i] != 1.0){ if(matrix[i][i] != 1.0){
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrixT_Test, at) { TEST(PIMathMatrixT_Test, at) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::identity(); auto matrix1 = PIMathMatrixT<rows, cols, double>::identity();
for(uint i = 0; i < rows; i++) { for(uint i = 0; i < rows; i++) {
if(matrix1.at(i,i) != 1.0) { if(matrix1.at(i,i) != 1.0) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrixT_Test, filled) { TEST(PIMathMatrixT_Test, filled) {
auto matr = PIMathMatrixT<rows, cols, double>::filled(1.0); auto matr = PIMathMatrixT<rows, cols, double>::filled(1.0);
ASSERT_TRUE(cmpSquareMatrixWithValue(matr, 1.0, rows)); ASSERT_TRUE(cmpSquareMatrixWithValue(matr, 1.0, rows));
} }
TEST(PIMathMatrixT_Test, cols) { TEST(PIMathMatrixT_Test, cols) {
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
ASSERT_EQ(cols,matr.cols()); ASSERT_EQ(cols,matr.cols());
} }
TEST(PIMathMatrixT_Test, rows) { TEST(PIMathMatrixT_Test, rows) {
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
ASSERT_EQ(rows,matr.rows()); ASSERT_EQ(rows,matr.rows());
} }
TEST(PIMathMatrixT_Test, col) { TEST(PIMathMatrixT_Test, col) {
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
PIMathVectorT<rows, double> vect; PIMathVectorT<rows, double> vect;
uint g = 2; uint g = 2;
matr[0][0] = 3; matr[0][0] = 3;
matr[0][1] = 6; matr[0][1] = 6;
matr[0][2] = 8; matr[0][2] = 8;
matr[1][0] = 2; matr[1][0] = 2;
matr[1][1] = 1; matr[1][1] = 1;
matr[1][2] = 4; matr[1][2] = 4;
matr[2][0] = 6; matr[2][0] = 6;
matr[2][1] = 2; matr[2][1] = 2;
matr[2][2] = 5; matr[2][2] = 5;
vect = matr.col(g); vect = matr.col(g);
for(uint i = 0; i < matr.cols(); i++) { for(uint i = 0; i < matr.cols(); i++) {
if(matr.at(i, g) != vect.at(i)) { if(matr.at(i, g) != vect.at(i)) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrixT_Test, row) { TEST(PIMathMatrixT_Test, row) {
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
PIMathVectorT<rows, double> vect; PIMathVectorT<rows, double> vect;
uint g = 2; uint g = 2;
matr[0][0] = 3; matr[0][0] = 3;
matr[0][1] = 6; matr[0][1] = 6;
matr[0][2] = 8; matr[0][2] = 8;
matr[1][0] = 2; matr[1][0] = 2;
matr[1][1] = 1; matr[1][1] = 1;
matr[1][2] = 4; matr[1][2] = 4;
matr[2][0] = 6; matr[2][0] = 6;
matr[2][1] = 2; matr[2][1] = 2;
matr[2][2] = 5; matr[2][2] = 5;
vect = matr.row(g); vect = matr.row(g);
for(uint i = 0; i < matr.rows(); i++) { for(uint i = 0; i < matr.rows(); i++) {
if(matr.at(g, i) != vect.at(i)) { if(matr.at(g, i) != vect.at(i)) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrixT_Test, setCol) { TEST(PIMathMatrixT_Test, setCol) {
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
PIMathVectorT<rows, double> vect; PIMathVectorT<rows, double> vect;
vect[0] = 1.0; vect[0] = 1.0;
vect[1] = 3.0; vect[1] = 3.0;
vect[2] = 5.0; vect[2] = 5.0;
uint g = 1; uint g = 1;
matr.setCol(g, vect); matr.setCol(g, vect);
for(uint i = 0; i < vect.size(); i++) { for(uint i = 0; i < vect.size(); i++) {
if(matr.at(i, g) != vect.at(i)) { if(matr.at(i, g) != vect.at(i)) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrixT_Test, setRow) { TEST(PIMathMatrixT_Test, setRow) {
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
PIMathVectorT<rows, double> vect; PIMathVectorT<rows, double> vect;
vect[0] = 1.0; vect[0] = 1.0;
vect[1] = 3.0; vect[1] = 3.0;
vect[2] = 5.0; vect[2] = 5.0;
uint g = 1; uint g = 1;
matr.setRow(g, vect); matr.setRow(g, vect);
for(uint i = 0; i < vect.size(); i++) { for(uint i = 0; i < vect.size(); i++) {
if(matr.at(g,i) != vect.at(i)) { if(matr.at(g,i) != vect.at(i)) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrixT_Test, swapCols) { TEST(PIMathMatrixT_Test, swapCols) {
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
int g1 = 1, g2 = 2; int g1 = 1, g2 = 2;
matr[0][0] = 3; matr[0][0] = 3;
matr[0][1] = 6; matr[0][1] = 6;
matr[0][2] = 8; matr[0][2] = 8;
matr[1][0] = 2; matr[1][0] = 2;
matr[1][1] = 1; matr[1][1] = 1;
matr[1][2] = 4; matr[1][2] = 4;
matr[2][0] = 6; matr[2][0] = 6;
matr[2][1] = 2; matr[2][1] = 2;
matr[2][2] = 5; matr[2][2] = 5;
const PIMathVectorT<rows, double> before_Vect1 = matr.col(g1); const PIMathVectorT<rows, double> before_Vect1 = matr.col(g1);
const PIMathVectorT<rows, double> before_Vect2 = matr.col(g2); const PIMathVectorT<rows, double> before_Vect2 = matr.col(g2);
matr.swapCols(g1, g2); matr.swapCols(g1, g2);
const PIMathVectorT<rows, double> after_Vect1 = matr.col(g1); const PIMathVectorT<rows, double> after_Vect1 = matr.col(g1);
const PIMathVectorT<rows, double> after_Vect2 = matr.col(g2); const PIMathVectorT<rows, double> after_Vect2 = matr.col(g2);
if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1)) { if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1)) {
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
else { else {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
TEST(PIMathMatrixT_Test, swapRows) { TEST(PIMathMatrixT_Test, swapRows) {
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
int g1 = 1, g2 = 2; int g1 = 1, g2 = 2;
matr[0][0] = 3; matr[0][0] = 3;
matr[0][1] = 6; matr[0][1] = 6;
matr[0][2] = 8; matr[0][2] = 8;
matr[1][0] = 2; matr[1][0] = 2;
matr[1][1] = 1; matr[1][1] = 1;
matr[1][2] = 4; matr[1][2] = 4;
matr[2][0] = 6; matr[2][0] = 6;
matr[2][1] = 2; matr[2][1] = 2;
matr[2][2] = 5; matr[2][2] = 5;
const PIMathVectorT<rows, double> before_Vect1 = matr.row(g1); const PIMathVectorT<rows, double> before_Vect1 = matr.row(g1);
const PIMathVectorT<rows, double> before_Vect2 = matr.row(g2); const PIMathVectorT<rows, double> before_Vect2 = matr.row(g2);
matr.swapRows(g1, g2); matr.swapRows(g1, g2);
const PIMathVectorT<rows, double> after_Vect1 = matr.row(g1); const PIMathVectorT<rows, double> after_Vect1 = matr.row(g1);
const PIMathVectorT<rows, double> after_Vect2 = matr.row(g2); const PIMathVectorT<rows, double> after_Vect2 = matr.row(g2);
if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1)) { if((before_Vect1 == after_Vect2) && (before_Vect2 == after_Vect1)) {
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
else { else {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
TEST(PIMathMatrixT_Test, fill) { TEST(PIMathMatrixT_Test, fill) {
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
PIMathMatrixT<rows, cols, double> matrix1; PIMathMatrixT<rows, cols, double> matrix1;
double g = 1.0; double g = 1.0;
matr.fill(g); matr.fill(g);
for(uint i = 0; i < cols; i++) { for(uint i = 0; i < cols; i++) {
for(uint j = 0; j < rows; j++) { for(uint j = 0; j < rows; j++) {
matrix1[j][i] = g; matrix1[j][i] = g;
} }
} }
ASSERT_TRUE(matr == matrix1); ASSERT_TRUE(matr == matrix1);
} }
TEST(PIMathMatrixT_Test, isSquareTrue) { TEST(PIMathMatrixT_Test, isSquareTrue) {
PIMathMatrixT<rows, cols, double> matrix1; PIMathMatrixT<rows, cols, double> matrix1;
ASSERT_TRUE(matrix1.isSquare()); ASSERT_TRUE(matrix1.isSquare());
} }
TEST(PIMathMatrixT_Test, isSquareFalse) { TEST(PIMathMatrixT_Test, isSquareFalse) {
const uint new_Cols = 4; const uint new_Cols = 4;
PIMathMatrixT<rows, new_Cols, double> matrix2; PIMathMatrixT<rows, new_Cols, double> matrix2;
ASSERT_FALSE(matrix2.isSquare()); ASSERT_FALSE(matrix2.isSquare());
} }
TEST(PIMathMatrixT_Test, isIdentityTrue) { TEST(PIMathMatrixT_Test, isIdentityTrue) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::identity(); auto matrix1 = PIMathMatrixT<rows, cols, double>::identity();
ASSERT_TRUE(matrix1.isIdentity()); ASSERT_TRUE(matrix1.isIdentity());
} }
TEST(PIMathMatrixT_Test, isIdentityFalse) { TEST(PIMathMatrixT_Test, isIdentityFalse) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(2.5); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(2.5);
ASSERT_FALSE(matrix1.isIdentity()); ASSERT_FALSE(matrix1.isIdentity());
} }
TEST(PIMathMatrixT_Test, isNullTrue) { TEST(PIMathMatrixT_Test, isNullTrue) {
PIMathMatrixT<rows, cols, double> matrix1; PIMathMatrixT<rows, cols, double> matrix1;
ASSERT_TRUE(matrix1.isNull()); ASSERT_TRUE(matrix1.isNull());
} }
TEST(PIMathMatrixT_Test, isNullFalse) { TEST(PIMathMatrixT_Test, isNullFalse) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::identity(); auto matrix1 = PIMathMatrixT<rows, cols, double>::identity();
ASSERT_FALSE(matrix1.isNull()); ASSERT_FALSE(matrix1.isNull());
} }
TEST(PIMathMatrixT_Test, operator_Assignment) { TEST(PIMathMatrixT_Test, operator_Assignment) {
PIMathMatrixT<rows, cols, double> matrix1; PIMathMatrixT<rows, cols, double> matrix1;
auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(6.72); auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(6.72);
matrix1 = matrix2; matrix1 = matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 6.72, rows)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 6.72, rows));
} }
TEST(PIMathMatrixT_Test, operator_EqualTrue) { TEST(PIMathMatrixT_Test, operator_EqualTrue) {
PIMathMatrixT<rows, cols, double> matrix1; PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2; PIMathMatrixT<rows, cols, double> matrix2;
matrix1[0][0] = 5.1; matrix1[0][0] = 5.1;
matrix1[0][1] = 1.21; matrix1[0][1] = 1.21;
matrix1[1][1] = 0.671; matrix1[1][1] = 0.671;
matrix1[1][0] = 2.623; matrix1[1][0] = 2.623;
matrix2[0][0] = 5.1; matrix2[0][0] = 5.1;
matrix2[0][1] = 1.21; matrix2[0][1] = 1.21;
matrix2[1][1] = 0.671; matrix2[1][1] = 0.671;
matrix2[1][0] = 2.623; matrix2[1][0] = 2.623;
ASSERT_TRUE(matrix1 == matrix2); ASSERT_TRUE(matrix1 == matrix2);
} }
TEST(PIMathMatrixT_Test, operator_EqualFalse) { TEST(PIMathMatrixT_Test, operator_EqualFalse) {
PIMathMatrixT<rows, cols, double> matrix1; PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2; PIMathMatrixT<rows, cols, double> matrix2;
matrix1[0][0] = 5.1; matrix1[0][0] = 5.1;
matrix1[0][1] = 1.21; matrix1[0][1] = 1.21;
matrix1[1][1] = 0.671; matrix1[1][1] = 0.671;
matrix1[1][0] = 2.623; matrix1[1][0] = 2.623;
matrix2[0][0] = 5.1; matrix2[0][0] = 5.1;
matrix2[0][1] = 1.21; matrix2[0][1] = 1.21;
matrix2[1][1] = 665.671; matrix2[1][1] = 665.671;
matrix2[1][0] = 2.623; matrix2[1][0] = 2.623;
ASSERT_FALSE(matrix1 == matrix2); ASSERT_FALSE(matrix1 == matrix2);
} }
TEST(PIMathMatrixT_Test, operator_Not_EqualTrue) { TEST(PIMathMatrixT_Test, operator_Not_EqualTrue) {
PIMathMatrixT<rows, cols, double> matrix1; PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2; PIMathMatrixT<rows, cols, double> matrix2;
matrix1[0][0] = 5.1; matrix1[0][0] = 5.1;
matrix1[0][1] = 1.21; matrix1[0][1] = 1.21;
matrix1[1][1] = 0.671; matrix1[1][1] = 0.671;
matrix1[1][0] = 2.623; matrix1[1][0] = 2.623;
matrix2[0][0] = 5.1; matrix2[0][0] = 5.1;
matrix2[0][1] = 1.21; matrix2[0][1] = 1.21;
matrix2[1][1] = 665.671; matrix2[1][1] = 665.671;
matrix2[1][0] = 2.623; matrix2[1][0] = 2.623;
ASSERT_TRUE(matrix1 != matrix2); ASSERT_TRUE(matrix1 != matrix2);
} }
TEST(PIMathMatrixT_Test, operator_Not_EqualFalse) { TEST(PIMathMatrixT_Test, operator_Not_EqualFalse) {
PIMathMatrixT<rows, cols, double> matrix1; PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2; PIMathMatrixT<rows, cols, double> matrix2;
matrix1[0][0] = 5.1; matrix1[0][0] = 5.1;
matrix1[0][1] = 1.21; matrix1[0][1] = 1.21;
matrix1[1][1] = 0.671; matrix1[1][1] = 0.671;
matrix1[1][0] = 2.623; matrix1[1][0] = 2.623;
matrix2[0][0] = 5.1; matrix2[0][0] = 5.1;
matrix2[0][1] = 1.21; matrix2[0][1] = 1.21;
matrix2[1][1] = 0.671; matrix2[1][1] = 0.671;
matrix2[1][0] = 2.623; matrix2[1][0] = 2.623;
ASSERT_FALSE(matrix1 != matrix2); ASSERT_FALSE(matrix1 != matrix2);
} }
TEST(PIMathMatrixT_Test, operator_Addition_Assignment) { TEST(PIMathMatrixT_Test, operator_Addition_Assignment) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72) ; auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72) ;
auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(1.0) ; auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(1.0) ;
matrix1 += matrix2; matrix1 += matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.72, rows)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 7.72, rows));
} }
TEST(PIMathMatrixT_Test, operator_Subtraction_Assignment) { TEST(PIMathMatrixT_Test, operator_Subtraction_Assignment) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(1.0); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(1.0);
auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(6.72); auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(6.72);
matrix1 -= matrix2; matrix1 -= matrix2;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, -5.72, rows)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, -5.72, rows));
} }
TEST(PIMathMatrixT_Test, operator_Multiplication_Assignment) { TEST(PIMathMatrixT_Test, operator_Multiplication_Assignment) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72);
matrix1 *= 2.0; matrix1 *= 2.0;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 13.44, rows)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 13.44, rows));
} }
TEST(PIMathMatrixT_Test, operator_Division_Assignment) { TEST(PIMathMatrixT_Test, operator_Division_Assignment) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72);
matrix1 /= 2.0; matrix1 /= 2.0;
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 3.36, rows)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1, 3.36, rows));
} }
TEST(PIMathMatrixT_Test, operator_Addition) { TEST(PIMathMatrixT_Test, operator_Addition) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72);
auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(8.28); auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(8.28);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 + matrix2, 15.0, rows)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 + matrix2, 15.0, rows));
} }
TEST(PIMathMatrixT_Test, operator_Subtraction) { TEST(PIMathMatrixT_Test, operator_Subtraction) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.0); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.0);
auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(5.0); auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(5.0);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 - matrix2, 1.0, rows)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 - matrix2, 1.0, rows));
} }
TEST(PIMathMatrixT_Test, operator_Multiplication) { TEST(PIMathMatrixT_Test, operator_Multiplication) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * 4.0, 26.88, rows)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * 4.0, 26.88, rows));
} }
TEST(PIMathMatrixT_Test, operator_Division) { TEST(PIMathMatrixT_Test, operator_Division) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(6.72);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 / 4.0, 1.68, rows)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 / 4.0, 1.68, rows));
} }
TEST(PIMathMatrixT_Test, determinantIfSquare) { TEST(PIMathMatrixT_Test, determinantIfSquare) {
double d; double d;
double i = 59.0; double i = 59.0;
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
matr[0][0] = 3; matr[0][0] = 3;
matr[0][1] = 6; matr[0][1] = 6;
matr[0][2] = 8; matr[0][2] = 8;
matr[1][0] = 2; matr[1][0] = 2;
matr[1][1] = 1; matr[1][1] = 1;
matr[1][2] = 4; matr[1][2] = 4;
matr[2][0] = 6; matr[2][0] = 6;
matr[2][1] = 2; matr[2][1] = 2;
matr[2][2] = 5; matr[2][2] = 5;
d = matr.determinant(); d = matr.determinant();
ASSERT_DOUBLE_EQ(i, d); ASSERT_DOUBLE_EQ(i, d);
} }
TEST(PIMathMatrixT_Test, determinantIfNotSquare) { TEST(PIMathMatrixT_Test, determinantIfNotSquare) {
PIMathMatrixT<rows, 5u, double> matr; PIMathMatrixT<rows, 5u, double> matr;
matr[0][0] = 3; matr[0][0] = 3;
matr[0][1] = 6; matr[0][1] = 6;
matr[0][2] = 8; matr[0][2] = 8;
matr[1][0] = 2; matr[1][0] = 2;
matr[1][1] = 1; matr[1][1] = 1;
matr[1][2] = 4; matr[1][2] = 4;
matr[2][0] = 6; matr[2][0] = 6;
matr[2][1] = 2; matr[2][1] = 2;
matr[2][2] = 5; matr[2][2] = 5;
ASSERT_FALSE(matr.determinant()); ASSERT_FALSE(matr.determinant());
} }
TEST(PIMathMatrixT_Test, invert) { TEST(PIMathMatrixT_Test, invert) {
PIMathMatrixT<rows, cols, double> matrix1; PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2; PIMathMatrixT<rows, cols, double> matrix2;
PIMathMatrixT<rows, cols, double> matrix3; PIMathMatrixT<rows, cols, double> matrix3;
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
double d1, d2; double d1, d2;
matr[0][0] = 3; matr[0][0] = 3;
matr[0][1] = 6; matr[0][1] = 6;
matr[0][2] = 8; matr[0][2] = 8;
matr[1][0] = 2; matr[1][0] = 2;
matr[1][1] = 1; matr[1][1] = 1;
matr[1][2] = 4; matr[1][2] = 4;
matr[2][0] = 6; matr[2][0] = 6;
matr[2][1] = 2; matr[2][1] = 2;
matr[2][2] = 5; matr[2][2] = 5;
matrix2 = matr; matrix2 = matr;
matr.invert(); matr.invert();
d1 = matr.determinant(); d1 = matr.determinant();
d2 = matrix2.determinant(); d2 = matrix2.determinant();
matrix3 = matrix1; matrix3 = matrix1;
matrix1.invert(); matrix1.invert();
ASSERT_TRUE((matrix1 == matrix3) && (d1 == 1/d2)); ASSERT_TRUE((matrix1 == matrix3) && (d1 == 1/d2));
} }
TEST(PIMathMatrixT_Test, inverted) { TEST(PIMathMatrixT_Test, inverted) {
PIMathMatrixT<rows, cols, double> matrix1; PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2; PIMathMatrixT<rows, cols, double> matrix2;
PIMathMatrixT<rows, cols, double> matrix3; PIMathMatrixT<rows, cols, double> matrix3;
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
double d1, d2; double d1, d2;
matrix1 = matr.identity(); matrix1 = matr.identity();
matr[0][0] = 3; matr[0][0] = 3;
matr[0][1] = 6; matr[0][1] = 6;
matr[0][2] = 8; matr[0][2] = 8;
matr[1][0] = 2; matr[1][0] = 2;
matr[1][1] = 1; matr[1][1] = 1;
matr[1][2] = 4; matr[1][2] = 4;
matr[2][0] = 6; matr[2][0] = 6;
matr[2][1] = 2; matr[2][1] = 2;
matr[2][2] = 5; matr[2][2] = 5;
matrix2 = matr.inverted(); matrix2 = matr.inverted();
d1 = matr.determinant(); d1 = matr.determinant();
d2 = matrix2.determinant(); d2 = matrix2.determinant();
matrix3 = matrix1.inverted(); matrix3 = matrix1.inverted();
ASSERT_TRUE((matrix1 == matrix3) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000)); ASSERT_TRUE((matrix1 == matrix3) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000));
} }
TEST(PIMathMatrixT_Test, toUpperTriangular) { TEST(PIMathMatrixT_Test, toUpperTriangular) {
PIMathMatrixT<rows, cols, double> matrix; PIMathMatrixT<rows, cols, double> matrix;
double d1, d2 = 1; double d1, d2 = 1;
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
matr[0][0] = 3; matr[0][0] = 3;
matr[0][1] = 6; matr[0][1] = 6;
matr[0][2] = 8; matr[0][2] = 8;
matr[1][0] = 2; matr[1][0] = 2;
matr[1][1] = 1; matr[1][1] = 1;
matr[1][2] = 4; matr[1][2] = 4;
matr[2][0] = 6; matr[2][0] = 6;
matr[2][1] = 2; matr[2][1] = 2;
matr[2][2] = 5; matr[2][2] = 5;
matrix = matr.toUpperTriangular(); matrix = matr.toUpperTriangular();
d1 = matrix.determinant(); d1 = matrix.determinant();
for(uint i = 0; i < cols; i++) for(uint i = 0; i < cols; i++)
{ {
d2 = d2*matrix.at(i,i); d2 = d2*matrix.at(i,i);
} }
ASSERT_DOUBLE_EQ(d1, d2); ASSERT_DOUBLE_EQ(d1, d2);
} }
TEST(PIMathMatrixT_Test, transposed) { TEST(PIMathMatrixT_Test, transposed) {
PIMathMatrixT<rows, cols, double> matrix1; PIMathMatrixT<rows, cols, double> matrix1;
PIMathMatrixT<rows, cols, double> matrix2; PIMathMatrixT<rows, cols, double> matrix2;
PIMathMatrixT<rows, cols, double> matr; PIMathMatrixT<rows, cols, double> matr;
double d1, d2; double d1, d2;
matr[0][0] = 3; matr[0][0] = 3;
matr[0][1] = 6; matr[0][1] = 6;
matr[0][2] = 8; matr[0][2] = 8;
matr[1][0] = 2; matr[1][0] = 2;
matr[1][1] = 1; matr[1][1] = 1;
matr[1][2] = 4; matr[1][2] = 4;
matr[2][0] = 6; matr[2][0] = 6;
matr[2][1] = 2; matr[2][1] = 2;
matr[2][2] = 5; matr[2][2] = 5;
d1 = matr.determinant(); d1 = matr.determinant();
matrix1 = matr.transposed(); matrix1 = matr.transposed();
d2 = matrix1.determinant(); d2 = matrix1.determinant();
matrix2 = matrix1.transposed(); matrix2 = matrix1.transposed();
ASSERT_TRUE((d1 == d2) && (matr == matrix2)); ASSERT_TRUE((d1 == d2) && (matr == matrix2));
} }
TEST(PIMathMatrixT_Test, scaleX_two) { TEST(PIMathMatrixT_Test, scaleX_two) {
double factor = 5.64; double factor = 5.64;
PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleX(factor); PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleX(factor);
ASSERT_TRUE((1.0 == matrix.at(1u,1u)) && (factor == matrix.at(0u,0u))); ASSERT_TRUE((1.0 == matrix.at(1u,1u)) && (factor == matrix.at(0u,0u)));
} }
TEST(PIMathMatrixT_Test, scaleY_two) { TEST(PIMathMatrixT_Test, scaleY_two) {
double factor = 5.64; double factor = 5.64;
PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleY(factor); PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::scaleY(factor);
ASSERT_TRUE((factor == matrix.at(1u,1u)) && (1.0 == matrix.at(0u,0u))); ASSERT_TRUE((factor == matrix.at(1u,1u)) && (1.0 == matrix.at(0u,0u)));
} }
TEST(PIMathMatrixT_Test, rotation_2x2) { TEST(PIMathMatrixT_Test, rotation_2x2) {
double angle = 1.0; double angle = 1.0;
PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::rotation(angle); PIMathMatrixT<2u, 2u, double> matrix = PIMathMatrixT<2u, 2u, double>::rotation(angle);
double c = cos(angle); double c = cos(angle);
double s = sin(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))); 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) { TEST(PIMathMatrixT_Test, rotation_3x3) {
double angle = 1.0; double angle = 1.0;
PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotation(angle); PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotation(angle);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, 0.0, rows)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix, 0.0, rows));
} }
TEST(PIMathMatrixT_Test, rotationX) { TEST(PIMathMatrixT_Test, rotationX) {
double angle = 1.0; double angle = 1.0;
double c = cos(angle); double c = cos(angle);
double s = sin(angle); double s = sin(angle);
PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationX(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))); 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) { TEST(PIMathMatrixT_Test, rotationY) {
double angle = 1.0; double angle = 1.0;
double c = cos(angle); double c = cos(angle);
double s = sin(angle); double s = sin(angle);
PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationY(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))); 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) { TEST(PIMathMatrixT_Test, rotationZ) {
double angle = 1.0; double angle = 1.0;
double c = cos(angle); double c = cos(angle);
double s = sin(angle); double s = sin(angle);
PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::rotationZ(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))); 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) { TEST(PIMathMatrixT_Test, scaleX_three) {
double factor = 23.65; double factor = 23.65;
PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleX(factor); 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))); ASSERT_TRUE((1.0 == matrix.at(2u,2u)) && (factor == matrix.at(0u,0u)) && (1.0 == matrix.at(1u,1u)));
} }
TEST(PIMathMatrixT_Test, scaleY_three) { TEST(PIMathMatrixT_Test, scaleY_three) {
double factor = 23.65; double factor = 23.65;
PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleY(factor); 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))); ASSERT_TRUE((1.0 == matrix.at(2u,2u)) && (1.0 == matrix.at(0u,0u)) && (factor == matrix.at(1u,1u)));
} }
TEST(PIMathMatrixT_Test, scaleZ_three) { TEST(PIMathMatrixT_Test, scaleZ_three) {
double factor = 23.65; double factor = 23.65;
PIMathMatrixT<3u, 3u, double> matrix = PIMathMatrixT<3u, 3u, double>::scaleZ(factor); 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))); ASSERT_TRUE((factor == matrix.at(2u,2u)) && (1.0 == matrix.at(0u,0u)) && (1.0 == matrix.at(1u,1u)));
} }
TEST(PIMathMatrixT_Test, matrixMultiplication) TEST(PIMathMatrixT_Test, matrixMultiplication)
{ {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(1.5); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(1.5);
auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(2.5); auto matrix2 = PIMathMatrixT<rows, cols, double>::filled(2.5);
ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 11.25, 3)); ASSERT_TRUE(cmpSquareMatrixWithValue(matrix1 * matrix2, 11.25, 3));
} }
TEST(PIMathMatrixT_Test, matrixAndVectorMultiplication) { TEST(PIMathMatrixT_Test, matrixAndVectorMultiplication) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(1.5); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(1.5);
auto vector = PIMathVectorT<rows, double>::filled(2.5); auto vector = PIMathVectorT<rows, double>::filled(2.5);
for(uint i = 0; i < 2; i++) { for(uint i = 0; i < 2; i++) {
if((matrix1 * vector)[i] != 11.25) { if((matrix1 * vector)[i] != 11.25) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathMatrixT_Test, vectorAndMatrixMultiplication) { TEST(PIMathMatrixT_Test, vectorAndMatrixMultiplication) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(1.5); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(1.5);
auto vector = PIMathVectorT<rows, double>::filled(2.5); auto vector = PIMathVectorT<rows, double>::filled(2.5);
for(uint i = 0; i < 2; i++) { for(uint i = 0; i < 2; i++) {
if((vector * matrix1)[i] != 11.25) { if((vector * matrix1)[i] != 11.25) {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
} }
TEST(PIMathMatrixT_Test, valAndMatrixMultiplication) { TEST(PIMathMatrixT_Test, valAndMatrixMultiplication) {
auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(1.5); auto matrix1 = PIMathMatrixT<rows, cols, double>::filled(1.5);
ASSERT_TRUE(cmpSquareMatrixWithValue(25.0*matrix1, 37.5, 3)); ASSERT_TRUE(cmpSquareMatrixWithValue(25.0*matrix1, 37.5, 3));
} }

794
tests/math/testpimathvector.cpp
View File

@@ -2,446 +2,622 @@
#include "pimathvector.h" #include "pimathvector.h"
const uint SIZE = 3u; const uint SIZE = 3u;
const double angle45DegInRad = 0.78539816339744830961566084581988;
bool cmpVectorWithValue(PIMathVector<double> vector, double val, int num) { bool cmpVectorWithValue(PIMathVector<double> vector, double val, int num) {
bool b = true; bool b = true;
for(int i = 0; i < num; i++) { for(int i = 0; i < num; i++) {
if(vector[i] - val >= double(1E-200)) { if(vector[i] - val >= double(1E-200)) {
b = false; b = false;
} }
} }
return b; return b;
} }
TEST(PIMathVector_Test, size) { TEST(PIMathVector_Test, size) {
auto vector = PIMathVector<double>(SIZE); auto vector = PIMathVector<double>(SIZE);
ASSERT_TRUE(vector.size() == SIZE); ASSERT_TRUE(vector.size() == SIZE);
} }
TEST(PIMathVector_Test, resize) { TEST(PIMathVector_Test, resize) {
uint newSize = 4u; uint newSize = 4u;
double a = 5.0; double a = 5.0;
PIMathVector<double> vector; PIMathVector<double> vector;
vector.resize(newSize, a); vector.resize(newSize, a);
ASSERT_TRUE(cmpVectorWithValue(vector, a, vector.size())); ASSERT_TRUE(cmpVectorWithValue(vector, a, vector.size()));
ASSERT_TRUE(vector.size() == newSize); ASSERT_TRUE(vector.size() == newSize);
} }
TEST(PIMathVector_Test, resized) { TEST(PIMathVector_Test, resized) {
uint newSize = 4u; uint newSize = 4u;
double a = 5.0; double a = 5.0;
PIMathVector<double> vector; PIMathVector<double> vector;
auto vect = vector.resized(newSize, a); auto vect = vector.resized(newSize, a);
ASSERT_TRUE(cmpVectorWithValue(vect, a, vect.size()) && vect.size() == newSize); ASSERT_TRUE(cmpVectorWithValue(vect, a, vect.size()));
ASSERT_TRUE(vect.size() == newSize); ASSERT_TRUE(vect.size() == newSize);
} }
TEST(PIMathVector_Test, fill) { TEST(PIMathVector_Test, fill) {
double a = 5.0; double a = 5.0;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
vector.fill(a); vector.fill(a);
ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE));
} }
TEST(PIMathVector_Test, moveVal) { TEST(PIMathVector_Test, moveVal) {
double a = 5.0; double a = 5.0;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
vector.fill(a); vector.fill(a);
vector.move(a); vector.move(a);
ASSERT_TRUE(cmpVectorWithValue(vector, 2 * a, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector, 2 * a, SIZE));
} }
TEST(PIMathVector_Test, moveVec) { TEST(PIMathVector_Test, moveVec) {
double a = 5.0; double a = 5.0;
double b = 7.0; double b = 7.0;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
PIMathVector<double> vec(SIZE); PIMathVector<double> vec(SIZE);
vector.fill(a); vector.fill(a);
vec.fill(b); vec.fill(b);
vector.move(vec); vector.move(vec);
ASSERT_TRUE(cmpVectorWithValue(vector, a + b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector, a + b, SIZE));
}
TEST(PIMathVector_Test, moveVecSizeNotEq) {
double a = 5.0;
double b = 7.0;
uint bias = 2u;
PIMathVector<double> vector(SIZE);
PIMathVector<double> 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) { TEST(PIMathVector_Test, swap) {
double b = 5.12; double b = 5.12;
double c = 3.32; double c = 3.32;
double d = 7.12; double d = 7.12;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
double a[3]; double a[3];
vector[0] = b; vector[0] = b;
vector[1] = c; vector[1] = c;
vector[2] = d; vector[2] = d;
a[0] = vector[0]; a[0] = vector[0];
a[1] = vector[1]; a[1] = vector[1];
a[2] = vector[2]; a[2] = vector[2];
vector.swap(0u, 1u); vector.swap(0u, 1u);
ASSERT_DOUBLE_EQ(a[0], vector[1]); ASSERT_DOUBLE_EQ(a[0], vector[1]);
ASSERT_DOUBLE_EQ(a[1], vector[0]); ASSERT_DOUBLE_EQ(a[1], vector[0]);
ASSERT_DOUBLE_EQ(a[2], vector[2]); ASSERT_DOUBLE_EQ(a[2], vector[2]);
} }
TEST(PIMathVector_Test, lengthSqr) { TEST(PIMathVector_Test, lengthSqr) {
double a = 3.0; double a = 3.0;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
vector.fill(a); vector.fill(a);
ASSERT_DOUBLE_EQ(SIZE * a * a, vector.lengthSqr()); ASSERT_DOUBLE_EQ(SIZE * a * a, vector.lengthSqr());
} }
TEST(PIMathVector_Test, length) { TEST(PIMathVector_Test, length) {
double a = 3.32; double a = 3.32;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
vector.fill(a); vector.fill(a);
ASSERT_DOUBLE_EQ(sqrt(SIZE * a * a), vector.length()); ASSERT_DOUBLE_EQ(sqrt(SIZE * a * a), vector.length());
} }
TEST(PIMathVector_Test, manhattanLength) { TEST(PIMathVector_Test, manhattanLength) {
double a = 3.32; double a = 3.32;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
vector.fill(a); vector.fill(a);
ASSERT_DOUBLE_EQ(SIZE * a, vector.manhattanLength()); ASSERT_DOUBLE_EQ(SIZE * a, vector.manhattanLength());
} }
TEST(PIMathVector_Test, angleCos) { TEST(PIMathVector_Test, angleCos) {
double a = 3.32; double a = 3.32;
double angle = 0.78539816339744830961566084581988; PIMathVector<double> vector(SIZE);
PIMathVector<double> vector(SIZE); PIMathVector<double> vec(SIZE);
PIMathVector<double> vec(SIZE); vector[0] = a;
vector[0] = a; vector[1] = a;
vector[1] = a; vec[1] = a;
vec[1] = a; ASSERT_DOUBLE_EQ(cos(angle45DegInRad), vector.angleCos(vec));
ASSERT_DOUBLE_EQ(cos(angle), vector.angleCos(vec)); }
TEST(PIMathVector_Test, angleCosSizeNotEq) {
double a = 3.32;
uint bias = 2u;
PIMathVector<double> vector(SIZE);
PIMathVector<double> vec(SIZE + bias);
vector[0] = a;
vector[1] = a;
vec[1] = a;
ASSERT_FALSE(vector.angleCos(vec));
} }
TEST(PIMathVector_Test, angleSin) { TEST(PIMathVector_Test, angleSin) {
double a = 3.32; double a = 3.32;
double angle = 0.78539816339744830961566084581988; PIMathVector<double> vector(SIZE);
PIMathVector<double> vector(SIZE); PIMathVector<double> vec(SIZE);
PIMathVector<double> vec(SIZE); vector[0] = a;
vector[0] = a; vector[1] = a;
vector[1] = a; vec[1] = a;
vec[1] = a; ASSERT_DOUBLE_EQ(sin(angle45DegInRad), vector.angleSin(vec));
ASSERT_DOUBLE_EQ(sin(angle), vector.angleSin(vec)); }
TEST(PIMathVector_Test, angleSinSizeNotEq) {
double a = 3.32;
uint bias = 2u;
PIMathVector<double> vector(SIZE);
PIMathVector<double> vec(SIZE + bias);
vector[0] = a;
vector[1] = a;
vec[1] = a;
ASSERT_FALSE(vector.angleSin(vec));
} }
TEST(PIMathVector_Test, angleRad) { TEST(PIMathVector_Test, angleRad) {
double a = 3.32; double a = 3.32;
double angle = 0.78539816339744830961566084581988; PIMathVector<double> vector(SIZE);
PIMathVector<double> vector(SIZE); PIMathVector<double> vec(SIZE);
PIMathVector<double> vec(SIZE); vector[0] = a;
vector[0] = a; vector[1] = a;
vector[1] = a; vec[1] = a;
vec[1] = a; ASSERT_DOUBLE_EQ(angle45DegInRad, vector.angleRad(vec));
ASSERT_DOUBLE_EQ(angle, vector.angleRad(vec)); }
TEST(PIMathVector_Test, angleRadSizeNotEq) {
double a = 3.32;
uint bias = 2u;
PIMathVector<double> vector(SIZE);
PIMathVector<double> vec(SIZE + bias);
vector[0] = a;
vector[1] = a;
vec[1] = a;
ASSERT_FALSE(vector.angleRad(vec));
} }
TEST(PIMathVector_Test, angleDeg) { TEST(PIMathVector_Test, angleDeg) {
double a = 3.32; double a = 3.32;
double angle = 45.0; double angle45Deg = 45.0;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
PIMathVector<double> vec(SIZE); PIMathVector<double> vec(SIZE);
vector[0] = a; vector[0] = a;
vector[1] = a; vector[1] = a;
vec[1] = a; vec[1] = a;
ASSERT_DOUBLE_EQ(angle, vector.angleDeg(vec)); ASSERT_DOUBLE_EQ(angle45Deg, vector.angleDeg(vec));
}
TEST(PIMathVector_Test, angleDegSizeNotEq) {
double a = 3.32;
uint bias = 2u;
PIMathVector<double> vector(SIZE);
PIMathVector<double> vec(SIZE + bias);
vector[0] = a;
vector[1] = a;
vec[1] = a;
ASSERT_FALSE(vector.angleDeg(vec));
} }
TEST(PIMathVector_Test, projection) { TEST(PIMathVector_Test, projection) {
double a = 2.0; double a = 2.0;
double b = 2.0; double b = 2.0;
double res = sqrt(32.0); double res = sqrt(32.0);
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
PIMathVector<double> vec(SIZE); PIMathVector<double> vec(SIZE);
vec[0] = a; vec[0] = a;
vec[2] = b; vec[2] = b;
vector[0] = a; vector[0] = a;
vector[1] = b; vector[1] = b;
vector[2] = a; vector[2] = a;
auto vecProj = vector.projection(vec); auto vecProj = vector.projection(vec);
ASSERT_DOUBLE_EQ(res, vecProj[0]); ASSERT_DOUBLE_EQ(res, vecProj[0]);
ASSERT_DOUBLE_EQ(0.0, vecProj[1]); ASSERT_DOUBLE_EQ(0.0, vecProj[1]);
ASSERT_DOUBLE_EQ(res, vecProj[2]); ASSERT_DOUBLE_EQ(res, vecProj[2]);
}
TEST(PIMathVector_Test, projectionSizeNotEq) {
double a = 2.0;
double b = 2.0;
uint bias = 2u;
PIMathVector<double> vector(SIZE);
PIMathVector<double> 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) { TEST(PIMathVector_Test, normalize) {
double a = 5.0; double a = 5.0;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
vector.fill(a); vector.fill(a);
ASSERT_TRUE(cmpVectorWithValue(vector.normalize(), a / sqrt(SIZE * a * a), SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector.normalize(), a / sqrt(SIZE * a * a), SIZE));
} }
TEST(PIMathVector_Test, normalized) { TEST(PIMathVector_Test, normalized) {
double a = 5.0; double a = 5.0;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
PIMathVector<double> vectorNew(SIZE); PIMathVector<double> vectorNew(SIZE);
vector.fill(a); vector.fill(a);
vectorNew = vector.normalized(); vectorNew = vector.normalized();
ASSERT_TRUE(cmpVectorWithValue(vectorNew, a / sqrt(SIZE * a * a), SIZE)); ASSERT_TRUE(cmpVectorWithValue(vectorNew, a / sqrt(SIZE * a * a), SIZE));
} }
TEST(PIMathVector_Test, isNullTrue) { TEST(PIMathVector_Test, isNullTrue) {
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
ASSERT_TRUE(vector.isNull()); ASSERT_TRUE(vector.isNull());
} }
TEST(PIMathVector_Test, isNullFalse) { TEST(PIMathVector_Test, isNullFalse) {
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
vector[0] = 6.273; vector[0] = 6.273;
ASSERT_FALSE(vector.isNull()); ASSERT_FALSE(vector.isNull());
} }
TEST(PIMathVector_Test, isValidTrue) { TEST(PIMathVector_Test, isValidTrue) {
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
ASSERT_TRUE(vector.isValid()); ASSERT_TRUE(vector.isValid());
} }
TEST(PIMathVector_Test, isValidFalse) { TEST(PIMathVector_Test, isValidFalse) {
PIMathVector<double> vector; PIMathVector<double> vector;
ASSERT_FALSE(vector.isValid()); ASSERT_FALSE(vector.isValid());
} }
TEST(PIMathVector_Test, isOrthoTrue) { TEST(PIMathVector_Test, isOrthoTrue) {
uint sizeNew = 2u; uint sizeNew = 2u;
double a = 2.0; double a = 2.0;
double b = 1.0; double b = 1.0;
PIMathVector<double> vector(sizeNew); PIMathVector<double> vector(sizeNew);
PIMathVector<double> vect(sizeNew); PIMathVector<double> vect(sizeNew);
vector[0] = a; vector[0] = a;
vect[1] = b; vect[1] = b;
ASSERT_TRUE(vector.isOrtho(vect)); ASSERT_TRUE(vector.isOrtho(vect));
} }
TEST(PIMathVector_Test, isOrthoFalse) { TEST(PIMathVector_Test, isOrthoFalse) {
uint sizeNew = 2u; uint sizeNew = 2u;
double a = 2.0; double a = 2.0;
double b = 1.0; double b = 1.0;
double c = 5.0; double c = 5.0;
PIMathVector<double> vector(sizeNew); PIMathVector<double> vector(sizeNew);
PIMathVector<double> vect(sizeNew); PIMathVector<double> vect(sizeNew);
vector[0] = a; vector[0] = a;
vect[0] = c; vect[0] = c;
vect[1] = b; vect[1] = b;
ASSERT_FALSE(vector.isOrtho(vect)); ASSERT_FALSE(vector.isOrtho(vect));
} }
TEST(PIMathVector_Test, at) { TEST(PIMathVector_Test, at) {
double a = 5.5; double a = 5.5;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
vector.fill(a); vector.fill(a);
for(uint i = 0; i < SIZE; i++){ for(uint i = 0; i < SIZE; i++){
if(vector.at(i) - a >= double(1E-200)){ if(vector.at(i) - a >= double(1E-200)){
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathVector_Test, operator_AssignmentValue) { TEST(PIMathVector_Test, operator_AssignmentValue) {
double a = 5.5; double a = 5.5;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
vector = a; vector = a;
ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE));
} }
TEST(PIMathVector_Test, operator_AssignmentVector) { TEST(PIMathVector_Test, operator_AssignmentVector) {
double a = 5.5; double a = 5.5;
PIMathVector<double> vector(SIZE); PIMathVector<double> vector(SIZE);
PIMathVector<double> vec(SIZE); PIMathVector<double> vec(SIZE);
vec = a; vec = a;
vector = vec; vector = vec;
ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE));
}
TEST(PIMathVector_Test, operator_AssignmentVectorSizeNotEq) {
double a = 5.5;
double b = 1.43;
uint bias = 2u;
PIMathVector<double> vector(SIZE);
PIMathVector<double> vec(SIZE + bias);
vector = b;
vec = a;
vector = vec;
ASSERT_TRUE(cmpVectorWithValue(vector, b, SIZE));
} }
TEST(PIMathVector_Test, operator_EqualTrue) { TEST(PIMathVector_Test, operator_EqualTrue) {
double a = 5.12; double a = 5.12;
double b = 7.34; double b = 7.34;
uint newSize = 2u; uint newSize = 2u;
PIMathVector<double> vector(newSize); PIMathVector<double> vector(newSize);
PIMathVector<double> vec(newSize); PIMathVector<double> vec(newSize);
vector[0] = a; vector[0] = a;
vector[1] = b; vector[1] = b;
vec[0] = a; vec[0] = a;
vec[1] = b; vec[1] = b;
ASSERT_TRUE(vec == vector); ASSERT_TRUE(vec == vector);
} }
TEST(PIMathVector_Test, operator_EqualFalse) { TEST(PIMathVector_Test, operator_EqualFalse) {
double a = 5.12; double a = 5.12;
double b = 7.34; double b = 7.34;
double c = 7.332; double c = 7.332;
uint newSize = 2u; uint newSize = 2u;
PIMathVector<double> vector(newSize); PIMathVector<double> vector(newSize);
PIMathVector<double> vec(newSize); PIMathVector<double> vec(newSize);
vector[0] = a; vector[0] = a;
vector[1] = b; vector[1] = b;
vec[0] = a; vec[0] = a;
vec[1] = c; vec[1] = c;
ASSERT_FALSE(vec == vector); ASSERT_FALSE(vec == vector);
} }
TEST(PIMathVector_Test, operator_Not_EqualTrue) { TEST(PIMathVector_Test, operator_Not_EqualTrue) {
double a = 5.12; double a = 5.12;
double b = 7.34; double b = 7.34;
double c = 7.332; double c = 7.332;
uint newSize = 2u; uint newSize = 2u;
PIMathVector<double> vector(newSize); PIMathVector<double> vector(newSize);
PIMathVector<double> vec(newSize); PIMathVector<double> vec(newSize);
vector[0] = a; vector[0] = a;
vector[1] = b; vector[1] = b;
vec[0] = a; vec[0] = a;
vec[1] = c; vec[1] = c;
ASSERT_TRUE(vec != vector); ASSERT_TRUE(vec != vector);
} }
TEST(PIMathVector_Test, operator_Not_EqualFalse) { TEST(PIMathVector_Test, operator_Not_EqualFalse) {
double a = 5.12; double a = 5.12;
double b = 7.34; double b = 7.34;
uint newSize = 2u; uint newSize = 2u;
PIMathVector<double> vector(newSize); PIMathVector<double> vector(newSize);
PIMathVector<double> vec(newSize); PIMathVector<double> vec(newSize);
vector[0] = a; vector[0] = a;
vector[1] = b; vector[1] = b;
vec[0] = a; vec[0] = a;
vec[1] = b; vec[1] = b;
ASSERT_FALSE(vec != vector); ASSERT_FALSE(vec != vector);
} }
TEST(PIMathVector_Test, operator_Addition_Aassignment) { TEST(PIMathVector_Test, operator_Addition_Assignment) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE); PIMathVector<double> vector2(SIZE);
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
vector1 += vector2; vector1 += vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a + b, SIZE)); 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<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE + bias);
vector1.fill(a);
vector2.fill(b);
vector1 += vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a, SIZE));
} }
TEST(PIMathVector_Test, operator_Subtraction_Assignment) { TEST(PIMathVector_Test, operator_Subtraction_Assignment) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE); PIMathVector<double> vector2(SIZE);
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
vector1 -= vector2; vector1 -= vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a - b, SIZE)); 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<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE + bias);
vector1.fill(a);
vector2.fill(b);
vector1 -= vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a, SIZE));
} }
TEST(PIMathVector_Test, operator_Multiplication_AssignmentValue) { TEST(PIMathVector_Test, operator_Multiplication_AssignmentValue) {
double a = 6.0; double a = 6.0;
double b = 4.0; double b = 4.0;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
vector1.fill(a); vector1.fill(a);
vector1 *= b; vector1 *= b;
ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE));
} }
TEST(PIMathVector_Test, operator_Multiplication_AssignmentVector) { TEST(PIMathVector_Test, operator_Multiplication_AssignmentVector) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE); PIMathVector<double> vector2(SIZE);
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
vector1 *= vector2; vector1 *= vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); 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<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE + bias);
vector1.fill(a);
vector2.fill(b);
vector1 *= vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a, SIZE));
} }
TEST(PIMathVector_Test, operator_Division_AssignmentValue) { TEST(PIMathVector_Test, operator_Division_AssignmentValue) {
double a = 6.0; double a = 6.0;
double b = 4.0; double b = 4.0;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
vector1.fill(a); vector1.fill(a);
vector1 /= b; vector1 /= b;
ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE));
} }
TEST(PIMathVector_Test, operator_Division_AssignmentVector) { TEST(PIMathVector_Test, operator_Division_AssignmentVector) {
double a = 6.0; double a = 6.0;
double b = 1.5; double b = 1.5;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE); PIMathVector<double> vector2(SIZE);
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
vector1 /= vector2; vector1 /= vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); 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<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE + bias);
vector1.fill(a);
vector2.fill(b);
vector1 /= vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a, SIZE));
} }
TEST(PIMathVector_Test, operator_Addition) { TEST(PIMathVector_Test, operator_Addition) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE); PIMathVector<double> vector2(SIZE);
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue(vector1 + vector2, a + b, SIZE)); 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<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE + bias);
vector1.fill(a);
vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue(vector1 + vector2, a, SIZE));
} }
TEST(PIMathVector_Test, operator_Subtraction) { TEST(PIMathVector_Test, operator_Subtraction) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE); PIMathVector<double> vector2(SIZE);
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue(vector1 - vector2, a - b, SIZE)); 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<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE + bias);
vector1.fill(a);
vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue(vector1 - vector2, a, SIZE));
} }
TEST(PIMathVector_Test, operator_MultiplicationValue) { TEST(PIMathVector_Test, operator_MultiplicationValue) {
double a = 6.0; double a = 6.0;
double b = 4.0; double b = 4.0;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE); PIMathVector<double> vector2(SIZE);
vector1.fill(a); vector1.fill(a);
ASSERT_TRUE(cmpVectorWithValue(vector1 * b, a * b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1 * b, a * b, SIZE));
} }
TEST(PIMathVector_Test, operator_MultiplicationVector1) { TEST(PIMathVector_Test, operator_MultiplicationVector1) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE); PIMathVector<double> vector2(SIZE);
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue((vector1 * vector2), 0.0, SIZE)); ASSERT_TRUE(cmpVectorWithValue((vector1 * vector2), 0.0, SIZE));
} }
TEST(PIMathVector_Test, operator_MultiplicationVector2) { TEST(PIMathVector_Test, operator_MultiplicationVector2) {
double a = 1.0; double a = 1.0;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE); PIMathVector<double> vector2(SIZE);
vector1[0] = a; vector1[0] = a;
vector2[1] = a; vector2[1] = a;
auto crossVec = vector1 * vector2; auto crossVec = vector1 * vector2;
ASSERT_DOUBLE_EQ(crossVec[0], 0.0); ASSERT_DOUBLE_EQ(crossVec[0], 0.0);
ASSERT_DOUBLE_EQ(crossVec[1], 0.0); ASSERT_DOUBLE_EQ(crossVec[1], 0.0);
ASSERT_DOUBLE_EQ(crossVec[2], a); ASSERT_DOUBLE_EQ(crossVec[2], a);
} }
TEST(PIMathVector_Test, operator_DivisionValue) { TEST(PIMathVector_Test, operator_DivisionValue) {
double a = 6.0; double a = 6.0;
double b = 4.0; double b = 4.0;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
vector1.fill(a); vector1.fill(a);
ASSERT_TRUE(cmpVectorWithValue(vector1 / b, a / b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1 / b, a / b, SIZE));
} }
TEST(PIMathVector_Test, operator_MultiplVect) { TEST(PIMathVector_Test, operator_MultiplVect) {
double a = 6.0; double a = 6.0;
double b = 5.0; double b = 5.0;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE); PIMathVector<double> vector2(SIZE);
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue(vector1 & vector2, a * b, SIZE)); 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<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE + bias);
vector1.fill(a);
vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue(vector1 & vector2, a , SIZE));
} }
TEST(PIMathVector_Test, operator_DotProduct) { TEST(PIMathVector_Test, operator_DotProduct) {
double a = 6.0; double a = 6.0;
double b = 5.0; double b = 5.0;
PIMathVector<double> vector1(SIZE); PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE); PIMathVector<double> vector2(SIZE);
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(SIZE * a * b == (vector1 ^ vector2)); ASSERT_TRUE(SIZE * a * b == (vector1 ^ vector2));
}
TEST(PIMathVector_Test, operator_DotProductSizeNotEq) {
double a = 6.0;
double b = 5.0;
uint bias = 2u;
PIMathVector<double> vector1(SIZE);
PIMathVector<double> vector2(SIZE + bias);
vector1.fill(a);
vector2.fill(b);
ASSERT_FALSE(vector1 ^ vector2);
} }

694
tests/math/testpimathvectort.cpp
View File

@@ -3,509 +3,507 @@
#include "pimathmatrix.h" #include "pimathmatrix.h"
const uint SIZE = 3u; const uint SIZE = 3u;
const double angle45DegInRad = 0.78539816339744830961566084581988;
bool cmpVectorWithValue(PIMathVectorT<SIZE, double> vector, double val, int num) { bool cmpVectorWithValue(PIMathVectorT<SIZE, double> vector, double val, int num) {
bool b = true; bool b = true;
for(int i = 0; i < num; i++) { for(int i = 0; i < num; i++) {
if(vector[i] - val >= double(1E-200)) { if(vector[i] - val >= double(1E-200)) {
b = false; b = false;
} }
} }
return b; return b;
} }
TEST(PIMathVectorT_Test, size) { TEST(PIMathVectorT_Test, size) {
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
ASSERT_TRUE(vector.size() == SIZE); ASSERT_TRUE(vector.size() == SIZE);
} }
TEST(PIMathVectorT_Test, fill) { TEST(PIMathVectorT_Test, fill) {
double a = 5.0; double a = 5.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
ASSERT_TRUE(cmpVectorWithValue(vector.fill(a), a, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector.fill(a), a, SIZE));
} }
TEST(PIMathVectorT_Test, set) { TEST(PIMathVectorT_Test, set) {
double a = 5.0; double a = 5.0;
double b = 3.0; double b = 3.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE, double> vector2; PIMathVectorT<SIZE, double> vector2;
ASSERT_TRUE(cmpVectorWithValue(vector.set(vector1.fill(a), vector2.fill(b)), b - a, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector.set(vector1.fill(a), vector2.fill(b)), b - a, SIZE));
} }
TEST(PIMathVectorT_Test, MoveVal) { TEST(PIMathVectorT_Test, MoveVal) {
double a = 4.0; double a = 4.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
ASSERT_TRUE(cmpVectorWithValue(vector.move(a), a, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector.move(a), a, SIZE));
} }
TEST(PIMathVectorT_Test, MoveVector) { TEST(PIMathVectorT_Test, MoveVector) {
double a = 5.0; double a = 5.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
ASSERT_TRUE(cmpVectorWithValue(vector.move(vector1.fill(a)), a, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector.move(vector1.fill(a)), a, SIZE));
} }
TEST(PIMathVectorT_Test, lengthSqr) { TEST(PIMathVectorT_Test, lengthSqr) {
double a = 1.0; double a = 1.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
vector.fill(a); vector.fill(a);
ASSERT_DOUBLE_EQ(SIZE * a, vector.lengthSqr()); ASSERT_DOUBLE_EQ(SIZE * a, vector.lengthSqr());
} }
TEST(PIMathVectorT_Test, length) { TEST(PIMathVectorT_Test, length) {
double a = 1.0; double a = 1.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
vector.fill(a); vector.fill(a);
ASSERT_DOUBLE_EQ(sqrt(SIZE * a), vector.length()); ASSERT_DOUBLE_EQ(sqrt(SIZE * a), vector.length());
} }
TEST(PIMathVectorT_Test, manhattanLength) { TEST(PIMathVectorT_Test, manhattanLength) {
double a = 5.0; double a = 5.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
vector.fill(a); vector.fill(a);
ASSERT_DOUBLE_EQ(SIZE * a, vector.manhattanLength()); ASSERT_DOUBLE_EQ(SIZE * a, vector.manhattanLength());
} }
TEST(PIMathVectorT_Test, angleCos) { TEST(PIMathVectorT_Test, angleCos) {
double a = 1.0; double a = 1.0;
double angle = 0.78539816339744830961566084581988; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vec;
PIMathVectorT<SIZE, double> vec; vector[0] = a;
vector[0] = a; vector[1] = a;
vector[1] = a; vec[1] = a;
vec[1] = a; ASSERT_DOUBLE_EQ(cos(angle45DegInRad), vector.angleCos(vec));
ASSERT_DOUBLE_EQ(cos(angle), vector.angleCos(vec));
} }
TEST(PIMathVectorT_Test, angleSin) { TEST(PIMathVectorT_Test, angleSin) {
double a = 1.0; double a = 1.0;
double angle = 0.78539816339744830961566084581988; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vec;
PIMathVectorT<SIZE, double> vec; vector[0] = a;
vector[0] = a; vector[1] = a;
vector[1] = a; vec[1] = a;
vec[1] = a; ASSERT_DOUBLE_EQ(sin(angle45DegInRad), vector.angleSin(vec));
ASSERT_DOUBLE_EQ(sin(angle), vector.angleSin(vec));
} }
TEST(PIMathVectorT_Test, angleRad) { TEST(PIMathVectorT_Test, angleRad) {
double a = 1.0; double a = 1.0;
double angle = 0.78539816339744830961566084581988; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vec;
PIMathVectorT<SIZE, double> vec; vector[0] = a;
vector[0] = a; vector[1] = a;
vector[1] = a; vec[1] = a;
vec[1] = a; ASSERT_DOUBLE_EQ(angle45DegInRad, vector.angleRad(vec));
ASSERT_DOUBLE_EQ(angle, vector.angleRad(vec));
} }
TEST(PIMathVectorT_Test, angleDeg) { TEST(PIMathVectorT_Test, angleDeg) {
double a = 1.0; double a = 1.0;
double angle = 45.0; double angle45inDeg = 45.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vec; PIMathVectorT<SIZE, double> vec;
vector[0] = a; vector[0] = a;
vector[1] = a; vector[1] = a;
vec[1] = a; vec[1] = a;
ASSERT_DOUBLE_EQ(angle, vector.angleDeg(vec)); ASSERT_DOUBLE_EQ(angle45inDeg, vector.angleDeg(vec));
} }
TEST(PIMathVectorT_Test, angleElevation) { TEST(PIMathVectorT_Test, angleElevation) {
double a = 1.0; double a = 1.0;
double angle = 45.0; double angle45inDeg = 45.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vec; PIMathVectorT<SIZE, double> vec;
vector[0] = a; vector[0] = a;
vector[1] = a; vector[1] = a;
vec[1] = a; vec[1] = a;
ASSERT_DOUBLE_EQ(-angle, vector.angleElevation(vec)); ASSERT_DOUBLE_EQ(-angle45inDeg, vector.angleElevation(vec));
} }
TEST(PIMathVectorT_Test, projection) { TEST(PIMathVectorT_Test, projection) {
double a = 2.0; double a = 2.0;
double b = 2.0; double b = 2.0;
double res = sqrt(32.0); double res = sqrt(32.0);
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vec; PIMathVectorT<SIZE, double> vec;
vec[0] = a; vec[0] = a;
vec[2] = b; vec[2] = b;
vector[0] = a; vector[0] = a;
vector[1] = b; vector[1] = b;
vector[2] = a; vector[2] = a;
auto vecProj = vector.projection(vec); auto vecProj = vector.projection(vec);
ASSERT_DOUBLE_EQ(res, vecProj[0]); ASSERT_DOUBLE_EQ(res, vecProj[0]);
ASSERT_DOUBLE_EQ(0.0, vecProj[1]); ASSERT_DOUBLE_EQ(0.0, vecProj[1]);
ASSERT_DOUBLE_EQ(res, vecProj[2]); ASSERT_DOUBLE_EQ(res, vecProj[2]);
} }
TEST(PIMathVectorT_Test, normalize) { TEST(PIMathVectorT_Test, normalize) {
double a = 5.0; double a = 5.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
vector.fill(a); vector.fill(a);
ASSERT_TRUE(cmpVectorWithValue(vector.normalize(), a / sqrt(SIZE * a * a), SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector.normalize(), a / sqrt(SIZE * a * a), SIZE));
} }
TEST(PIMathVectorT_Test, normalized) { TEST(PIMathVectorT_Test, normalized) {
double a = 5.0; double a = 5.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vectorNew; PIMathVectorT<SIZE, double> vectorNew;
vector.fill(a); vector.fill(a);
vectorNew = vector.normalized(); vectorNew = vector.normalized();
ASSERT_TRUE(cmpVectorWithValue(vectorNew, a / sqrt(SIZE * a * a), SIZE)); ASSERT_TRUE(cmpVectorWithValue(vectorNew, a / sqrt(SIZE * a * a), SIZE));
} }
TEST(PIMathVectorT_Test, cross1) { TEST(PIMathVectorT_Test, cross1) {
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE, double> vector2; PIMathVectorT<SIZE, double> vector2;
double a = 5.0; double a = 5.0;
double b = 1.72; double b = 1.72;
double c = 0.0; double c = 0.0;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue(vector1.cross(vector2), c, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1.cross(vector2), c, SIZE));
} }
TEST(PIMathVectorT_Test, cross2) { TEST(PIMathVectorT_Test, cross2) {
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE, double> vector2; PIMathVectorT<SIZE, double> vector2;
double a = 1.0; double a = 1.0;
vector1[0] = a; vector1[0] = a;
vector2[1] = a; vector2[1] = a;
auto crossVec = vector1 * vector2; auto crossVec = vector1 * vector2;
ASSERT_DOUBLE_EQ(crossVec[0], 0.0); ASSERT_DOUBLE_EQ(crossVec[0], 0.0);
ASSERT_DOUBLE_EQ(crossVec[1], 0.0); ASSERT_DOUBLE_EQ(crossVec[1], 0.0);
ASSERT_DOUBLE_EQ(crossVec[2], a); ASSERT_DOUBLE_EQ(crossVec[2], a);
} }
TEST(PIMathVectorT_Test, dot) { TEST(PIMathVectorT_Test, dot) {
double a = 6.0; double a = 6.0;
double b = 5.0; double b = 5.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE, double> vector2; PIMathVectorT<SIZE, double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_DOUBLE_EQ(vector1.dot(vector2), SIZE * a * b); ASSERT_DOUBLE_EQ(vector1.dot(vector2), SIZE * a * b);
} }
TEST(PIMathVectorT_Test, isNullTrue) { TEST(PIMathVectorT_Test, isNullTrue) {
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
ASSERT_TRUE(vector.isNull()); ASSERT_TRUE(vector.isNull());
} }
TEST(PIMathVectorT_Test, isNullFalse) { TEST(PIMathVectorT_Test, isNullFalse) {
double a = 6.273; double a = 6.273;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
vector[0] = a; vector[0] = a;
ASSERT_FALSE(vector.isNull()); ASSERT_FALSE(vector.isNull());
} }
TEST(PIMathVectorT_Test, isOrthoTrue) { TEST(PIMathVectorT_Test, isOrthoTrue) {
double a = 2.0; double a = 2.0;
double b = 1.0; double b = 1.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vect; PIMathVectorT<SIZE, double> vect;
vector[0] = a; vector[0] = a;
vect[1] = b; vect[1] = b;
ASSERT_TRUE(vector.isOrtho(vect)); ASSERT_TRUE(vector.isOrtho(vect));
} }
TEST(PIMathVectorT_Test, isOrthoFalse) { TEST(PIMathVectorT_Test, isOrthoFalse) {
double a = 2.0; double a = 2.0;
double b = 5.0; double b = 5.0;
double c = 1.0; double c = 1.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vect; PIMathVectorT<SIZE, double> vect;
vector[0] = a; vector[0] = a;
vect[0] = b; vect[0] = b;
vect[1] = c; vect[1] = c;
ASSERT_FALSE(vector.isOrtho(vect)); ASSERT_FALSE(vector.isOrtho(vect));
} }
TEST(PIMathVectorT_Test, at) { TEST(PIMathVectorT_Test, at) {
double a = 5.5; double a = 5.5;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
vector.fill(a); vector.fill(a);
for(uint i = 0; i < SIZE; i++){ for(uint i = 0; i < SIZE; i++){
if(vector.at(i) != a){ if(vector.at(i) != a){
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathVectorT_Test, operator_AssignmentValue) { TEST(PIMathVectorT_Test, operator_AssignmentValue) {
double a = 3.0; double a = 3.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
vector = a; vector = a;
ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE));
} }
TEST(PIMathVectorT_Test, operator_AssignmentVector) { TEST(PIMathVectorT_Test, operator_AssignmentVector) {
double a = 5.0; double a = 5.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vec; PIMathVectorT<SIZE, double> vec;
vec = a; vec = a;
vector = vec; vector = vec;
ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE));
} }
TEST(PIMathVectorT_Test, operator_EqualTrue) { TEST(PIMathVectorT_Test, operator_EqualTrue) {
double a = 5.12; double a = 5.12;
double b = 7.34; double b = 7.34;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vec; PIMathVectorT<SIZE, double> vec;
vector[0] = a; vector[0] = a;
vector[1] = b; vector[1] = b;
vec[0] = a; vec[0] = a;
vec[1] = b; vec[1] = b;
ASSERT_TRUE(vec == vector); ASSERT_TRUE(vec == vector);
} }
TEST(PIMathVectorT_Test, operator_EqualFalse) { TEST(PIMathVectorT_Test, operator_EqualFalse) {
double a = 5.12; double a = 5.12;
double b = 7.34; double b = 7.34;
double c = 0.34; double c = 0.34;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vec; PIMathVectorT<SIZE, double> vec;
vector[0] = a; vector[0] = a;
vector[1] = b; vector[1] = b;
vec[0] = a; vec[0] = a;
vec[1] = c; vec[1] = c;
ASSERT_FALSE(vec == vector); ASSERT_FALSE(vec == vector);
} }
TEST(PIMathVectorT_Test, operator_Not_EqualTrue) { TEST(PIMathVectorT_Test, operator_Not_EqualTrue) {
double a = 5.12; double a = 5.12;
double b = 7.34; double b = 7.34;
double c = 0.34; double c = 0.34;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vec; PIMathVectorT<SIZE, double> vec;
vector[0] = a; vector[0] = a;
vector[1] = b; vector[1] = b;
vec[0] = a; vec[0] = a;
vec[1] = c; vec[1] = c;
ASSERT_TRUE(vec != vector); ASSERT_TRUE(vec != vector);
} }
TEST(PIMathVectorT_Test, operator_Not_EqualFalse) { TEST(PIMathVectorT_Test, operator_Not_EqualFalse) {
double a = 5.12; double a = 5.12;
double b = 7.34; double b = 7.34;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
PIMathVectorT<SIZE, double> vec; PIMathVectorT<SIZE, double> vec;
vector[0] = a; vector[0] = a;
vector[1] = b; vector[1] = b;
vec[0] = a; vec[0] = a;
vec[1] = b; vec[1] = b;
ASSERT_FALSE(vec != vector); ASSERT_FALSE(vec != vector);
} }
TEST(PIMathVectorT_Test, operator_Addition_Aassignment) { TEST(PIMathVectorT_Test, operator_Addition_Assignment) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
vector1 += vector2; vector1 += vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a + b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1, a + b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_Subtraction_Assignment) { TEST(PIMathVectorT_Test, operator_Subtraction_Assignment) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
vector1 -= vector2; vector1 -= vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a - b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1, a - b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_Multiplication_AssignmentValue) { TEST(PIMathVectorT_Test, operator_Multiplication_AssignmentValue) {
double a = 6.0; double a = 6.0;
double b = 4.0; double b = 4.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
vector1.fill(a); vector1.fill(a);
vector1 *= b; vector1 *= b;
ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_Multiplication_AssignmentVector) { TEST(PIMathVectorT_Test, operator_Multiplication_AssignmentVector) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
vector1 *= vector2; vector1 *= vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1, a * b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_Division_AssignmentValue) { TEST(PIMathVectorT_Test, operator_Division_AssignmentValue) {
double a = 6.0; double a = 6.0;
double b = 4.0; double b = 4.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
vector1.fill(a); vector1.fill(a);
vector1 /= b; vector1 /= b;
ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_Division_AssignmentVector) { TEST(PIMathVectorT_Test, operator_Division_AssignmentVector) {
double a = 6.0; double a = 6.0;
double b = 1.5; double b = 1.5;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
vector1 /= vector2; vector1 /= vector2;
ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1, a / b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_Addition) { TEST(PIMathVectorT_Test, operator_Addition) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue(vector1 + vector2, a + b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1 + vector2, a + b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_Subtraction) { TEST(PIMathVectorT_Test, operator_Subtraction) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue(vector1 - vector2, a - b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1 - vector2, a - b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_MultiplicationValue) { TEST(PIMathVectorT_Test, operator_MultiplicationValue) {
double a = 6.0; double a = 6.0;
double b = 4.0; double b = 4.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1.fill(a); vector1.fill(a);
ASSERT_TRUE(cmpVectorWithValue(vector1 * b, a * b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1 * b, a * b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_MultiplicationVector1) { TEST(PIMathVectorT_Test, operator_MultiplicationVector1) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue((vector1 * vector2), 0.0, SIZE)); ASSERT_TRUE(cmpVectorWithValue((vector1 * vector2), 0.0, SIZE));
} }
TEST(PIMathVectorT_Test, operator_MultiplicationVector2) { TEST(PIMathVectorT_Test, operator_MultiplicationVector2) {
double a = 1.0; double a = 1.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1[0] = a; vector1[0] = a;
vector2[1] = 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))); 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) { TEST(PIMathVectorT_Test, operator_DivisionVal) {
double a = 6.0; double a = 6.0;
double b = 4.0; double b = 4.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
vector1.fill(a); vector1.fill(a);
ASSERT_TRUE(cmpVectorWithValue(vector1 / b, a / b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1 / b, a / b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_DivisionVector) { TEST(PIMathVectorT_Test, operator_DivisionVector) {
double a = 6.0; double a = 6.0;
double b = 4.0; double b = 4.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE, double> vector2; PIMathVectorT<SIZE, double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue(vector1 / vector2, a / b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1 / vector2, a / b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_MultiplVect) { TEST(PIMathVectorT_Test, operator_MultiplVect) {
double a = 6.0; double a = 6.0;
double b = 5.0; double b = 5.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(cmpVectorWithValue(vector1 & vector2, a * b, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector1 & vector2, a * b, SIZE));
} }
TEST(PIMathVectorT_Test, operator_absDotProduct) { TEST(PIMathVectorT_Test, operator_absDotProduct) {
double a = 6.0; double a = 6.0;
double b = 5.0; double b = 5.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_DOUBLE_EQ(vector1 ^ vector2, SIZE * a * b); ASSERT_DOUBLE_EQ(vector1 ^ vector2, SIZE * a * b);
} }
TEST(PIMathVectorT_Test, transposed) { TEST(PIMathVectorT_Test, transposed) {
double a = 6.0; double a = 6.0;
PIMathVectorT<SIZE, double> vector; PIMathVectorT<SIZE, double> vector;
vector.fill(a); vector.fill(a);
auto matrix = vector.transposed(); auto matrix = vector.transposed();
for(int i = 0; i < SIZE; i++){ for(int i = 0; i < SIZE; i++){
if(matrix[0][i] != a) if(matrix[0][i] != a)
{ {
ASSERT_TRUE(false); ASSERT_TRUE(false);
} }
} }
ASSERT_TRUE(true); ASSERT_TRUE(true);
} }
TEST(PIMathVectorT_Test, filled) { TEST(PIMathVectorT_Test, filled) {
double a = 6.0; double a = 6.0;
auto vector = PIMathVectorT<SIZE, double>::filled(a); auto vector = PIMathVectorT<SIZE, double>::filled(a);
ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE)); ASSERT_TRUE(cmpVectorWithValue(vector, a, SIZE));
} }
TEST(PIMathVectorT_Test, turnTo) { TEST(PIMathVectorT_Test, turnTo) {
double a = 6.0; double a = 6.0;
PIMathVectorT<SIZE, double> vect; PIMathVectorT<SIZE, double> vect;
vect.fill(a); vect.fill(a);
auto vector = vect.turnTo<2u, double>(); auto vector = vect.turnTo<2u, double>();
ASSERT_TRUE(vector.size() == 2); ASSERT_TRUE(vector.size() == 2);
} }
TEST(PIMathVectorT_Test, LogicalOrTrue) { TEST(PIMathVectorT_Test, LogicalOrTrue) {
double a = 6.0; double a = 6.0;
double b = 1.72; double b = 1.72;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1.fill(a); vector1.fill(a);
vector2.fill(b); vector2.fill(b);
ASSERT_TRUE(vector1 || vector2); ASSERT_TRUE(vector1 || vector2);
} }
TEST(PIMathVectorT_Test, LogicalOrFalse) { TEST(PIMathVectorT_Test, LogicalOrFalse) {
double a = 1.0; double a = 1.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
PIMathVectorT<SIZE,double> vector2; PIMathVectorT<SIZE,double> vector2;
vector1[0] = a; vector1[0] = a;
vector2[1] = a; vector2[1] = a;
ASSERT_FALSE(vector1 || vector2); ASSERT_FALSE(vector1 || vector2);
} }
TEST(PIMathVectorT_Test, sqrt) { TEST(PIMathVectorT_Test, sqrt) {
double a = 36.0; double a = 36.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
vector1.fill(a); vector1.fill(a);
ASSERT_TRUE(cmpVectorWithValue(sqrt(vector1), sqrt(a), SIZE)); ASSERT_TRUE(cmpVectorWithValue(sqrt(vector1), sqrt(a), SIZE));
} }
TEST(PIMathVectorT_Test, sqr) { TEST(PIMathVectorT_Test, sqr) {
double a = 6.0; double a = 6.0;
PIMathVectorT<SIZE, double> vector1; PIMathVectorT<SIZE, double> vector1;
vector1.fill(a); vector1.fill(a);
ASSERT_TRUE(cmpVectorWithValue(sqr(vector1), sqr(a), SIZE)); ASSERT_TRUE(cmpVectorWithValue(sqr(vector1), sqr(a), SIZE));
} }