add tests for mat2 and its call version

include/cglm/mat2.h

@@ -245,7 +245,7 @@ glm_mat2_inv(mat2 mat, mat2 dest) {
   float a = mat[0][0], b = mat[0][1],
         c = mat[1][0], d = mat[1][1];
 
-  det = 1.0f / (a * d - c * b);
+  det = 1.0f / (a * d - b * c);
 
   dest[0][0] =  d * det;
   dest[0][1] = -b * det;

test/src/test_common.c

@@ -31,6 +31,14 @@ test_rand_mat3(mat3 dest) {
   glm_mat4_pick3(m4, dest);
 }
 
+void
+test_rand_mat2(mat2 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+}
+
 void
 test_rand_vec3(vec3 dest) {
   dest[0] = drand48();
@@ -73,12 +81,11 @@ test_rand_quat(versor q) {
 
 test_status_t
 test_assert_mat4_eq(mat4 m1, mat4 m2) {
-  int i, j, k;
+  int i, j;
 
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
-      for (k = 0; k < 4; k++)
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
-        ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
     }
   }
 
@@ -87,12 +94,11 @@ test_assert_mat4_eq(mat4 m1, mat4 m2) {
 
 test_status_t
 test_assert_mat4_eqt(mat4 m1, mat4 m2) {
-  int i, j, k;
+  int i, j;
 
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
-      for (k = 0; k < 4; k++)
+      ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009)
-        ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009)
     }
   }
 
@@ -101,12 +107,67 @@ test_assert_mat4_eqt(mat4 m1, mat4 m2) {
 
 test_status_t
 test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps) {
-  int i, j, k;
+  int i, j;
 
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
-      for (k = 0; k < 4; k++)
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= eps);
-        ASSERT(fabsf(m1[i][j] - m2[i][j]) <= eps);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eqt(mat2 m1, mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq(mat2 m1, mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq_identity(mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      if (i == j) {
+        ASSERT(test_eq(m2[i][j], 1.0f))
+      } else {
+        ASSERT(test_eq(m2[i][j], 0.0f))
+      }
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+test_status_t
+test_assert_mat2_eq_zero(mat2 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m2[i][j], 0.0f))
     }
   }
 
@@ -115,12 +176,11 @@ test_assert_mat4_eq2(mat4 m1, mat4 m2, float eps) {
 
 test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2) {
-  int i, j, k;
+  int i, j;
 
   for (i = 0; i < 3; i++) {
     for (j = 0; j < 3; j++) {
-      for (k = 0; k < 3; k++)
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
-        ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009);
     }
   }
 
