Merge pull request #343 from EasyIP2023/non-square-matrix

add docs and tests to non-square-matrix branch

docs/source/mat2.rst

@@ -65,11 +65,12 @@ Functions documentation
     make given matrix zero
 
     Parameters:
-      | *[in,out]* **mat**  matrix to
+      | *[in,out]* **mat**  matrix
 
 .. c:function:: void glm_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
 
     multiply m1 and m2 to dest
+
     m1, m2 and dest matrices can be same matrix, it is possible to write this:
 
     .. code-block:: c
@@ -101,7 +102,7 @@ Functions documentation
 
 .. c:function:: void glm_mat2_mulv(mat2 m, vec2 v, vec2 dest)
 
-    multiply mat4 with vec4 (column vector) and store in dest vector
+    multiply mat2 with vec2 (column vector) and store in dest vector
 
     Parameters:
       | *[in]*  **mat**   mat2 (left)
@@ -113,8 +114,8 @@ Functions documentation
     multiply matrix with scalar
 
     Parameters:
-      | *[in, out]* **mat**   matrix
+      | *[in, out]* **m**  matrix
-      | *[in]*      **dest**  scalar
+      | *[in]*      **s**  scalar
 
 .. c:function:: float  glm_mat2_det(mat2 mat)
 

docs/source/mat2x3.rst

@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat2x3_make`
+1. :c:func:`glm_mat2x3_copy`
+#. :c:func:`glm_mat2x3_zero`
+#. :c:func:`glm_mat2x3_make`
+#. :c:func:`glm_mat2x3_mul`
+#. :c:func:`glm_mat2x3_mulv`
+#. :c:func:`glm_mat2x3_transpose`
+#. :c:func:`glm_mat2x3_scale`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
 
+.. c:function:: void glm_mat2x3_copy(mat2x3 mat, mat2x3 dest)
+
+    copy mat2x3 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat2x3_zero(mat2x3 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
 .. c:function:: void glm_mat2x3_make(float * __restrict src, mat2x3 dest)
 
     Create mat2x3 matrix from pointer
@@ -29,3 +50,43 @@ Functions documentation
     Parameters:
       | *[in]*  **src**  pointer to an array of floats
       | *[out]* **dest** destination matrix2x3
+
+.. c:function:: void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat2x3_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest)
+
+    multiply mat2x3 with vec3 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat2x3 (left)
+      | *[in]*  **v**     vec3 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat2x3_transpose(mat2x3 m, mat3x2 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat2x3_scale(mat2x3 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

docs/source/mat2x4.rst

@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat2x4_make`
+1. :c:func:`glm_mat2x4_copy`
+#. :c:func:`glm_mat2x4_zero`
+#. :c:func:`glm_mat2x4_make`
+#. :c:func:`glm_mat2x4_mul`
+#. :c:func:`glm_mat2x4_mulv`
+#. :c:func:`glm_mat2x4_transpose`
+#. :c:func:`glm_mat2x4_scale`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
 
