|
@@ -170,4 +170,221 @@ TEST(MatrixTest, Transposing_this_identity_matrix)
|
|
|
Matrix ident = Matrix4().identity();
|
|
|
|
|
|
ASSERT_EQ(ident.transpose(), ident);
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, Calculating_the_determinant_of_a_2x2_matrix)
|
|
|
+{
|
|
|
+ double valuesA[] = { 1, 5,
|
|
|
+ -3, 2 };
|
|
|
+ Matrix2 A = Matrix2(valuesA);
|
|
|
+
|
|
|
+ ASSERT_EQ(A.determinant(), 17);
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, A_submatrix_of_a_3x3_matrix_is_a_2x2_matrix)
|
|
|
+{
|
|
|
+ double valuesA[] = { 1, 5, 0,
|
|
|
+ -3, 2, 7,
|
|
|
+ 0, 6, -3 };
|
|
|
+ double results[] = { -3, 2,
|
|
|
+ 0, 6 };
|
|
|
+ Matrix3 A = Matrix3(valuesA);
|
|
|
+
|
|
|
+ ASSERT_EQ(A.submatrix(0, 2), Matrix2(results));
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, A_submatrix_of_a_4x4_matrix_is_a_3x3_matrix)
|
|
|
+{
|
|
|
+ double valuesA[] = { -6, 1, 1, 6,
|
|
|
+ -8, 5, 8, 6,
|
|
|
+ -1, 0, 8, 2,
|
|
|
+ -7, 1, -1, 1 };
|
|
|
+ double results[] = { -6, 1, 6,
|
|
|
+ -8, 8, 6,
|
|
|
+ -7,-1, 1 };
|
|
|
+ Matrix4 A = Matrix4(valuesA);
|
|
|
+
|
|
|
+ ASSERT_EQ(A.submatrix(2, 1), Matrix3(results));
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, Calculate_a_minor_of_a_3x3_matrix)
|
|
|
+{
|
|
|
+ double valuesA[] = { 3, 5, 0,
|
|
|
+ 2, -1, -7,
|
|
|
+ 6, -1, 5 };
|
|
|
+
|
|
|
+ Matrix3 A = Matrix3(valuesA);
|
|
|
+
|
|
|
+ Matrix B = A.submatrix(1, 0);
|
|
|
+
|
|
|
+ ASSERT_EQ(B.determinant(), 25);
|
|
|
+ ASSERT_EQ(A.minor(1, 0), 25);
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, Calculating_a_cofactor_of_a_3x3_matrix)
|
|
|
+{
|
|
|
+ double valuesA[] = { 3, 5, 0,
|
|
|
+ 2, -1, -7,
|
|
|
+ 6, -1, 5 };
|
|
|
+
|
|
|
+ Matrix3 A = Matrix3(valuesA);
|
|
|
+
|
|
|
+ ASSERT_EQ(A.minor(0, 0), -12);
|
|
|
+ ASSERT_EQ(A.cofactor(0, 0), -12);
|
|
|
+ ASSERT_EQ(A.minor(1, 0), 25);
|
|
|
+ ASSERT_EQ(A.cofactor(1, 0), -25);
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, Calculating_the_determinant_of_a_3x3_matrix)
|
|
|
+{
|
|
|
+ double valuesA[] = { 1, 2, 6,
|
|
|
+ -5, 8, -4,
|
|
|
+ 2, 6, 4 };
|
|
|
+
|
|
|
+ Matrix A = Matrix3(valuesA);
|
|
|
+
|
|
|
+ ASSERT_EQ(A.cofactor(0, 0), 56);
|
|
|
+ ASSERT_EQ(A.cofactor(0, 1), 12);
|
|
|
+ ASSERT_EQ(A.minor(0, 2), -46);
|
|
|
+ ASSERT_EQ(A.determinant(), -196);
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, Calculating_the_determinant_of_a_4x4_matrix)
|
|
|
+{
|
|
|
+ double valuesA[] = { -2, -8, 3, 5,
|
|
|
+ -3, 1, 7, 3,
|
|
|
+ 1, 2, -9, 6,
|
|
|
+ -6, 7, 7, -9 };
|
|
|
+
|
|
|
+ Matrix A = Matrix4(valuesA);
|
|
|
+
|
|
|
+ ASSERT_EQ(A.cofactor(0, 0), 690);
|
|
|
+ ASSERT_EQ(A.cofactor(0, 1), 447);
|
|
|
+ ASSERT_EQ(A.cofactor(0, 2), 210);
|
|
|
+ ASSERT_EQ(A.minor(0, 3), -51);
|
|
|
+ ASSERT_EQ(A.determinant(), -4071);
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, Testing_an_invertible_matrix_for_invertibility)
|
|
|
+{
|
|
|
+ double valuesA[] = { 6, 4, 4, 4,
|
|
|
+ 5, 5, 7, 6,
|
|
|
+ 4, -9, 3, -7,
|
|
|
+ 9, 1, 7, -6 };
|
|
|
+ Matrix A = Matrix4(valuesA);
|
|
|
+
|
|
|
+ ASSERT_EQ(A.determinant(), -2120);
|
|
|
+ ASSERT_TRUE(A.isInvertible());
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, Testing_an_noninvertible_matrix_for_invertibility)
|
|
|
+{
|
|
|
+ double valuesA[] = { -4, 2, -2, -3,
|
|
|
+ 9, 6, 2, 6,
|
|
|
+ 0, -5, 1, -5,
|
|
|
+ 0, 0, 0, 0 };
|
|
|
+ Matrix A = Matrix4(valuesA);
|
|
|
+
|
|
|
+ ASSERT_EQ(A.determinant(), 0);
|
|
|
+ ASSERT_FALSE(A.isInvertible());
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, Calculating_the_inverse_of_a_matrix)
|
|
|
+{
|
|
|
+ double valuesA[] = { -5, 2, 6, -8,
|
|
|
+ 1, -5, 1, 8,
|
|
|
+ 7, 7, -6, -7,
|
|
|
+ 1, -3, 7, 4 };
|
|
|
+
|
|
|
+ double results[] = { 0.21805, 0.45113, 0.24060, -0.04511,
|
|
|
+ -0.80827, -1.45677, -0.44361, 0.52068,
|
|
|
+ -0.07895, -0.22368, -0.05263, 0.19737,
|
|
|
+ -0.52256, -0.81391, -0.30075, 0.30639 };
|
|
|
+
|
|
|
+ Matrix A = Matrix4(valuesA);
|
|
|
+ Matrix B = A.inverse();
|
|
|
+
|
|
|
+ ASSERT_EQ(A.determinant(), 532);
|
|
|
+ ASSERT_EQ(A.cofactor(2, 3), -160);
|
|
|
+ ASSERT_NEAR(B.get(3, 2), -160./532., DBL_EPSILON);
|
|
|
+ ASSERT_EQ(A.cofactor(3, 2), 105);
|
|
|
+ ASSERT_NEAR(B.get(2, 3), 105./532., DBL_EPSILON);
|
|
|
+
|
|
|
+ /* Temporary lower the precision */
|
|
|
+ set_equal_precision(0.00001);
|
|
|
+
|
|
|
+ ASSERT_EQ(B, Matrix4(results));
|
|
|
+
|
|
|
+ /* Revert to default */
|
|
|
+ set_equal_precision(FLT_EPSILON);
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, Calculating_the_inverse_of_another_matrix)
|
|
|
+{
|
|
|
+ double valuesA[] = { 8, -5, 9, 2,
|
|
|
+ 7, 5, 6, 1,
|
|
|
+ -6, 0, 9, 6,
|
|
|
+ -3, 0, -9, -4 };
|
|
|
+
|
|
|
+ double results[] = { -0.15385, -0.15385, -0.28205, -0.53846,
|
|
|
+ -0.07692, 0.12308, 0.02564, 0.03077,
|
|
|
+ 0.35897, 0.35897, 0.43590, 0.92308,
|
|
|
+ -0.69231, -0.69231, -0.76923, -1.92308 };
|
|
|
+
|
|
|
+ Matrix A = Matrix4(valuesA);
|
|
|
+ Matrix B = A.inverse();
|
|
|
+
|
|
|
+
|
|
|
+ /* Temporary lower the precision */
|
|
|
+ set_equal_precision(0.00001);
|
|
|
+
|
|
|
+ ASSERT_EQ(B, Matrix4(results));
|
|
|
+
|
|
|
+ /* Revert to default */
|
|
|
+ set_equal_precision(FLT_EPSILON);
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, Calculating_the_inverse_of_third_matrix)
|
|
|
+{
|
|
|
+ double valuesA[] = { 9, 3, 0, 9,
|
|
|
+ -5, -2, -6, -3,
|
|
|
+ -4, 9, 6, 4,
|
|
|
+ -7, 6, 6, 2 };
|
|
|
+
|
|
|
+ double results[] = { -0.04074, -0.07778, 0.14444, -0.22222,
|
|
|
+ -0.07778, 0.03333, 0.36667, -0.33333,
|
|
|
+ -0.02901, -0.14630, -0.10926, 0.12963,
|
|
|
+ 0.17778, 0.06667, -0.26667, 0.33333 };
|
|
|
+
|
|
|
+ Matrix A = Matrix4(valuesA);
|
|
|
+ Matrix B = A.inverse();
|
|
|
+
|
|
|
+
|
|
|
+ /* Temporary lower the precision */
|
|
|
+ set_equal_precision(0.00001);
|
|
|
+
|
|
|
+ ASSERT_EQ(B, Matrix4(results));
|
|
|
+
|
|
|
+ /* Revert to default */
|
|
|
+ set_equal_precision(FLT_EPSILON);
|
|
|
+}
|
|
|
+
|
|
|
+TEST(MatrixTest, Multiplying_a_product_by_its_inverse)
|
|
|
+{
|
|
|
+ double valuesA[] = { 3, -9, 7, 3,
|
|
|
+ 3, -8, 2, -9,
|
|
|
+ -4, 4, 4, 1,
|
|
|
+ -6, 5, -1, 1 };
|
|
|
+
|
|
|
+ double valuesB[] = { 8, 2, 2, 2,
|
|
|
+ 3, -1, 7, 0,
|
|
|
+ 7, 0, 5, 4,
|
|
|
+ 6, -2, 0, 5 };
|
|
|
+
|
|
|
+ Matrix A = Matrix4(valuesA);
|
|
|
+ Matrix B = Matrix4(valuesB);
|
|
|
+
|
|
|
+ Matrix C = A * B;
|
|
|
+
|
|
|
+ ASSERT_EQ(C * B.inverse(), A);
|
|
|
}
|