@@ -129,12 +189,11 @@ test_assert_mat3_eq(mat3 m1, mat3 m2) {
 
 test_status_t
 test_assert_mat3_eqt(mat3 m1, mat3 m2) {
-  int i, j, k;
+  int i, j;
 
   for (i = 0; i < 3; i++) {
     for (j = 0; j < 3; j++) {
-      for (k = 0; k < 3; k++)
+      ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
-        ASSERT(fabsf(m1[j][i] - m2[i][j]) <= 0.0000009);
     }
   }
 

test/src/test_common.h

@@ -16,6 +16,9 @@ test_rand_mat4(mat4 dest);
 void
 test_rand_mat3(mat3 dest);
 
+void
+test_rand_mat2(mat2 dest);
+
 test_status_t
 test_assert_eqf(float a, float b);
 
@@ -34,6 +37,18 @@ test_assert_mat4_eq_identity(mat4 m4);
 test_status_t
 test_assert_mat4_eq_zero(mat4 m4);
 
+test_status_t
+test_assert_mat2_eqt(mat2 m1, mat2 m2);
+
+test_status_t
+test_assert_mat2_eq(mat2 m1, mat2 m2);
+
+test_status_t
+test_assert_mat2_eq_identity(mat2 m2);
+
+test_status_t
+test_assert_mat2_eq_zero(mat2 m2);
+
 test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2);
 

test/src/test_mat2.h

@@ -0,0 +1,286 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+#define A_MATRIX2x2 {{1,2},{5,6}}
+
+#ifndef CGLM_TEST_MAT2_ONCE
+#define CGLM_TEST_MAT2_ONCE
+
+TEST_IMPL(MACRO_GLM_MAT2_IDENTITY_INIT) {
+  mat2 m = GLM_MAT2_IDENTITY_INIT;
+  
+  ASSERT(test_eq(m[0][0], 1.0f))
+  ASSERT(test_eq(m[0][1], 0.0f))
+  ASSERT(test_eq(m[1][0], 0.0f))
+  ASSERT(test_eq(m[1][1], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT2_ZERO_INIT) {  
+  mat2 m = GLM_MAT2_ZERO_INIT;
+  
+  ASSERT(test_eq(m[0][0], 0.0f))
+  ASSERT(test_eq(m[0][1], 0.0f))
+  ASSERT(test_eq(m[1][0], 0.0f))
+  ASSERT(test_eq(m[1][1], 0.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT2_IDENTITY) {
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[0][0], 1.0f))
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[0][1], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[1][0], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_IDENTITY[1][1], 1.0f))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(MACRO_GLM_MAT2_ZERO) {
+  ASSERT(test_eq(GLM_MAT2_ZERO[0][0], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_ZERO[0][1], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_ZERO[1][0], 0.0f))
+  ASSERT(test_eq(GLM_MAT2_ZERO[1][1], 0.0f))
+
+  TEST_SUCCESS
+}
+
+#endif /* CGLM_TEST_MAT2_ONCE */
+
+TEST_IMPL(GLM_PREFIX, mat2_copy) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+
+  GLM(mat2_copy)(m1, m2);
+
+  test_assert_mat2_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_identity) {
+  mat2 m1 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m3;
+
+  GLM(mat2_identity)(m3);
+
+  ASSERTIFY(test_assert_mat2_eq_identity(m1))
+  ASSERTIFY(test_assert_mat2_eq_identity(m2))
+  ASSERTIFY(test_assert_mat2_eq_identity(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_identity_array) {
+  int i, count;
+  mat2 matrices[4] = {
+    A_MATRIX2x2,
+    A_MATRIX2x2,
+    A_MATRIX2x2,
+    A_MATRIX2x2
+  };
+
+  count = 4;
+
+  GLM(mat2_identity_array)(matrices, count);
+
+  for (i = 0; i < count; i++) {
+    ASSERTIFY(test_assert_mat2_eq_identity(matrices[i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_zero) {
+  mat2 m1 = GLM_MAT2_ZERO_INIT;
+  mat2 m2 = GLM_MAT2_ZERO_INIT;
+  mat2 m3;
+
+  GLM(mat2_zero)(m3);
+
+  ASSERTIFY(test_assert_mat2_eq_zero(m1))
+  ASSERTIFY(test_assert_mat2_eq_zero(m2))
+  ASSERTIFY(test_assert_mat2_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_mul) {
+  mat2 m1 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m3;
+  mat2 m4 = GLM_MAT2_ZERO_INIT;
+  int  i, j, k;
+
+  /* test random matrices */
+  /* random matrices */
+  test_rand_mat2(m1);
+  test_rand_mat2(m2);
+
+  GLM(mat2_mul)(m1, m2, m3);
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      for (k = 0; k < 2; k++)
+        /* column-major */
+        m4[i][j] += m1[k][j] * m2[i][k];
+    }
+  }
+
+  ASSERTIFY(test_assert_mat2_eq(m3, m4))
+
+  /* test pre compiled */
+  GLM(mat2_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat2_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_transpose_to) {
+  mat2 mat = A_MATRIX2x2;
+  mat2 m1;
+
+  GLM(mat2_transpose_to)(mat, m1);
+
+  ASSERTIFY(test_assert_mat2_eqt(mat, m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_transpose) {
+  mat2 mat = A_MATRIX2x2;
+  mat2 m1;
+
+  GLM(mat2_copy)(mat, m1);
+  GLM(mat2_transpose)(m1);
+
+  ASSERTIFY(test_assert_mat2_eqt(mat, m1))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_mulv) {
+  vec2 res;
+  mat2 mat = A_MATRIX2x2;
+  vec2 v = {11.0f, 21.0f};
+  int  i;
+
+  GLM(mat2_mulv)(mat, v, res);
+
+  for (i = 0; i < 2; i++) {
+    ASSERT(test_eq(res[i], v[0] * mat[0][i] + v[1] * mat[1][i]))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_trace) {
+  mat2  mat = A_MATRIX2x2;
+  float trace;
+
+  trace = GLM(mat2_trace)(mat);
+
+  ASSERT(test_eq(trace, mat[0][0] + mat[1][1]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_scale) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = A_MATRIX2x2;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat2_scale)(m1, (float)scale);
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_det) {
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_inv) {
+  mat2 m1 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m2 = GLM_MAT2_IDENTITY_INIT;
+  mat2 m3;
+  int  i;
+
+  m1[0][0] = 41.0f;
+  m1[0][1] = 0.0f;
+  m1[1][0] = 0.0f;
+  m1[1][1] = 70.0f;
+
+  for (i = 0; i < 10000; i++) {
+    /* test inverse precise */
+    GLM(mat2_inv)(m1, m2);
+    GLM(mat2_inv)(m2, m3);
+    
+    ASSERTIFY(test_assert_mat2_eq(m1, m3))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_swap_col) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = A_MATRIX2x2;
+
+  GLM(mat2_swap_col)(m1, 0, 1);
+
+  ASSERTIFY(test_assert_vec2_eq(m1[0], m2[1]))
+  ASSERTIFY(test_assert_vec2_eq(m1[1], m2[0]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_swap_row) {
+  mat2 m1 = A_MATRIX2x2;
+  mat2 m2 = A_MATRIX2x2;
+
+  GLM(mat2_swap_row)(m1, 0, 1);
+
+  ASSERT(test_eq(m1[0][0], m2[0][1]))
+  ASSERT(test_eq(m1[0][1], m2[0][0]))
+
+  ASSERT(test_eq(m1[1][0], m2[1][1]))
+  ASSERT(test_eq(m1[1][1], m2[1][0]))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2_rmc) {
+  mat2  mat = A_MATRIX2x2;
+  vec2  v   = {11.0f, 12.0f};
+  vec2  v1;
+  float r1, r2;
+  int   i;
+
+  r1 = GLM(mat2_rmc)(v, mat, v);
+
+  for (i = 0; i < 2; i++) {
+    v1[i] = v[0] * mat[i][0] + v[1] * mat[i][1];
+  }
+
+  r2 = v[0] * v1[0] + v[1] * v1[1];
+
+  ASSERT(test_eq(r1, r2))
+
+  TEST_SUCCESS
+}
+
+#undef A_MATRIX2x2

test/src/tests.c

@@ -15,6 +15,7 @@
 #include "test_vec2.h"
 #include "test_vec3.h"
 #include "test_vec4.h"
+#include "test_mat2.h"
 #include "test_mat3.h"
 #include "test_mat4.h"
 #include "test_quat.h"
@@ -35,6 +36,7 @@
 #include "test_vec2.h"
 #include "test_vec3.h"
 #include "test_vec4.h"
+#include "test_mat2.h"
 #include "test_mat3.h"
 #include "test_mat4.h"
 #include "test_quat.h"

test/tests.h

@@ -159,6 +159,42 @@ TEST_DECLARE(glmc_mat3_swap_col)
 TEST_DECLARE(glmc_mat3_swap_row)
 TEST_DECLARE(glmc_mat3_rmc)
 
+TEST_DECLARE(MACRO_GLM_MAT2_IDENTITY_INIT)
+TEST_DECLARE(MACRO_GLM_MAT2_ZERO_INIT)
+TEST_DECLARE(MACRO_GLM_MAT2_IDENTITY)
+TEST_DECLARE(MACRO_GLM_MAT2_ZERO)
+TEST_DECLARE(glm_mat2_copy)
+TEST_DECLARE(glm_mat2_identity)
+TEST_DECLARE(glm_mat2_identity_array)
+TEST_DECLARE(glm_mat2_zero)
+TEST_DECLARE(glm_mat2_mul)
+TEST_DECLARE(glm_mat2_transpose_to)
+TEST_DECLARE(glm_mat2_transpose)
+TEST_DECLARE(glm_mat2_mulv)
+TEST_DECLARE(glm_mat2_trace)
+TEST_DECLARE(glm_mat2_scale)
+TEST_DECLARE(glm_mat2_det)
+TEST_DECLARE(glm_mat2_inv)
+TEST_DECLARE(glm_mat2_swap_col)
+TEST_DECLARE(glm_mat2_swap_row)
+TEST_DECLARE(glm_mat2_rmc)
+
+TEST_DECLARE(glmc_mat2_copy)
+TEST_DECLARE(glmc_mat2_identity)
+TEST_DECLARE(glmc_mat2_identity_array)
+TEST_DECLARE(glmc_mat2_zero)
+TEST_DECLARE(glmc_mat2_mul)
+TEST_DECLARE(glmc_mat2_transpose_to)
+TEST_DECLARE(glmc_mat2_transpose)
+TEST_DECLARE(glmc_mat2_mulv)
+TEST_DECLARE(glmc_mat2_trace)
+TEST_DECLARE(glmc_mat2_scale)
+TEST_DECLARE(glmc_mat2_det)
+TEST_DECLARE(glmc_mat2_inv)
+TEST_DECLARE(glmc_mat2_swap_col)
+TEST_DECLARE(glmc_mat2_swap_row)
+TEST_DECLARE(glmc_mat2_rmc)
+
 /* camera */
 TEST_DECLARE(camera_lookat)
 TEST_DECLARE(camera_decomp)
@@ -775,7 +811,6 @@ TEST_LIST {
   TEST_ENTRY(glmc_mat4_swap_row)
   TEST_ENTRY(glmc_mat4_rmc)
   
-  
   /* mat3 */
   TEST_ENTRY(glm_mat3_copy)
   TEST_ENTRY(glm_mat3_identity)
@@ -811,6 +846,42 @@ TEST_LIST {
   TEST_ENTRY(glmc_mat3_swap_row)
   TEST_ENTRY(glmc_mat3_rmc)
   
+  TEST_ENTRY(MACRO_GLM_MAT2_IDENTITY_INIT)
+  TEST_ENTRY(MACRO_GLM_MAT2_ZERO_INIT)
+  TEST_ENTRY(MACRO_GLM_MAT2_IDENTITY)
+  TEST_ENTRY(MACRO_GLM_MAT2_ZERO)
+  TEST_ENTRY(glm_mat2_copy)
+  TEST_ENTRY(glm_mat2_identity)
+  TEST_ENTRY(glm_mat2_identity_array)
+  TEST_ENTRY(glm_mat2_zero)
+  TEST_ENTRY(glm_mat2_mul)
+  TEST_ENTRY(glm_mat2_transpose_to)
+  TEST_ENTRY(glm_mat2_transpose)
+  TEST_ENTRY(glm_mat2_mulv)
+  TEST_ENTRY(glm_mat2_trace)
+  TEST_ENTRY(glm_mat2_scale)
+  TEST_ENTRY(glm_mat2_det)
+  TEST_ENTRY(glm_mat2_inv)
+  TEST_ENTRY(glm_mat2_swap_col)
+  TEST_ENTRY(glm_mat2_swap_row)
+  TEST_ENTRY(glm_mat2_rmc)
+
+  TEST_ENTRY(glmc_mat2_copy)
+  TEST_ENTRY(glmc_mat2_identity)
+  TEST_ENTRY(glmc_mat2_identity_array)
+  TEST_ENTRY(glmc_mat2_zero)
+  TEST_ENTRY(glmc_mat2_mul)
+  TEST_ENTRY(glmc_mat2_transpose_to)
+  TEST_ENTRY(glmc_mat2_transpose)
+  TEST_ENTRY(glmc_mat2_mulv)
+  TEST_ENTRY(glmc_mat2_trace)
+  TEST_ENTRY(glmc_mat2_scale)
+  TEST_ENTRY(glmc_mat2_det)
+  TEST_ENTRY(glmc_mat2_inv)
+  TEST_ENTRY(glmc_mat2_swap_col)
+  TEST_ENTRY(glmc_mat2_swap_row)
+  TEST_ENTRY(glmc_mat2_rmc)
+
   /* camera */
   TEST_ENTRY(camera_lookat)
   TEST_ENTRY(camera_decomp)
@@ -955,7 +1026,6 @@ TEST_LIST {
   TEST_ENTRY(glm_vec2_clamp)
   TEST_ENTRY(glm_vec2_lerp)
 
-
   TEST_ENTRY(glmc_vec2)
   TEST_ENTRY(glmc_vec2_copy)
   TEST_ENTRY(glmc_vec2_zero)