+.. c:function:: void glm_mat2x4_copy(mat2x4 mat, mat2x4 dest)
+
+    copy mat2x4 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat2x4_zero(mat2x4 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
 .. c:function:: void glm_mat2x4_make(float * __restrict src, mat2x4 dest)
 
     Create mat2x4 matrix from pointer
@@ -29,3 +50,43 @@ Functions documentation
     Parameters:
       | *[in]*  **src**  pointer to an array of floats
       | *[out]* **dest** destination matrix2x4
+
+.. c:function:: void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat2x4_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest)
+
+    multiply mat2x4 with vec4 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat2x4 (left)
+      | *[in]*  **v**     vec4 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat2x4_transpose(mat2x4 m, mat4x2 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat2x4_scale(mat2x4 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

docs/source/mat3.rst

@@ -72,6 +72,7 @@ Functions documentation
 .. c:function:: void  glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest)
 
     multiply m1 and m2 to dest
+
     m1, m2 and dest matrices can be same matrix, it is possible to write this:
 
     .. code-block:: c
@@ -103,10 +104,10 @@ Functions documentation
 
 .. c:function:: void  glm_mat3_mulv(mat3 m, vec3 v, vec3 dest)
 
-    multiply mat4 with vec4 (column vector) and store in dest vector
+    multiply mat3 with vec3 (column vector) and store in dest vector
 
     Parameters:
-      | *[in]*  **mat**   mat3 (left)
+      | *[in]*  **m**     mat3 (left)
       | *[in]*  **v**     vec3 (right, column vector)
       | *[out]* **dest**  destination (result, column vector)
 
@@ -123,8 +124,8 @@ Functions documentation
     multiply matrix with scalar
 
     Parameters:
-      | *[in, out]* **mat**   matrix
+      | *[in, out]* **m** matrix
-      | *[in]*      **dest**  scalar
+      | *[in]*      **s** scalar
 
 .. c:function:: float  glm_mat3_det(mat3 mat)
 

docs/source/mat3x2.rst

@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat3x2_make`
+1. :c:func:`glm_mat3x2_copy`
+#. :c:func:`glm_mat3x2_zero`
+#. :c:func:`glm_mat3x2_make`
+#. :c:func:`glm_mat3x2_mul`
+#. :c:func:`glm_mat3x2_mulv`
+#. :c:func:`glm_mat3x2_transpose`
+#. :c:func:`glm_mat3x2_scale`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
 
+.. c:function:: void glm_mat3x2_copy(mat3x2 mat, mat3x2 dest)
+
+    copy mat3x2 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat3x2_zero(mat3x2 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
 .. c:function:: void glm_mat3x2_make(float * __restrict src, mat3x2 dest)
 
     Create mat3x2 matrix from pointer
@@ -28,3 +49,43 @@ Functions documentation
     Parameters:
       | *[in]*  **src**  pointer to an array of floats
       | *[out]* **dest** destination matrix3x2
+
+.. c:function:: void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat3x2_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest)
+
+    multiply mat3x2 with vec2 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat3x2 (left)
+      | *[in]*  **v**     vec3 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat3x2_transpose(mat3x2 m, mat2x3 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat3x2_scale(mat3x2 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

docs/source/mat3x4.rst

@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat3x4_make`
+1. :c:func:`glm_mat3x4_copy`
+#. :c:func:`glm_mat3x4_zero`
+#. :c:func:`glm_mat3x4_make`
+#. :c:func:`glm_mat3x4_mul`
+#. :c:func:`glm_mat3x4_mulv`
+#. :c:func:`glm_mat3x4_transpose`
+#. :c:func:`glm_mat3x4_scale`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
 
+.. c:function:: void glm_mat3x4_copy(mat3x4 mat, mat3x4 dest)
+
+    copy mat3x4 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat3x4_zero(mat3x4 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
 .. c:function:: void glm_mat3x4_make(float * __restrict src, mat3x4 dest)
 
     Create mat3x4 matrix from pointer
@@ -28,3 +49,43 @@ Functions documentation
     Parameters:
       | *[in]*  **src**  pointer to an array of floats
       | *[out]* **dest** destination matrix3x4
+
+.. c:function:: void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat3x4_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest)
+
+    multiply mat3x4 with vec4 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat3x4 (left)
+      | *[in]*  **v**     vec4 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat3x4_transpose(mat3x4 m, mat4x3 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat3x4_scale(mat3x4 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

docs/source/mat4.rst

@@ -119,6 +119,7 @@ Functions documentation
 .. c:function:: void  glm_mat4_mul(mat4 m1, mat4 m2, mat4 dest)
 
     multiply m1 and m2 to dest
+
     m1, m2 and dest matrices can be same matrix, it is possible to write this:
 
     .. code-block:: c
@@ -157,7 +158,6 @@ Functions documentation
     Parameters:
       | *[in]*  **m**     mat4 (left)
       | *[in]*  **v**     vec4 (right, column vector)
-      | *[in]*  **last**  4th item to make it vec4
       | *[out]* **dest**  vec4 (result, column vector)
 
 .. c:function:: void  glm_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest)

docs/source/mat4x2.rst

@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat4x2_make`
+1. :c:func:`glm_mat4x2_copy`
+#. :c:func:`glm_mat4x2_zero`
+#. :c:func:`glm_mat4x2_make`
+#. :c:func:`glm_mat4x2_mul`
+#. :c:func:`glm_mat4x2_mulv`
+#. :c:func:`glm_mat4x2_transpose`
+#. :c:func:`glm_mat4x2_scale`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
 
+.. c:function:: void glm_mat4x2_copy(mat4x2 mat, mat4x2 dest)
+
+    copy mat4x2 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat4x2_zero(mat4x2 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
 .. c:function:: void glm_mat4x2_make(float * __restrict src, mat4x2 dest)
 
     Create mat4x2 matrix from pointer
@@ -28,3 +49,43 @@ Functions documentation
     Parameters:
       | *[in]*  **src**  pointer to an array of floats
       | *[out]* **dest** destination matrix4x2
+
+.. c:function:: void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat4x2_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest)
+
+    multiply mat4x2 with vec2 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat4x2 (left)
+      | *[in]*  **v**     vec2 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat4x2_transpose(mat4x2 m, mat2x4 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat4x2_scale(mat4x2 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

docs/source/mat4x3.rst

@@ -15,11 +15,32 @@ Macros:
 
 Functions:
 
-1. :c:func:`glm_mat4x3_make`
+1. :c:func:`glm_mat4x3_copy`
+#. :c:func:`glm_mat4x3_zero`
+#. :c:func:`glm_mat4x3_make`
+#. :c:func:`glm_mat4x3_mul`
+#. :c:func:`glm_mat4x3_mulv`
+#. :c:func:`glm_mat4x3_transpose`
+#. :c:func:`glm_mat4x3_scale`
 
 Functions documentation
 ~~~~~~~~~~~~~~~~~~~~~~~
 
+.. c:function:: void glm_mat4x3_copy(mat4x3 mat, mat4x3 dest)
+
+    copy mat4x3 to another one (dest).
+
+    Parameters:
+      | *[in]*  **mat**   source
+      | *[out]* **dest**  destination
+
+.. c:function:: void glm_mat4x3_zero(mat4x3 mat)
+
+    make given matrix zero
+
+    Parameters:
+      | *[in,out]* **mat**  matrix
+
 .. c:function:: void glm_mat4x3_make(float * __restrict src, mat4x3 dest)
 
     Create mat4x3 matrix from pointer
@@ -28,3 +49,43 @@ Functions documentation
     Parameters:
       | *[in]*  **src**  pointer to an array of floats
       | *[out]* **dest** destination matrix4x3
+
+.. c:function:: void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest)
+
+    multiply m1 and m2 to dest
+
+    m1, m2 and dest matrices can be same matrix, it is possible to write this:
+
+    .. code-block:: c
+
+       glm_mat4x3_mul(m, m, m);
+
+    Parameters:
+      | *[in]*  **m1**    left matrix
+      | *[in]*  **m2**    right matrix
+      | *[out]* **dest**  destination matrix
+
+.. c:function:: void glm_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest)
+
+    multiply mat4x3 with vec3 (column vector) and store in dest vector
+
+    Parameters:
+      | *[in]*  **m**     mat4x3 (left)
+      | *[in]*  **v**     vec3 (right, column vector)
+      | *[out]* **dest**  destination (result, column vector)
+
+.. c:function:: void glm_mat4x3_transpose(mat4x3 m, mat3x4 dest)
+
+    transpose matrix and store in dest
+
+    Parameters:
+      | *[in]*  **m**     matrix
+      | *[out]* **dest**  destination
+
+.. c:function:: void  glm_mat4x3_scale(mat4x3 m, float s)
+
+    multiply matrix with scalar
+
+    Parameters:
+      | *[in, out]* **m** matrix
+      | *[in]*      **s** scalar

include/cglm/mat2x3.h

@@ -94,18 +94,18 @@ glm_mat2x3_make(float * __restrict src, mat2x3 dest) {
 CGLM_INLINE
 void
 glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest) {
-  float a00 = m1[0][0], a01 = m1[0][1],
+  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2],
-        a10 = m1[1][0], a11 = m1[1][1],
+        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2],
-        a20 = m1[2][0], a21 = m1[2][1],
 
         b00 = m2[0][0], b01 = m2[0][1],
         b10 = m2[1][0], b11 = m2[1][1],
         b20 = m2[2][0], b21 = m2[2][1];
 
-  dest[0][0] = a00 * b00 + a10 * b01 + a20 * b20;
+  dest[0][0] = a00 * b00 + a01 * b10 + a02 * b20;
-  dest[0][1] = a00 * b10 + a10 * b11 + a20 * b21;
+  dest[0][1] = a00 * b01 + a01 * b11 + a02 * b21;
-  dest[1][0] = a01 * b00 + a11 * b01 + a21 * b20;
+
-  dest[1][1] = a01 * b10 + a11 * b11 + a21 * b21;
+  dest[1][0] = a10 * b00 + a11 * b10 + a12 * b20;
+  dest[1][1] = a10 * b01 + a11 * b11 + a12 * b21;
 }
 
 /*!

include/cglm/mat2x4.h

@@ -92,20 +92,19 @@ glm_mat2x4_make(float * __restrict src, mat2x4 dest) {
 CGLM_INLINE
 void
 glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest) {
-  float a00 = m1[0][0], a01 = m1[0][1],
+  float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
-        a10 = m1[1][0], a11 = m1[1][1],
+        a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
-        a20 = m1[2][0], a21 = m1[2][1],
-        a30 = m1[3][0], a31 = m1[3][1],
 
         b00 = m2[0][0], b01 = m2[0][1],
         b10 = m2[1][0], b11 = m2[1][1],
         b20 = m2[2][0], b21 = m2[2][1],
         b30 = m2[3][0], b31 = m2[3][1];
 
-  dest[0][0] = a00 * b00 + a10 * b01 + a20 * b20 + a30 * b30;
+  dest[0][0] = a00 * b00 + a01 * b10 + a02 * b20 + a03 * b30;
-  dest[0][1] = a00 * b10 + a10 * b11 + a20 * b21 + a30 * b31;
+  dest[0][1] = a00 * b01 + a01 * b11 + a02 * b21 + a03 * b31;
-  dest[1][0] = a01 * b00 + a11 * b01 + a21 * b20 + a31 * b30;
+
-  dest[1][1] = a01 * b10 + a11 * b11 + a21 * b21 + a31 * b31;
+  dest[1][0] = a10 * b00 + a11 * b10 + a12 * b20 + a13 * b30;
+  dest[1][1] = a10 * b01 + a11 * b11 + a12 * b21 + a13 * b31;
 }
 
 /*!
@@ -151,7 +150,7 @@ CGLM_INLINE
 void
 glm_mat2x4_scale(mat2x4 m, float s) {
   m[0][0] *= s;  m[0][1] *= s;  m[0][2] *= s;  m[0][3] *= s;
-  m[1][0] *= s;  m[1][1] *= s;  m[2][2] *= s;  m[3][3] *= s;
+  m[1][0] *= s;  m[1][1] *= s;  m[1][2] *= s;  m[1][3] *= s;
 }
 
 #endif

include/cglm/mat3x2.h

@@ -103,13 +103,13 @@ glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest) {
         b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
         b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2];
 
-  dest[0][0] = a00 * b00 + a10 * b10;
+  dest[0][0] = a00 * b00 + a01 * b10;
-  dest[0][1] = a00 * b01 + a10 * b11;
+  dest[0][1] = a00 * b01 + a01 * b11;
-  dest[0][2] = a00 * b02 + a10 * b12;
+  dest[0][2] = a00 * b02 + a01 * b12;
 
-  dest[1][0] = a01 * b00 + a11 * b10;
+  dest[1][0] = a10 * b00 + a11 * b10;
-  dest[1][1] = a01 * b01 + a11 * b11;
+  dest[1][1] = a10 * b01 + a11 * b11;
-  dest[1][2] = a01 * b02 + a11 * b12;
+  dest[1][2] = a10 * b02 + a11 * b12;
 
   dest[2][0] = a20 * b00 + a21 * b10;
   dest[2][1] = a20 * b01 + a21 * b11;

include/cglm/mat4x2.h

@@ -110,15 +110,15 @@ glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest) {
         b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2], b03 = m2[0][3],
         b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2], b13 = m2[1][3];
 
-  dest[0][0] = a00 * b00 + a10 * b10;
+  dest[0][0] = a00 * b00 + a01 * b10;
-  dest[0][1] = a00 * b01 + a10 * b11;
+  dest[0][1] = a00 * b01 + a01 * b11;
-  dest[0][2] = a00 * b02 + a10 * b12;
+  dest[0][2] = a00 * b02 + a01 * b12;
-  dest[0][3] = a00 * b03 + a10 * b13;
+  dest[0][3] = a00 * b03 + a01 * b13;
 
-  dest[1][0] = a01 * b00 + a11 * b10;
+  dest[1][0] = a10 * b00 + a11 * b10;
-  dest[1][1] = a01 * b01 + a11 * b11;
+  dest[1][1] = a10 * b01 + a11 * b11;
-  dest[1][2] = a01 * b02 + a11 * b12;
+  dest[1][2] = a10 * b02 + a11 * b12;
-  dest[1][3] = a01 * b03 + a11 * b13;
+  dest[1][3] = a10 * b03 + a11 * b13;
 
   dest[2][0] = a20 * b00 + a21 * b10;
   dest[2][1] = a20 * b01 + a21 * b11;

include/cglm/mat4x3.h

@@ -42,15 +42,19 @@ void
 glm_mat4x3_copy(mat4x3 mat, mat4x3 dest) {
   dest[0][0] = mat[0][0];
   dest[0][1] = mat[0][1];
+  dest[0][2] = mat[0][2];
 
   dest[1][0] = mat[1][0];
   dest[1][1] = mat[1][1];
+  dest[1][2] = mat[1][2];
 
   dest[2][0] = mat[2][0];
   dest[2][1] = mat[2][1];
+  dest[2][2] = mat[2][2];
 
   dest[3][0] = mat[3][0];
   dest[3][1] = mat[3][1];
+  dest[3][2] = mat[3][2];
 }
 
 /*!

test/src/test_common.c

@@ -22,6 +22,40 @@ test_rand_mat4(mat4 dest) {
   /* glm_scale(dest, (vec3){drand48(), drand48(), drand48()}); */
 }
 
+void
+test_rand_mat4x2(mat4x2 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+
+  dest[2][0] = drand48();
+  dest[2][1] = drand48();
+
+  dest[3][0] = drand48();
+  dest[3][1] = drand48();
+}
+
+void
+test_rand_mat4x3(mat4x3 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[0][2] = drand48();
+
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+  dest[1][2] = drand48();
+
+  dest[2][0] = drand48();
+  dest[2][1] = drand48();
+  dest[2][2] = drand48();
+
+  dest[3][0] = drand48();
+  dest[3][1] = drand48();
+  dest[3][2] = drand48();
+}
+
 void
 test_rand_mat3(mat3 dest) {
   mat4 m4;
@@ -31,6 +65,34 @@ test_rand_mat3(mat3 dest) {
   glm_mat4_pick3(m4, dest);
 }
 
+void
+test_rand_mat3x2(mat3x2 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+  dest[2][0] = drand48();
+  dest[2][1] = drand48();
+}
+
+void
+test_rand_mat3x4(mat3x4 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[0][2] = drand48();
+  dest[0][3] = drand48();
+
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+  dest[1][2] = drand48();
+  dest[1][3] = drand48();
+
+  dest[2][0] = drand48();
+  dest[2][1] = drand48();
+  dest[2][2] = drand48();
+  dest[2][3] = drand48();
+}
+
 void
 test_rand_mat2(mat2 dest) {
   dest[0][0] = drand48();
@@ -39,6 +101,28 @@ test_rand_mat2(mat2 dest) {
   dest[1][1] = drand48();
 }
 
+void
+test_rand_mat2x3(mat2x3 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[0][2] = drand48();
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+  dest[1][2] = drand48();
+}
+
+void
+test_rand_mat2x4(mat2x4 dest) {
+  dest[0][0] = drand48();
+  dest[0][1] = drand48();
+  dest[0][2] = drand48();
+  dest[0][3] = drand48();
+  dest[1][0] = drand48();
+  dest[1][1] = drand48();
+  dest[1][2] = drand48();
+  dest[1][3] = drand48();
+}
+
 void
 test_rand_vec3(vec3 dest) {
   dest[0] = drand48();
@@ -187,6 +271,19 @@ test_assert_mat2x3_eq_zero(mat2x3 m2x3) {
   TEST_SUCCESS
 }
 
+test_status_t
+test_assert_mat2x3_eq(mat2x3 m1, mat2x3 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
 test_status_t
 test_assert_mat2x4_eq_zero(mat2x4 m2x4) {
   int i, j;
@@ -200,6 +297,19 @@ test_assert_mat2x4_eq_zero(mat2x4 m2x4) {
   TEST_SUCCESS
 }
 
+test_status_t
+test_assert_mat2x4_eq(mat2x4 m1, mat2x4 m2) {
+  int i, j;
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
 test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2) {
   int i, j;
@@ -269,6 +379,19 @@ test_assert_mat3x2_eq_zero(mat3x2 m3x2) {
   TEST_SUCCESS
 }
 
+test_status_t
+test_assert_mat3x2_eq(mat3x2 m1, mat3x2 m2) {
+  int i, j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
 test_status_t
 test_assert_mat3x4_eq_zero(mat3x4 m3x4) {
   int i, j;
@@ -282,6 +405,19 @@ test_assert_mat3x4_eq_zero(mat3x4 m3x4) {
   TEST_SUCCESS
 }
 
+test_status_t
+test_assert_mat3x4_eq(mat3x4 m1, mat3x4 m2) {
+  int i, j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
 test_status_t
 test_assert_mat4_eq_identity(mat4 m4) {
   int i, j;
@@ -325,6 +461,19 @@ test_assert_mat4x2_eq_zero(mat4x2 m4x2) {
   TEST_SUCCESS
 }
 
+test_status_t
+test_assert_mat4x2_eq(mat4x2 m1, mat4x2 m2) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
 test_status_t
 test_assert_mat4x3_eq_zero(mat4x3 m4x3) {
   int i, j;
@@ -338,6 +487,19 @@ test_assert_mat4x3_eq_zero(mat4x3 m4x3) {
   TEST_SUCCESS
 }
 
+test_status_t
+test_assert_mat4x3_eq(mat4x3 m1, mat4x3 m2) {
+  int i, j;
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(fabsf(m1[i][j] - m2[i][j]) <= 0.0000009)
+    }
+  }
+
+  TEST_SUCCESS
+}
+
 test_status_t
 test_assert_eqf(float a, float b) {
   ASSERT(fabsf(a - b) <= 0.000009); /* rounding errors */

test/src/test_common.h

@@ -17,12 +17,30 @@
 void
 test_rand_mat4(mat4 dest);
 
+void
+test_rand_mat4x2(mat4x2 dest);
+
+void
+test_rand_mat4x3(mat4x3 dest);
+
 void
 test_rand_mat3(mat3 dest);
 
+void
+test_rand_mat3x2(mat3x2 dest);
+
+void
+test_rand_mat3x4(mat3x4 dest);
+
 void
 test_rand_mat2(mat2 dest);
 
+void
+test_rand_mat2x3(mat2x3 dest);
+
+void
+test_rand_mat2x4(mat2x4 dest);
+
 test_status_t
 test_assert_eqf(float a, float b);
 
@@ -44,9 +62,15 @@ test_assert_mat4_eq_zero(mat4 m4);
 test_status_t
 test_assert_mat4x2_eq_zero(mat4x2 m4x2);
 
+test_status_t
+test_assert_mat4x2_eq(mat4x2 m1, mat4x2 m2);
+
 test_status_t
 test_assert_mat4x3_eq_zero(mat4x3 m4x3);
 
+test_status_t
+test_assert_mat4x3_eq(mat4x3 m1, mat4x3 m2);
+
 test_status_t
 test_assert_mat2_eqt(mat2 m1, mat2 m2);
 
@@ -62,9 +86,15 @@ test_assert_mat2_eq_zero(mat2 m2);
 test_status_t
 test_assert_mat2x3_eq_zero(mat2x3 m2x3);
 
+test_status_t
+test_assert_mat2x3_eq(mat2x3 m1, mat2x3 m2);
+
 test_status_t
 test_assert_mat2x4_eq_zero(mat2x4 m2x4);
 
+test_status_t
+test_assert_mat2x4_eq(mat2x4 m1, mat2x4 m2);
+
 test_status_t
 test_assert_mat3_eq(mat3 m1, mat3 m2);
 
@@ -83,9 +113,15 @@ test_assert_mat3_eq_zero(mat3 m3);
 test_status_t
 test_assert_mat3x2_eq_zero(mat3x2 m3x2);
 
+test_status_t
+test_assert_mat3x2_eq(mat3x2 m1, mat3x2 m2);
+
 test_status_t
 test_assert_mat3x4_eq_zero(mat3x4 m3x4);
 
+test_status_t
+test_assert_mat3x4_eq(mat3x4 m1, mat3x4 m2);
+
 test_status_t
 test_assert_vec3_eq(vec3 v1, vec3 v2);
 

test/src/test_mat2x3.h

@@ -7,6 +7,9 @@
 
 #include "test_common.h"
 
+#define A_MATRIX2X3 {{1,2,3},{5,6,7}}
+#define A_MATRIX2X3_TRANSPOSE {{1,5}, {2,6}, {3,7}}
+
 #ifndef CGLM_TEST_MAT2X3_ONCE
 #define CGLM_TEST_MAT2X3_ONCE
 
@@ -24,6 +27,31 @@ TEST_IMPL(MACRO_GLM_MAT2X3_ZERO) {
 
 #endif /* CGLM_TEST_MAT2X3_ONCE */
 
+TEST_IMPL(GLM_PREFIX, mat2x3_copy) {
+  mat2x3 m1 = A_MATRIX2X3;
+  mat2x3 m2 = GLM_MAT2X3_ZERO_INIT;
+
+  GLM(mat2x3_copy)(m1, m2);
+
+  test_assert_mat2x3_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x3_zero) {
+  mat2x3 m1 = GLM_MAT2X3_ZERO_INIT;
+  mat2x3 m2 = GLM_MAT2X3_ZERO_INIT;
+  mat2x3 m3;
+
+  GLM(mat2x3_zero)(m3);
+
+  ASSERTIFY(test_assert_mat2x3_eq_zero(m1))
+  ASSERTIFY(test_assert_mat2x3_eq_zero(m2))
+  ASSERTIFY(test_assert_mat2x3_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
 TEST_IMPL(GLM_PREFIX, mat2x3_make) {
   float src[18] = {
     0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f,
@@ -50,3 +78,79 @@ TEST_IMPL(GLM_PREFIX, mat2x3_make) {
 
   TEST_SUCCESS
 }
+
+TEST_IMPL(GLM_PREFIX, mat2x3_mul) {
+  mat2x3 m1 = GLM_MAT2X3_ZERO_INIT;
+  mat3x2 m2 = GLM_MAT3X2_ZERO_INIT;
+
+  mat2 m3 = GLM_MAT2_ZERO_INIT;
+  mat2 m4 = GLM_MAT2_ZERO_INIT;
+
+  int i, j, k;
+
+  /* test random matrices */
+  /* random matrices */
+  test_rand_mat2x3(m1);
+  test_rand_mat3x2(m2);
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      for (k = 0; k < 3; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat2x3_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat2_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x3_mulv) {
+  mat2x3 mat = A_MATRIX2X3;
+  vec3 v = {11.0f, 21.0f, 31.0f};
+
+  int  i;
+  vec2 dest;
+  float res = 0.0;
+
+  GLM(mat2x3_mulv)(mat, v, dest);
+
+  for (i = 0; i < 2; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x3_transpose) {
+  mat2x3 m1 = A_MATRIX2X3;
+
+  mat3x2 m2;
+  mat3x2 m3 = A_MATRIX2X3_TRANSPOSE;
+  GLM(mat2x3_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat3x2_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x3_scale) {
+  mat2x3 m1 = A_MATRIX2X3;
+  mat2x3 m2 = A_MATRIX2X3;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat2x3_scale)(m1, (float) scale);
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/src/test_mat2x4.h

@@ -8,6 +8,9 @@
 
 #include "test_common.h"
 
+#define A_MATRIX2X4 {{1,2,3,4},{5,6,7,8}}
+#define A_MATRIX2X4_TRANSPOSE {{1,5}, {2,6}, {3,7}, {4,8}}
+
 #ifndef CGLM_TEST_MAT2X4_ONCE
 #define CGLM_TEST_MAT2X4_ONCE
 
@@ -25,6 +28,31 @@ TEST_IMPL(MACRO_GLM_MAT2X4_ZERO) {
 
 #endif /* CGLM_TEST_MAT2X4_ONCE */
 
+TEST_IMPL(GLM_PREFIX, mat2x4_copy) {
+  mat2x4 m1 = A_MATRIX2X4;
+  mat2x4 m2 = GLM_MAT2X4_ZERO_INIT;
+
+  GLM(mat2x4_copy)(m1, m2);
+
+  test_assert_mat2x4_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x4_zero) {
+  mat2x4 m1 = GLM_MAT2X4_ZERO_INIT;
+  mat2x4 m2 = GLM_MAT2X4_ZERO_INIT;
+  mat2x4 m3;
+
+  GLM(mat2x4_zero)(m3);
+
+  ASSERTIFY(test_assert_mat2x4_eq_zero(m1))
+  ASSERTIFY(test_assert_mat2x4_eq_zero(m2))
+  ASSERTIFY(test_assert_mat2x4_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
 TEST_IMPL(GLM_PREFIX, mat2x4_make) {
   float src[24] = {
     0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f, 77.3f, 88.4f,
@@ -53,3 +81,79 @@ TEST_IMPL(GLM_PREFIX, mat2x4_make) {
 
   TEST_SUCCESS
 }
+
+TEST_IMPL(GLM_PREFIX, mat2x4_mul) {
+  mat2x4 m1 = GLM_MAT2X4_ZERO_INIT;
+  mat4x2 m2 = GLM_MAT4X2_ZERO_INIT;
+
+  mat2 m3 = GLM_MAT2_ZERO_INIT;
+  mat2 m4 = GLM_MAT2_ZERO_INIT;
+
+  int i, j, k;
+
+  /* test random matrices */
+  /* random matrices */
+  test_rand_mat2x4(m1);
+  test_rand_mat4x2(m2);
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 2; j++) {
+      for (k = 0; k < 4; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat2x4_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat2_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x4_mulv) {
+  mat2x4 mat = A_MATRIX2X4;
+  vec4 v = {11.0f, 21.0f, 31.0f, 41.0f};
+
+  int  i;
+  vec2 dest;
+  float res = 0.0;
+
+  GLM(mat2x4_mulv)(mat, v, dest);
+
+  for (i = 0; i < 2; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2] + mat[i][3] * v[3];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x4_transpose) {
+  mat2x4 m1 = A_MATRIX2X4;
+
+  mat4x2 m2;
+  mat4x2 m3 = A_MATRIX2X4_TRANSPOSE;
+  GLM(mat2x4_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat4x2_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat2x4_scale) {
+  mat2x4 m1 = A_MATRIX2X4;
+  mat2x4 m2 = A_MATRIX2X4;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat2x4_scale)(m1, (float) scale);
+
+  for (i = 0; i < 2; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/src/test_mat3x2.h

@@ -7,6 +7,9 @@
 
 #include "test_common.h"
 
+#define A_MATRIX3X2 {{1,2},{5,6},{3,7}}
+#define A_MATRIX3X2_TRANSPOSE {{1,5,3}, {2,6,7}}
+
 #ifndef CGLM_TEST_MAT3X2_ONCE
 #define CGLM_TEST_MAT3X2_ONCE
 
@@ -24,6 +27,31 @@ TEST_IMPL(MACRO_GLM_MAT3X2_ZERO) {
 
 #endif /* CGLM_TEST_MAT3X2_ONCE */
 
+TEST_IMPL(GLM_PREFIX, mat3x2_copy) {
+  mat3x2 m1 = A_MATRIX3X2;
+  mat3x2 m2 = GLM_MAT3X2_ZERO_INIT;
+
+  GLM(mat3x2_copy)(m1, m2);
+
+  test_assert_mat3x2_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x2_zero) {
+  mat3x2 m1 = GLM_MAT3X2_ZERO_INIT;
+  mat3x2 m2 = GLM_MAT3X2_ZERO_INIT;
+  mat3x2 m3;
+
+  GLM(mat3x2_zero)(m3);
+
+  ASSERTIFY(test_assert_mat3x2_eq_zero(m1))
+  ASSERTIFY(test_assert_mat3x2_eq_zero(m2))
+  ASSERTIFY(test_assert_mat3x2_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
 TEST_IMPL(GLM_PREFIX, mat3x2_make) {
   float src[18] = {
     0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f,
@@ -51,3 +79,77 @@ TEST_IMPL(GLM_PREFIX, mat3x2_make) {
 
   TEST_SUCCESS
 }
+
+TEST_IMPL(GLM_PREFIX, mat3x2_mul) {
+  mat3x2 m1 = GLM_MAT3X2_ZERO_INIT;
+  mat2x3 m2 = GLM_MAT2X3_ZERO_INIT;
+
+  mat3 m3 = GLM_MAT3_ZERO_INIT;
+  mat3 m4 = GLM_MAT3_ZERO_INIT;
+
+  int i, j, k;
+
+  test_rand_mat3x2(m1);
+  test_rand_mat2x3(m2);
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      for (k = 0; k < 2; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat3x2_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat3_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x2_mulv) {
+  mat3x2 mat = A_MATRIX3X2;
+  vec2 v = {11.0f, 21.0f};
+
+  int  i;
+  vec3 dest;
+  float res = 0.0;
+
+  GLM(mat3x2_mulv)(mat, v, dest);
+
+  for (i = 0; i < 3; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x2_transpose) {
+  mat3x2 m1 = A_MATRIX3X2;
+
+  mat2x3 m2;
+  mat2x3 m3 = A_MATRIX3X2_TRANSPOSE;
+  GLM(mat3x2_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat2x3_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x2_scale) {
+  mat3x2 m1 = A_MATRIX3X2;
+  mat3x2 m2 = A_MATRIX3X2;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat3x2_scale)(m1, (float) scale);
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/src/test_mat3x4.h

@@ -7,6 +7,9 @@
 
 #include "test_common.h"
 
+#define A_MATRIX3X4 {{1,2,4,5},{6,7,8,9},{10,11,12,13}}
+#define A_MATRIX3X4_TRANSPOSE {{1,6,10}, {2,7,1}, {4,8,12}, {5,9,13}}
+
 #ifndef CGLM_TEST_MAT3X4_ONCE
 #define CGLM_TEST_MAT3X4_ONCE
 
@@ -24,6 +27,31 @@ TEST_IMPL(MACRO_GLM_MAT3X4_ZERO) {
 
 #endif /* CGLM_TEST_MAT3X4_ONCE */
 
+TEST_IMPL(GLM_PREFIX, mat3x4_copy) {
+  mat3x4 m1 = A_MATRIX3X4;
+  mat3x4 m2 = GLM_MAT3X4_ZERO_INIT;
+
+  GLM(mat3x4_copy)(m1, m2);
+
+  test_assert_mat3x4_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x4_zero) {
+  mat3x4 m1 = GLM_MAT3X4_ZERO_INIT;
+  mat3x4 m2 = GLM_MAT3X4_ZERO_INIT;
+  mat3x4 m3;
+
+  GLM(mat3x4_zero)(m3);
+
+  ASSERTIFY(test_assert_mat3x4_eq_zero(m1))
+  ASSERTIFY(test_assert_mat3x4_eq_zero(m2))
+  ASSERTIFY(test_assert_mat3x4_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
 TEST_IMPL(GLM_PREFIX, mat3x4_make) {
   float src[36] = {
     0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f, 2.3f, 4.2f, 66.5f, 23.7f, 6.6f, 8.9f,
@@ -57,3 +85,77 @@ TEST_IMPL(GLM_PREFIX, mat3x4_make) {
 
   TEST_SUCCESS
 }
+
+TEST_IMPL(GLM_PREFIX, mat3x4_mul) {
+  mat3x4 m1 = GLM_MAT3X4_ZERO_INIT;
+  mat4x3 m2 = GLM_MAT4X3_ZERO_INIT;
+
+  mat3 m3 = GLM_MAT3_ZERO_INIT;
+  mat3 m4 = GLM_MAT3_ZERO_INIT;
+
+  int i, j, k;
+
+  test_rand_mat3x4(m1);
+  test_rand_mat4x3(m2);
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      for (k = 0; k < 4; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat3x4_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat3_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x4_mulv) {
+  mat3x4 mat = A_MATRIX3X4;
+  vec4 v = {11.0f, 21.0f, 31.0f, 41.0f};
+
+  int  i;
+  vec3 dest;
+  float res = 0.0;
+
+  GLM(mat3x4_mulv)(mat, v, dest);
+
+  for (i = 0; i < 3; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x4_transpose) {
+  mat3x4 m1 = A_MATRIX3X4;
+
+  mat4x3 m2;
+  mat4x3 m3 = A_MATRIX3X2_TRANSPOSE;
+  GLM(mat3x4_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat4x3_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat3x4_scale) {
+  mat3x4 m1 = A_MATRIX3X4;
+  mat3x4 m2 = A_MATRIX3X4;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat3x4_scale)(m1, (float) scale);
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 4; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/src/test_mat4x2.h

@@ -7,6 +7,9 @@
 
 #include "test_common.h"
 
+#define A_MATRIX4X2 {{1,2},{3,4},{5,6},{7,8}}
+#define A_MATRIX4X2_TRANSPOSE {{1,3,5,7}, {2,4,6,8}}
+
 #ifndef CGLM_TEST_MAT4X2_ONCE
 #define CGLM_TEST_MAT4X2_ONCE
 
@@ -24,6 +27,31 @@ TEST_IMPL(MACRO_GLM_MAT4X2_ZERO) {
 
 #endif /* CGLM_TEST_MAT4X2_ONCE */
 
+TEST_IMPL(GLM_PREFIX, mat4x2_copy) {
+  mat4x2 m1 = A_MATRIX4X2;
+  mat4x2 m2 = GLM_MAT4X2_ZERO_INIT;
+
+  GLM(mat4x2_copy)(m1, m2);
+
+  test_assert_mat4x2_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x2_zero) {
+  mat4x2 m1 = GLM_MAT4X2_ZERO_INIT;
+  mat4x2 m2 = GLM_MAT4X2_ZERO_INIT;
+  mat4x2 m3;
+
+  GLM(mat4x2_zero)(m3);
+
+  ASSERTIFY(test_assert_mat4x2_eq_zero(m1))
+  ASSERTIFY(test_assert_mat4x2_eq_zero(m2))
+  ASSERTIFY(test_assert_mat4x2_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
 TEST_IMPL(GLM_PREFIX, mat4x2_make) {
   float src[24] = {
     0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f, 2.3f, 4.2f,
@@ -54,3 +82,77 @@ TEST_IMPL(GLM_PREFIX, mat4x2_make) {
 
   TEST_SUCCESS
 }
+
+TEST_IMPL(GLM_PREFIX, mat4x2_mul) {
+  mat4x2 m1 = GLM_MAT4X2_ZERO_INIT;
+  mat2x4 m2 = GLM_MAT2X4_ZERO_INIT;
+
+  mat4 m3 = GLM_MAT4_ZERO_INIT;
+  mat4 m4 = GLM_MAT4_ZERO_INIT;
+
+  int i, j, k;
+
+  test_rand_mat4x2(m1);
+  test_rand_mat2x4(m2);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 2; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat4x2_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x2_mulv) {
+  mat4x2 mat = A_MATRIX4X2;
+  vec2 v = {11.0f, 21.0f};
+
+  int  i;
+  vec4 dest;
+  float res = 0.0;
+
+  GLM(mat4x2_mulv)(mat, v, dest);
+
+  for (i = 0; i < 4; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x2_transpose) {
+  mat4x2 m1 = A_MATRIX4X2;
+
+  mat2x4 m2;
+  mat2x4 m3 = A_MATRIX4X2_TRANSPOSE;
+  GLM(mat4x2_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat2x4_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x2_scale) {
+  mat4x2 m1 = A_MATRIX4X2;
+  mat4x2 m2 = A_MATRIX4X2;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat4x2_scale)(m1, (float) scale);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 2; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/src/test_mat4x3.h

@@ -7,6 +7,9 @@
 
 #include "test_common.h"
 
+#define A_MATRIX4X3 {{1,2,3},{4,5,6},{7,8,9},{10,11,12}}
+#define A_MATRIX4X3_TRANSPOSE {{1,4,7,10},{2,5,8,11},{3,6,9,12}}
+
 #ifndef CGLM_TEST_MAT4X3_ONCE
 #define CGLM_TEST_MAT4X3_ONCE
 
@@ -24,6 +27,31 @@ TEST_IMPL(MACRO_GLM_MAT4X3_ZERO) {
 
 #endif /* CGLM_TEST_MAT4X3_ONCE */
 
+TEST_IMPL(GLM_PREFIX, mat4x3_copy) {
+  mat4x3 m1 = A_MATRIX4X3;
+  mat4x3 m2 = GLM_MAT4X3_ZERO_INIT;
+
+  GLM(mat4x3_copy)(m1, m2);
+
+  test_assert_mat4x3_eq(m1, m2);
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x3_zero) {
+  mat4x3 m1 = GLM_MAT4X3_ZERO_INIT;
+  mat4x3 m2 = GLM_MAT4X3_ZERO_INIT;
+  mat4x3 m3;
+
+  GLM(mat4x3_zero)(m3);
+
+  ASSERTIFY(test_assert_mat4x3_eq_zero(m1))
+  ASSERTIFY(test_assert_mat4x3_eq_zero(m2))
+  ASSERTIFY(test_assert_mat4x3_eq_zero(m3))
+
+  TEST_SUCCESS
+}
+
 TEST_IMPL(GLM_PREFIX, mat4x3_make) {
   float src[36] = {
     0.5f, 1.7f, 10.3f, 4.2f, 8.9f, 1.1f, 2.3f, 4.2f, 5.3f, 4.8f, 96.3f, 13.7f,
@@ -58,3 +86,77 @@ TEST_IMPL(GLM_PREFIX, mat4x3_make) {
 
   TEST_SUCCESS
 }
+
+TEST_IMPL(GLM_PREFIX, mat4x3_mul) {
+  mat4x3 m1 = GLM_MAT4X3_ZERO_INIT;
+  mat3x4 m2 = GLM_MAT3X4_ZERO_INIT;
+
+  mat4 m3 = GLM_MAT4_ZERO_INIT;
+  mat4 m4 = GLM_MAT4_ZERO_INIT;
+
+  int i, j, k;
+
+  test_rand_mat4x3(m1);
+  test_rand_mat3x4(m2);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 3; k++) {
+        m4[i][j] += m1[i][k] * m2[k][j];
+      }
+    }
+  }
+
+  GLM(mat4x3_mul)(m1, m2, m3);
+  ASSERTIFY(test_assert_mat4_eq(m3, m4))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x3_mulv) {
+  mat4x3 mat = A_MATRIX4X3;
+  vec3 v = {11.0f, 21.0f, 31.0f};
+
+  int  i;
+  vec4 dest;
+  float res = 0.0;
+
+  GLM(mat4x3_mulv)(mat, v, dest);
+
+  for (i = 0; i < 4; i++) {
+    res = mat[i][0] * v[0] + mat[i][1] * v[1] + mat[i][2] * v[2];
+    ASSERT(test_eq(dest[i], res))
+  }
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x3_transpose) {
+  mat4x3 m1 = A_MATRIX4X3;
+
+  mat3x4 m2;
+  mat3x4 m3 = A_MATRIX4X3_TRANSPOSE;
+  GLM(mat4x3_transpose)(m1, m2);
+
+  ASSERTIFY(test_assert_mat3x4_eq(m2, m3))
+
+  TEST_SUCCESS
+}
+
+TEST_IMPL(GLM_PREFIX, mat4x3_scale) {
+  mat4x3 m1 = A_MATRIX4X3;
+  mat4x3 m2 = A_MATRIX4X3;
+  int i, j, scale;
+
+  scale = rand() % 100;
+
+  GLM(mat4x3_scale)(m1, (float) scale);
+
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 3; j++) {
+      ASSERT(test_eq(m1[i][j], m2[i][j] * scale))
+    }
+  }
+
+  TEST_SUCCESS
+}

test/tests.h

@@ -155,15 +155,39 @@ TEST_DECLARE(glmc_mat4_make)
 
 TEST_DECLARE(MACRO_GLM_MAT4X2_ZERO_INIT)
 TEST_DECLARE(MACRO_GLM_MAT4X2_ZERO)
+TEST_DECLARE(glm_mat4x2_copy)
+TEST_DECLARE(glm_mat4x2_zero)
 TEST_DECLARE(glm_mat4x2_make)
+TEST_DECLARE(glm_mat4x2_mul)
+TEST_DECLARE(glm_mat4x2_mulv)
+TEST_DECLARE(glm_mat4x2_transpose)
+TEST_DECLARE(glm_mat4x2_scale)
 
+TEST_DECLARE(glmc_mat4x2_copy)
+TEST_DECLARE(glmc_mat4x2_zero)
 TEST_DECLARE(glmc_mat4x2_make)
+TEST_DECLARE(glmc_mat4x2_mul)
+TEST_DECLARE(glmc_mat4x2_mulv)
+TEST_DECLARE(glmc_mat4x2_transpose)
+TEST_DECLARE(glmc_mat4x2_scale)
 
 TEST_DECLARE(MACRO_GLM_MAT4X3_ZERO_INIT)
 TEST_DECLARE(MACRO_GLM_MAT4X3_ZERO)
+TEST_DECLARE(glm_mat4x3_copy)
+TEST_DECLARE(glm_mat4x3_zero)
 TEST_DECLARE(glm_mat4x3_make)
+TEST_DECLARE(glm_mat4x3_mul)
+TEST_DECLARE(glm_mat4x3_mulv)
+TEST_DECLARE(glm_mat4x3_transpose)
+TEST_DECLARE(glm_mat4x3_scale)
 
+TEST_DECLARE(glmc_mat4x3_copy)
+TEST_DECLARE(glmc_mat4x3_zero)
 TEST_DECLARE(glmc_mat4x3_make)
+TEST_DECLARE(glmc_mat4x3_mul)
+TEST_DECLARE(glmc_mat4x3_mulv)
+TEST_DECLARE(glmc_mat4x3_transpose)
+TEST_DECLARE(glmc_mat4x3_scale)
 
 /* mat3 */
 TEST_DECLARE(glm_mat3_copy)
@@ -204,9 +228,21 @@ TEST_DECLARE(glmc_mat3_make)
 
 TEST_DECLARE(MACRO_GLM_MAT3X2_ZERO_INIT)
 TEST_DECLARE(MACRO_GLM_MAT3X2_ZERO)
+TEST_DECLARE(glm_mat3x2_copy)
+TEST_DECLARE(glm_mat3x2_zero)
 TEST_DECLARE(glm_mat3x2_make)
+TEST_DECLARE(glm_mat3x2_mul)
+TEST_DECLARE(glm_mat3x2_mulv)
+TEST_DECLARE(glm_mat3x2_transpose)
+TEST_DECLARE(glm_mat3x2_scale)
 
+TEST_DECLARE(glmc_mat3x2_copy)
+TEST_DECLARE(glmc_mat3x2_zero)
 TEST_DECLARE(glmc_mat3x2_make)
+TEST_DECLARE(glmc_mat3x2_mul)
+TEST_DECLARE(glmc_mat3x2_mulv)
+TEST_DECLARE(glmc_mat3x2_transpose)
+TEST_DECLARE(glmc_mat3x2_scale)
 
 TEST_DECLARE(MACRO_GLM_MAT3X4_ZERO_INIT)
 TEST_DECLARE(MACRO_GLM_MAT3X4_ZERO)
@@ -254,15 +290,39 @@ TEST_DECLARE(glmc_mat2_make)
 
 TEST_DECLARE(MACRO_GLM_MAT2X3_ZERO_INIT)
 TEST_DECLARE(MACRO_GLM_MAT2X3_ZERO)
+TEST_DECLARE(glm_mat2x3_copy)
+TEST_DECLARE(glm_mat2x3_zero)
 TEST_DECLARE(glm_mat2x3_make)
+TEST_DECLARE(glm_mat2x3_mul)
+TEST_DECLARE(glm_mat2x3_mulv)
+TEST_DECLARE(glm_mat2x3_transpose)
+TEST_DECLARE(glm_mat2x3_scale)
 
+TEST_DECLARE(glmc_mat2x3_copy)
+TEST_DECLARE(glmc_mat2x3_zero)
 TEST_DECLARE(glmc_mat2x3_make)
+TEST_DECLARE(glmc_mat2x3_mul)
+TEST_DECLARE(glmc_mat2x3_mulv)
+TEST_DECLARE(glmc_mat2x3_transpose)
+TEST_DECLARE(glmc_mat2x3_scale)
 
 TEST_DECLARE(MACRO_GLM_MAT2X4_ZERO_INIT)
 TEST_DECLARE(MACRO_GLM_MAT2X4_ZERO)
+TEST_DECLARE(glm_mat2x4_copy)
+TEST_DECLARE(glm_mat2x4_zero)
 TEST_DECLARE(glm_mat2x4_make)
+TEST_DECLARE(glm_mat2x4_mul)
+TEST_DECLARE(glm_mat2x4_mulv)
+TEST_DECLARE(glm_mat2x4_transpose)
+TEST_DECLARE(glm_mat2x4_scale)
 
+TEST_DECLARE(glmc_mat2x4_copy)
+TEST_DECLARE(glmc_mat2x4_zero)
 TEST_DECLARE(glmc_mat2x4_make)
+TEST_DECLARE(glmc_mat2x4_mul)
+TEST_DECLARE(glmc_mat2x4_mulv)
+TEST_DECLARE(glmc_mat2x4_transpose)
+TEST_DECLARE(glmc_mat2x4_scale)
 
 /* camera (incl [LR]H cross [NZ]O) */
 TEST_DECLARE(glm_perspective_lh_zo)
@@ -1058,15 +1118,39 @@ TEST_LIST {
 
   TEST_ENTRY(MACRO_GLM_MAT4X2_ZERO_INIT)
   TEST_ENTRY(MACRO_GLM_MAT4X2_ZERO)
+  TEST_ENTRY(glm_mat4x2_copy)
+  TEST_ENTRY(glm_mat4x2_zero)
   TEST_ENTRY(glm_mat4x2_make)
+  TEST_ENTRY(glm_mat4x2_mul)
+  TEST_ENTRY(glm_mat4x2_mulv)
+  TEST_ENTRY(glm_mat4x2_transpose)
+  TEST_ENTRY(glm_mat4x2_scale)
 
+  TEST_ENTRY(glmc_mat4x2_copy)
+  TEST_ENTRY(glmc_mat4x2_zero)
   TEST_ENTRY(glmc_mat4x2_make)
+  TEST_ENTRY(glmc_mat4x2_mul)
+  TEST_ENTRY(glmc_mat4x2_mulv)
+  TEST_ENTRY(glmc_mat4x2_transpose)
+  TEST_ENTRY(glmc_mat4x2_scale)
 
   TEST_ENTRY(MACRO_GLM_MAT4X3_ZERO_INIT)
   TEST_ENTRY(MACRO_GLM_MAT4X3_ZERO)
+  TEST_ENTRY(glm_mat4x3_copy)
+  TEST_ENTRY(glm_mat4x3_zero)
   TEST_ENTRY(glm_mat4x3_make)
+  TEST_ENTRY(glm_mat4x3_mul)
+  TEST_ENTRY(glm_mat4x3_mulv)
+  TEST_ENTRY(glm_mat4x3_transpose)
+  TEST_ENTRY(glm_mat4x3_scale)
 
+  TEST_ENTRY(glmc_mat4x3_copy)
+  TEST_ENTRY(glmc_mat4x3_zero)
   TEST_ENTRY(glmc_mat4x3_make)
+  TEST_ENTRY(glmc_mat4x3_mul)
+  TEST_ENTRY(glmc_mat4x3_mulv)
+  TEST_ENTRY(glmc_mat4x3_transpose)
+  TEST_ENTRY(glmc_mat4x3_scale)
 
   /* mat3 */
   TEST_ENTRY(glm_mat3_copy)
@@ -1107,9 +1191,21 @@ TEST_LIST {
 
   TEST_ENTRY(MACRO_GLM_MAT3X2_ZERO_INIT)
   TEST_ENTRY(MACRO_GLM_MAT3X2_ZERO)
+  TEST_ENTRY(glm_mat3x2_copy)
+  TEST_ENTRY(glm_mat3x2_zero)
   TEST_ENTRY(glm_mat3x2_make)
+  TEST_ENTRY(glm_mat3x2_mul)
+  TEST_ENTRY(glm_mat3x2_mulv)
+  TEST_ENTRY(glm_mat3x2_transpose)
+  TEST_ENTRY(glm_mat3x2_scale)
 
+  TEST_ENTRY(glmc_mat3x2_copy)
+  TEST_ENTRY(glmc_mat3x2_zero)
   TEST_ENTRY(glmc_mat3x2_make)
+  TEST_ENTRY(glmc_mat3x2_mul)
+  TEST_ENTRY(glmc_mat3x2_mulv)
+  TEST_ENTRY(glmc_mat3x2_transpose)
+  TEST_ENTRY(glmc_mat3x2_scale)
 
   TEST_ENTRY(MACRO_GLM_MAT3X4_ZERO_INIT)
   TEST_ENTRY(MACRO_GLM_MAT3X4_ZERO)
@@ -1157,15 +1253,39 @@ TEST_LIST {
 
   TEST_ENTRY(MACRO_GLM_MAT2X3_ZERO_INIT)
   TEST_ENTRY(MACRO_GLM_MAT2X3_ZERO)
+  TEST_ENTRY(glm_mat2x3_copy)
+  TEST_ENTRY(glm_mat2x3_zero)
   TEST_ENTRY(glm_mat2x3_make)
+  TEST_ENTRY(glm_mat2x3_mul)
+  TEST_ENTRY(glm_mat2x3_mulv)
+  TEST_ENTRY(glm_mat2x3_transpose)
+  TEST_ENTRY(glm_mat2x3_scale)
 
+  TEST_ENTRY(glmc_mat2x3_copy)
+  TEST_ENTRY(glmc_mat2x3_zero)
   TEST_ENTRY(glmc_mat2x3_make)
+  TEST_ENTRY(glmc_mat2x3_mul)
+  TEST_ENTRY(glmc_mat2x3_mulv)
+  TEST_ENTRY(glmc_mat2x3_transpose)
+  TEST_ENTRY(glmc_mat2x3_scale)
 
   TEST_ENTRY(MACRO_GLM_MAT2X4_ZERO_INIT)
   TEST_ENTRY(MACRO_GLM_MAT2X4_ZERO)
+  TEST_ENTRY(glm_mat2x4_copy)
+  TEST_ENTRY(glm_mat2x4_zero)
   TEST_ENTRY(glm_mat2x4_make)
+  TEST_ENTRY(glm_mat2x4_mul)
+  TEST_ENTRY(glm_mat2x4_mulv)
+  TEST_ENTRY(glm_mat2x4_transpose)
+  TEST_ENTRY(glm_mat2x4_scale)
 
-  TEST_ENTRY(glmc_mat2x4_make)
+  TEST_ENTRY(glm_mat2x4_copy)
+  TEST_ENTRY(glm_mat2x4_zero)
+  TEST_ENTRY(glm_mat2x4_make)
+  TEST_ENTRY(glm_mat2x4_mul)
+  TEST_ENTRY(glm_mat2x4_mulv)
+  TEST_ENTRY(glm_mat2x4_transpose)
+  TEST_ENTRY(glm_mat2x4_scale)
 
   /* camera (incl [LR]H cross [NZ]O) */
   TEST_ENTRY(glm_perspective_lh_zo)