matrix_test.cpp 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407
  1. /*
  2. * DoRayMe - a quick and dirty Raytracer
  3. * Matrix unit tests
  4. *
  5. * Created by Manoël Trapier
  6. * Copyright (c) 2020 986-Studio.
  7. *
  8. */
  9. #include <matrix.h>
  10. #include <tuple.h>
  11. #include <math.h>
  12. #include <gtest/gtest.h>
  13. TEST(MatrixTest, Constructing_and_inspecting_a_4x4_Matrix)
  14. {
  15. double values[] = {1, 2, 3, 4,
  16. 5.5, 6.5, 7.5, 8.5,
  17. 9, 10, 11, 12,
  18. 13.5, 14.5, 15.5, 16.5};
  19. Matrix4 m = Matrix4(values);
  20. ASSERT_EQ(m.get(0, 0), 1);
  21. ASSERT_EQ(m.get(0, 3), 4);
  22. ASSERT_EQ(m.get(1, 0), 5.5);
  23. ASSERT_EQ(m.get(1, 2), 7.5);
  24. ASSERT_EQ(m.get(2, 2), 11);
  25. ASSERT_EQ(m.get(3, 0), 13.5);
  26. ASSERT_EQ(m.get(3, 2), 15.5);
  27. }
  28. TEST(MatrixTest, Change_a_single_value_and_check_it)
  29. {
  30. double values[] = {-3, 5,
  31. 1, -2};
  32. Matrix2 m = Matrix2(values);
  33. ASSERT_EQ(m.get(0, 0), -3);
  34. ASSERT_EQ(m.get(0, 1), 5);
  35. ASSERT_EQ(m.get(1, 0), 1);
  36. ASSERT_EQ(m.get(1, 1), -2);
  37. m.set(0, 0, 12);
  38. ASSERT_EQ(m.get(0, 0), 12);
  39. }
  40. TEST(MatrixTest, A_3x3_matrix_ought_to_be_representable)
  41. {
  42. double values[] = {-3, 5, 0,
  43. 1, -2, -7,
  44. 0, 1, 1};
  45. Matrix3 m = Matrix3(values);
  46. ASSERT_EQ(m.get(0, 0), -3);
  47. ASSERT_EQ(m.get(1, 1), -2);
  48. ASSERT_EQ(m.get(2, 2), 1);
  49. }
  50. TEST(MatrixTest, A_2x2_matrix_ought_to_be_representable)
  51. {
  52. double values[] = {-3, 5,
  53. 1, -2};
  54. Matrix2 m = Matrix2(values);
  55. ASSERT_EQ(m.get(0, 0), -3);
  56. ASSERT_EQ(m.get(0, 1), 5);
  57. ASSERT_EQ(m.get(1, 0), 1);
  58. ASSERT_EQ(m.get(1, 1), -2);
  59. }
  60. TEST(MatrixTest, Matrix_equality_with_identical_matrix)
  61. {
  62. double values1[] = {1, 2, 3, 4,
  63. 5, 6, 7, 8,
  64. 9, 8, 7, 6,
  65. 5, 4, 3, 2};
  66. double values2[] = {1, 2, 3, 4,
  67. 5, 6, 7, 8,
  68. 9, 8, 7, 6,
  69. 5, 4, 3, 2};
  70. Matrix4 A = Matrix4(values1);
  71. Matrix4 B = Matrix4(values2);
  72. ASSERT_EQ(A, B);
  73. }
  74. TEST(MatrixTest, Matrix_equality_with_different_matrix)
  75. {
  76. double values1[] = {1, 2, 3, 4,
  77. 5, 6, 7, 8,
  78. 9, 8, 7, 6,
  79. 5, 4, 3, 2};
  80. double values2[] = {2, 3, 4, 5,
  81. 6, 7, 8, 9,
  82. 8, 7, 6, 5,
  83. 4, 3, 2, 1};
  84. Matrix4 A = Matrix4(values1);
  85. Matrix4 B = Matrix4(values2);
  86. ASSERT_NE(A, B);
  87. }
  88. TEST(MatrixTest, Multiplying_two_matrices)
  89. {
  90. double values1[] = {1, 2, 3, 4,
  91. 5, 6, 7, 8,
  92. 9, 8, 7, 6,
  93. 5, 4, 3, 2};
  94. double values2[] = {-2, 1, 2, 3,
  95. 3, 2, 1, -1,
  96. 4, 3, 6, 5,
  97. 1, 2, 7, 8};
  98. double results[] = {20, 22, 50, 48,
  99. 44, 54, 114, 108,
  100. 40, 58, 110, 102,
  101. 16, 26, 46, 42};
  102. Matrix4 A = Matrix4(values1);
  103. Matrix4 B = Matrix4(values2);
  104. ASSERT_EQ(A * B, Matrix4(results));
  105. }
  106. TEST(MatrixTest, A_matrix_multiplyed_by_a_tuple)
  107. {
  108. double valuesA[] = {1, 2, 3, 4,
  109. 2, 4, 4, 2,
  110. 8, 6, 4, 1,
  111. 0, 0, 0, 1};
  112. Matrix4 A = Matrix4(valuesA);
  113. Tuple b = Tuple(1, 2, 3, 1);
  114. ASSERT_EQ(A * b, Tuple(18, 24, 33, 1));
  115. }
  116. TEST(MatrixTest, Multiplying_a_matrix_by_the_identity_matrix)
  117. {
  118. double valuesA[] = {0, 1, 2, 4,
  119. 1, 2, 4, 8,
  120. 2, 4, 8, 16,
  121. 4, 8, 16, 32};
  122. Matrix4 A = Matrix4(valuesA);
  123. Matrix ident = Matrix4().identity();
  124. ASSERT_EQ(A * ident, A);
  125. }
  126. TEST(MatrixTest, Multiplying_the_identity_matrix_by_a_tuple)
  127. {
  128. Tuple a = Tuple(1, 2, 3, 4);
  129. Matrix ident = Matrix4().identity();
  130. ASSERT_EQ(ident * a, a);
  131. }
  132. TEST(MatrixTest, Transposing_a_matrix)
  133. {
  134. double valuesA[] = {0, 9, 3, 0,
  135. 9, 8, 0, 8,
  136. 1, 8, 5, 3,
  137. 0, 0, 5, 8};
  138. double results[] = {0, 9, 1, 0,
  139. 9, 8, 8, 0,
  140. 3, 0, 5, 5,
  141. 0, 8, 3, 8};
  142. Matrix A = Matrix4(valuesA);
  143. ASSERT_EQ(A.transpose(), Matrix4(results));
  144. }
  145. TEST(MatrixTest, Transposing_this_identity_matrix)
  146. {
  147. Matrix ident = Matrix4().identity();
  148. ASSERT_EQ(ident.transpose(), ident);
  149. }
  150. TEST(MatrixTest, Calculating_the_determinant_of_a_2x2_matrix)
  151. {
  152. double valuesA[] = { 1, 5,
  153. -3, 2 };
  154. Matrix2 A = Matrix2(valuesA);
  155. ASSERT_EQ(A.determinant(), 17);
  156. }
  157. TEST(MatrixTest, A_submatrix_of_a_3x3_matrix_is_a_2x2_matrix)
  158. {
  159. double valuesA[] = { 1, 5, 0,
  160. -3, 2, 7,
  161. 0, 6, -3 };
  162. double results[] = { -3, 2,
  163. 0, 6 };
  164. Matrix3 A = Matrix3(valuesA);
  165. ASSERT_EQ(A.submatrix(0, 2), Matrix2(results));
  166. }
  167. TEST(MatrixTest, A_submatrix_of_a_4x4_matrix_is_a_3x3_matrix)
  168. {
  169. double valuesA[] = { -6, 1, 1, 6,
  170. -8, 5, 8, 6,
  171. -1, 0, 8, 2,
  172. -7, 1, -1, 1 };
  173. double results[] = { -6, 1, 6,
  174. -8, 8, 6,
  175. -7,-1, 1 };
  176. Matrix4 A = Matrix4(valuesA);
  177. ASSERT_EQ(A.submatrix(2, 1), Matrix3(results));
  178. }
  179. TEST(MatrixTest, Calculate_a_minor_of_a_3x3_matrix)
  180. {
  181. double valuesA[] = { 3, 5, 0,
  182. 2, -1, -7,
  183. 6, -1, 5 };
  184. Matrix3 A = Matrix3(valuesA);
  185. Matrix B = A.submatrix(1, 0);
  186. ASSERT_EQ(B.determinant(), 25);
  187. ASSERT_EQ(A.minor(1, 0), 25);
  188. }
  189. TEST(MatrixTest, Calculating_a_cofactor_of_a_3x3_matrix)
  190. {
  191. double valuesA[] = { 3, 5, 0,
  192. 2, -1, -7,
  193. 6, -1, 5 };
  194. Matrix3 A = Matrix3(valuesA);
  195. ASSERT_EQ(A.minor(0, 0), -12);
  196. ASSERT_EQ(A.cofactor(0, 0), -12);
  197. ASSERT_EQ(A.minor(1, 0), 25);
  198. ASSERT_EQ(A.cofactor(1, 0), -25);
  199. }
  200. TEST(MatrixTest, Calculating_the_determinant_of_a_3x3_matrix)
  201. {
  202. double valuesA[] = { 1, 2, 6,
  203. -5, 8, -4,
  204. 2, 6, 4 };
  205. Matrix A = Matrix3(valuesA);
  206. ASSERT_EQ(A.cofactor(0, 0), 56);
  207. ASSERT_EQ(A.cofactor(0, 1), 12);
  208. ASSERT_EQ(A.minor(0, 2), -46);
  209. ASSERT_EQ(A.determinant(), -196);
  210. }
  211. TEST(MatrixTest, Calculating_the_determinant_of_a_4x4_matrix)
  212. {
  213. double valuesA[] = { -2, -8, 3, 5,
  214. -3, 1, 7, 3,
  215. 1, 2, -9, 6,
  216. -6, 7, 7, -9 };
  217. Matrix A = Matrix4(valuesA);
  218. ASSERT_EQ(A.cofactor(0, 0), 690);
  219. ASSERT_EQ(A.cofactor(0, 1), 447);
  220. ASSERT_EQ(A.cofactor(0, 2), 210);
  221. ASSERT_EQ(A.minor(0, 3), -51);
  222. ASSERT_EQ(A.determinant(), -4071);
  223. }
  224. TEST(MatrixTest, Testing_an_invertible_matrix_for_invertibility)
  225. {
  226. double valuesA[] = { 6, 4, 4, 4,
  227. 5, 5, 7, 6,
  228. 4, -9, 3, -7,
  229. 9, 1, 7, -6 };
  230. Matrix A = Matrix4(valuesA);
  231. ASSERT_EQ(A.determinant(), -2120);
  232. ASSERT_TRUE(A.isInvertible());
  233. }
  234. TEST(MatrixTest, Testing_an_noninvertible_matrix_for_invertibility)
  235. {
  236. double valuesA[] = { -4, 2, -2, -3,
  237. 9, 6, 2, 6,
  238. 0, -5, 1, -5,
  239. 0, 0, 0, 0 };
  240. Matrix A = Matrix4(valuesA);
  241. ASSERT_EQ(A.determinant(), 0);
  242. ASSERT_FALSE(A.isInvertible());
  243. }
  244. TEST(MatrixTest, Calculating_the_inverse_of_a_matrix)
  245. {
  246. double valuesA[] = { -5, 2, 6, -8,
  247. 1, -5, 1, 8,
  248. 7, 7, -6, -7,
  249. 1, -3, 7, 4 };
  250. double results[] = { 0.21805, 0.45113, 0.24060, -0.04511,
  251. -0.80827, -1.45677, -0.44361, 0.52068,
  252. -0.07895, -0.22368, -0.05263, 0.19737,
  253. -0.52256, -0.81391, -0.30075, 0.30639 };
  254. Matrix A = Matrix4(valuesA);
  255. Matrix B = A.inverse();
  256. ASSERT_EQ(A.determinant(), 532);
  257. ASSERT_EQ(A.cofactor(2, 3), -160);
  258. ASSERT_NEAR(B.get(3, 2), -160./532., DBL_EPSILON);
  259. ASSERT_EQ(A.cofactor(3, 2), 105);
  260. ASSERT_NEAR(B.get(2, 3), 105./532., DBL_EPSILON);
  261. /* Temporary lower the precision */
  262. set_equal_precision(0.00001);
  263. ASSERT_EQ(B, Matrix4(results));
  264. /* Revert to default */
  265. set_equal_precision(FLT_EPSILON);
  266. }
  267. TEST(MatrixTest, Calculating_the_inverse_of_another_matrix)
  268. {
  269. double valuesA[] = { 8, -5, 9, 2,
  270. 7, 5, 6, 1,
  271. -6, 0, 9, 6,
  272. -3, 0, -9, -4 };
  273. double results[] = { -0.15385, -0.15385, -0.28205, -0.53846,
  274. -0.07692, 0.12308, 0.02564, 0.03077,
  275. 0.35897, 0.35897, 0.43590, 0.92308,
  276. -0.69231, -0.69231, -0.76923, -1.92308 };
  277. Matrix A = Matrix4(valuesA);
  278. Matrix B = A.inverse();
  279. /* Temporary lower the precision */
  280. set_equal_precision(0.00001);
  281. ASSERT_EQ(B, Matrix4(results));
  282. /* Revert to default */
  283. set_equal_precision(FLT_EPSILON);
  284. }
  285. TEST(MatrixTest, Calculating_the_inverse_of_third_matrix)
  286. {
  287. double valuesA[] = { 9, 3, 0, 9,
  288. -5, -2, -6, -3,
  289. -4, 9, 6, 4,
  290. -7, 6, 6, 2 };
  291. double results[] = { -0.04074, -0.07778, 0.14444, -0.22222,
  292. -0.07778, 0.03333, 0.36667, -0.33333,
  293. -0.02901, -0.14630, -0.10926, 0.12963,
  294. 0.17778, 0.06667, -0.26667, 0.33333 };
  295. Matrix A = Matrix4(valuesA);
  296. Matrix B = A.inverse();
  297. /* Temporary lower the precision */
  298. set_equal_precision(0.00001);
  299. ASSERT_EQ(B, Matrix4(results));
  300. /* Revert to default */
  301. set_equal_precision(FLT_EPSILON);
  302. }
  303. TEST(MatrixTest, Multiplying_a_product_by_its_inverse)
  304. {
  305. double valuesA[] = { 3, -9, 7, 3,
  306. 3, -8, 2, -9,
  307. -4, 4, 4, 1,
  308. -6, 5, -1, 1 };
  309. double valuesB[] = { 8, 2, 2, 2,
  310. 3, -1, 7, 0,
  311. 7, 0, 5, 4,
  312. 6, -2, 0, 5 };
  313. Matrix A = Matrix4(valuesA);
  314. Matrix B = Matrix4(valuesB);
  315. Matrix C = A * B;
  316. ASSERT_EQ(C * B.inverse(), A);
  317. }