215 lines
6.2 KiB
C++
215 lines
6.2 KiB
C++
#if GTEST
|
|
#include <gtest/gtest.h>
|
|
#include <math.h>
|
|
#include <limits>
|
|
|
|
#include "Matrix.h"
|
|
|
|
TEST(Matrix2, Zero) {
|
|
// Test case 1: 2x2 zero matrix
|
|
Matrix2 zeroMatrix = Matrix2::Zero(2, 2);
|
|
EXPECT_TRUE(zeroMatrix.nRows == 2);
|
|
EXPECT_TRUE(zeroMatrix.nCols == 2);
|
|
for (int i = 0; i < zeroMatrix.nValues; ++i) {
|
|
EXPECT_TRUE(zeroMatrix.data[i] == 0.0f);
|
|
}
|
|
std::cout << "Test case 1 passed: 2x2 zero matrix\n";
|
|
|
|
// Test case 2: 3x3 zero matrix
|
|
zeroMatrix = Matrix2::Zero(3, 3);
|
|
EXPECT_TRUE(zeroMatrix.nRows == 3);
|
|
EXPECT_TRUE(zeroMatrix.nCols == 3);
|
|
for (int i = 0; i < zeroMatrix.nValues; ++i) {
|
|
EXPECT_TRUE(zeroMatrix.data[i] == 0.0f);
|
|
}
|
|
std::cout << "Test case 2 passed: 3x3 zero matrix\n";
|
|
|
|
// Test case 3: 1x1 zero matrix
|
|
zeroMatrix = Matrix2::Zero(1, 1);
|
|
EXPECT_TRUE(zeroMatrix.nRows == 1);
|
|
EXPECT_TRUE(zeroMatrix.nCols == 1);
|
|
EXPECT_TRUE(zeroMatrix.data[0] == 0.0f);
|
|
std::cout << "Test case 3 passed: 1x1 zero matrix\n";
|
|
|
|
// Test case 4: 0x0 matrix (edge case)
|
|
zeroMatrix = Matrix2::Zero(0, 0);
|
|
EXPECT_TRUE(zeroMatrix.nRows == 0);
|
|
EXPECT_TRUE(zeroMatrix.nCols == 0);
|
|
EXPECT_TRUE(zeroMatrix.data == nullptr);
|
|
std::cout << "Test case 4 passed: 0x0 matrix\n";
|
|
}
|
|
|
|
TEST(Matrix2, Multiplication) {
|
|
// Test 1: Multiplying two 2x2 matrices
|
|
float dataA[] = {1, 2, 3, 4};
|
|
float dataB[] = {5, 6, 7, 8};
|
|
Matrix2 A(dataA, 2, 2);
|
|
Matrix2 B(dataB, 2, 2);
|
|
|
|
Matrix2 result = A * B;
|
|
|
|
float expectedData[] = {19, 22, 43, 50};
|
|
for (int i = 0; i < 4; ++i)
|
|
EXPECT_TRUE(result.data[i] == expectedData[i]);
|
|
std::cout << "Test 1 passed: 2x2 matrix multiplication.\n";
|
|
|
|
|
|
// Test 2: Multiplying a 3x2 matrix with a 2x3 matrix
|
|
float dataC[] = {1, 2, 3, 4, 5, 6};
|
|
float dataD[] = {7, 8, 9, 10, 11, 12};
|
|
Matrix2 C(dataC, 3, 2);
|
|
Matrix2 D(dataD, 2, 3);
|
|
|
|
Matrix2 result2 = C * D;
|
|
|
|
float expectedData2[] = {27, 30, 33, 61, 68, 75, 95, 106, 117};
|
|
for (int i = 0; i < 9; ++i)
|
|
EXPECT_TRUE(result2.data[i] == expectedData2[i]);
|
|
std::cout << "Test 2 passed: 3x2 * 2x3 matrix multiplication.\n";
|
|
|
|
// Test 3: Multiplying with a zero matrix
|
|
Matrix2 zeroMatrix = Matrix2::Zero(2, 2);
|
|
Matrix2 result3 = A * zeroMatrix;
|
|
|
|
for (int i = 0; i < 4; ++i)
|
|
EXPECT_TRUE(result3.data[i] == 0);
|
|
std::cout << "Test 3 passed: Multiplication with zero matrix.\n";
|
|
|
|
// Test 4: Multiplying with an identity matrix
|
|
Matrix2 identityMatrix = Matrix2::Identity(2);
|
|
Matrix2 result4 = A * identityMatrix;
|
|
|
|
for (int i = 0; i < 4; ++i)
|
|
EXPECT_TRUE(result4.data[i] == A.data[i]);
|
|
std::cout << "Test 4 passed: Multiplication with identity matrix.\n";
|
|
|
|
}
|
|
|
|
TEST(MatrixSingle, Init) {
|
|
// zero
|
|
MatrixOf<float> m0 = MatrixOf<float>(0, 0);
|
|
|
|
// one
|
|
float data1[] = {1.0F};
|
|
MatrixOf<float> m1 = MatrixOf<float>(1, 1, data1);
|
|
|
|
// two
|
|
float data2[] = {1.0F, 2.0F, 3.0F, 4.0F};
|
|
MatrixOf<float> m2 = MatrixOf<float>(2, 2, data2);
|
|
|
|
// negative
|
|
// MatrixOf<float> m_1 = MatrixOf<float>(-1, -1);
|
|
// parameters are unsigned
|
|
}
|
|
|
|
TEST(MatrixSingle, Transpose) {
|
|
float data1[] = {1.0F};
|
|
MatrixOf<float> m = MatrixOf<float>(1, 1, data1);
|
|
|
|
MatrixOf<float> r = MatrixOf<float>(1, 1);
|
|
m.Transpose(&r);
|
|
|
|
// 2 x 2
|
|
|
|
float data3[] = {1.0F, 2.0F, 3.0F, 4.0F};
|
|
MatrixOf<float> m22 = MatrixOf<float>(2, 2, data3);
|
|
EXPECT_EQ(m22.RowCount(), 2);
|
|
EXPECT_EQ(m22.ColCount(), 2);
|
|
|
|
float data4[] = {0.0F, 0.0F, 0.0F, 0.0F};
|
|
MatrixOf<float> r22 = MatrixOf<float>(2, 2, data4);
|
|
EXPECT_EQ(r22.RowCount(), 2);
|
|
EXPECT_EQ(r22.ColCount(), 2);
|
|
|
|
m22.Transpose(&r22);
|
|
EXPECT_EQ(r22.RowCount(), 2);
|
|
EXPECT_EQ(r22.ColCount(), 2);
|
|
EXPECT_FLOAT_EQ(r22.Get(0, 0), 1.0F);
|
|
EXPECT_FLOAT_EQ(r22.Get(0, 1), 3.0F);
|
|
EXPECT_FLOAT_EQ(r22.Get(1, 0), 2.0F);
|
|
EXPECT_FLOAT_EQ(r22.Get(1, 1), 4.0F);
|
|
|
|
// 1 x 2
|
|
float data12[] = {1.0F, 2.0F};
|
|
MatrixOf<float> m12 = MatrixOf<float>(1, 2, data12);
|
|
EXPECT_EQ(m12.RowCount(), 1);
|
|
EXPECT_EQ(m12.ColCount(), 2);
|
|
|
|
float data21[] = {0.0F, 0.0F};
|
|
MatrixOf<float> r21 = MatrixOf<float>(2, 1, data21);
|
|
EXPECT_EQ(r21.RowCount(), 2);
|
|
EXPECT_EQ(r21.ColCount(), 1);
|
|
|
|
m12.Transpose(&r21);
|
|
EXPECT_EQ(r21.RowCount(), 2);
|
|
EXPECT_EQ(r21.ColCount(), 1);
|
|
EXPECT_FLOAT_EQ(r21.Get(0, 0), 1.0F);
|
|
EXPECT_FLOAT_EQ(r21.Get(1, 0), 2.0F);
|
|
|
|
// changing dimensions, same size is okay
|
|
MatrixOf<float> r12 = MatrixOf<float>(1, 2, data21);
|
|
EXPECT_EQ(r12.RowCount(), 1);
|
|
EXPECT_EQ(r12.ColCount(), 2);
|
|
|
|
m12.Transpose(&r12);
|
|
EXPECT_EQ(r12.RowCount(), 2);
|
|
EXPECT_EQ(r12.ColCount(), 1);
|
|
EXPECT_FLOAT_EQ(r12.Get(0, 0), 1.0F);
|
|
EXPECT_FLOAT_EQ(r12.Get(0, 1), 2.0F);
|
|
}
|
|
|
|
TEST(MatrixSingle, Multiply) {
|
|
float m12data[] = {1.0F, 2.0F};
|
|
MatrixOf<float> m12 = MatrixOf<float>(1, 2, m12data);
|
|
|
|
EXPECT_EQ(m12.RowCount(), 1);
|
|
EXPECT_EQ(m12.ColCount(), 2);
|
|
EXPECT_FLOAT_EQ(m12.Get(0, 0), 1.0F);
|
|
EXPECT_FLOAT_EQ(m12.Get(0, 1), 2.0F);
|
|
|
|
float m21data[] = {3.0F, 4.0F};
|
|
MatrixOf<float> m21 = MatrixOf<float>(2, 1, m21data);
|
|
|
|
EXPECT_EQ(m21.RowCount(), 2);
|
|
EXPECT_EQ(m21.ColCount(), 1);
|
|
EXPECT_FLOAT_EQ(m21.Get(0, 0), 3.0F);
|
|
EXPECT_FLOAT_EQ(m21.Get(1, 0), 4.0F);
|
|
|
|
float r11data[] = {0.0F};
|
|
MatrixOf<float> r11 = MatrixOf<float>(1, 1, r11data);
|
|
|
|
EXPECT_EQ(r11.RowCount(), 1);
|
|
EXPECT_EQ(r11.ColCount(), 1);
|
|
|
|
MatrixOf<float>::Multiply(&m12, &m21, &r11);
|
|
EXPECT_EQ(r11.RowCount(), 1);
|
|
EXPECT_EQ(r11.ColCount(), 1);
|
|
EXPECT_FLOAT_EQ(r11.Get(0, 0), 11.0F);
|
|
|
|
float r22data[] = {0.0F, 0.0F, 0.0F, 0.0F};
|
|
MatrixOf<float> r22 = MatrixOf<float>(2, 2, r22data);
|
|
|
|
MatrixOf<float>::Multiply(&m21, &m12, &r22);
|
|
EXPECT_EQ(r22.RowCount(), 2);
|
|
EXPECT_EQ(r22.ColCount(), 2);
|
|
EXPECT_FLOAT_EQ(r22.Get(0, 0), 3.0F);
|
|
EXPECT_FLOAT_EQ(r22.Get(0, 1), 4.0F);
|
|
EXPECT_FLOAT_EQ(r22.Get(1, 0), 6.0F);
|
|
EXPECT_FLOAT_EQ(r22.Get(1, 1), 8.0F);
|
|
}
|
|
|
|
TEST(MatrixSingle, Multiply_Vector3) {
|
|
Vector3 v = Vector3(1.0, 2.0, 3.0);
|
|
Vector3 r = Vector3::zero;
|
|
|
|
// float m13data[] = {3.0, 4.0, 5.0};
|
|
// MatrixOf<float> m13 = MatrixOf<float>(1, 3, m13data);
|
|
// Vector3 r = MatrixOf<float>::Multiply(&m13, v);
|
|
|
|
float m33data[] = {1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0};
|
|
MatrixOf<float> m33 = MatrixOf<float>(3, 3, m33data);
|
|
r = MatrixOf<float>::Multiply(&m33, v);
|
|
EXPECT_FLOAT_EQ(Vector3::Distance(r, Vector3(1.0f, 2.0f, 3.0f)), 0);
|
|
}
|
|
|
|
#endif |