diff --git a/include/cglm/mat2.h b/include/cglm/mat2.h index e7a865b..69d27d3 100644 --- a/include/cglm/mat2.h +++ b/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; diff --git a/test/src/test_common.c b/test/src/test_common.c index 6459aa8..c352c89 100644 --- a/test/src/test_common.c +++ b/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); } } diff --git a/test/src/test_common.h b/test/src/test_common.h index 6dcb878..86801b6 100644 --- a/test/src/test_common.h +++ b/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); diff --git a/test/src/test_mat2.h b/test/src/test_mat2.h new file mode 100644 index 0000000..9141caf --- /dev/null +++ b/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 diff --git a/test/src/tests.c b/test/src/tests.c index 90b8dee..669b33c 100644 --- a/test/src/tests.c +++ b/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" diff --git a/test/tests.h b/test/tests.h index e026ed0..4c9a552 100644 --- a/test/tests.h +++ b/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)