From 225467d61b653e6c860f968477d99cc409a7b62b Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Fri, 18 Jul 2025 07:19:09 -0500 Subject: [PATCH 01/12] :sparkles: Add vec --- include/juno/math/juno_la.h | 25 +++++++++++++++++-------- tests/test_la.c | 18 ++++++++++++++++-- 2 files changed, 33 insertions(+), 10 deletions(-) diff --git a/include/juno/math/juno_la.h b/include/juno/math/juno_la.h index 6369788a..602f852d 100644 --- a/include/juno/math/juno_la.h +++ b/include/juno/math/juno_la.h @@ -8,26 +8,35 @@ extern "C" { #endif -typedef struct JUNO_MATH_MAT_API_T JUNO_MATH_MAT_API_T; -JUNO_MODULE_DECLARE(JUNO_MATH_MAT_T); +typedef struct JUNO_MATH_MAT_FLOAT_API_T JUNO_MATH_MAT_FLOAT_API_T; +JUNO_MODULE_DECLARE(JUNO_MATH_MAT_FLOAT_T); -typedef struct JUNO_MATH_MAT_ROOT_TAG JUNO_MODULE_ROOT(JUNO_MATH_MAT_API_T, +typedef struct JUNO_MATH_MAT_ROOT_TAG JUNO_MODULE_ROOT(JUNO_MATH_MAT_FLOAT_API_T, size_t iNDim; size_t iMDim; ) JUNO_MATH_MAT_ROOT_T; -typedef struct JUNO_MATH_MAT_NxM_TAG JUNO_MODULE_DERIVE(JUNO_MATH_MAT_ROOT_T, +typedef struct JUNO_MATH_MAT_NxM_FLOAT_TAG JUNO_MODULE_DERIVE(JUNO_MATH_MAT_ROOT_T, float tMat[]; -) JUNO_MATH_MAT_NxM_T; +) JUNO_MATH_MAT_NxM_FLOAT_T; -#define JUNO_MATH_MAT_NxM(TYPE_NAME_T, N, M) \ +typedef struct JUNO_MATH_VEC_FLOAT_TAG JUNO_MODULE_DERIVE(JUNO_MATH_MAT_ROOT_T, + float tVec[]; +) JUNO_MATH_VEC_FLOAT_T; + +#define JUNO_MATH_MAT_NxM_FLOAT(TYPE_NAME_T, N, M) \ typedef struct TYPE_NAME_T JUNO_MODULE_DERIVE(JUNO_MATH_MAT_ROOT_T, \ float tMat[N][M]; \ ) TYPE_NAME_T; -struct JUNO_MATH_MAT_API_T +#define JUNO_MATH_VEC_N_FLOAT(TYPE_NAME_T, N) \ +typedef struct TYPE_NAME_T JUNO_MODULE_DERIVE(JUNO_MATH_MAT_ROOT_T, \ + float tVec[N]; \ +) TYPE_NAME_T; + +struct JUNO_MATH_MAT_FLOAT_API_T { - JUNO_RESULT_BOOL_T (*Equals)(JUNO_MATH_MAT_T *ptMat1, JUNO_MATH_MAT_T *ptMat2); + JUNO_RESULT_BOOL_T (*Equals)(JUNO_MATH_MAT_FLOAT_T *ptMat1, JUNO_MATH_MAT_FLOAT_T *ptMat2); }; #ifdef __cplusplus diff --git a/tests/test_la.c b/tests/test_la.c index 4255862e..781c93f3 100644 --- a/tests/test_la.c +++ b/tests/test_la.c @@ -13,7 +13,8 @@ void tearDown(void) { } -JUNO_MATH_MAT_NxM(MAT_3x3, 3, 3); +JUNO_MATH_MAT_NxM_FLOAT(MAT_3x3, 3, 3); +JUNO_MATH_VEC_N_FLOAT(VEC_3_T, 3); static void test_mat_index(void) { @@ -24,15 +25,28 @@ static void test_mat_index(void) for(size_t j = 0; j < 3; j++) { TEST_ASSERT_EQUAL_FLOAT(tTruth[i][j], tMat3x3.tMat[i][j]); - JUNO_MATH_MAT_NxM_T *ptMatNxM = (JUNO_MATH_MAT_NxM_T*) &tMat3x3; + JUNO_MATH_MAT_NxM_FLOAT_T *ptMatNxM = (JUNO_MATH_MAT_NxM_FLOAT_T*) &tMat3x3; TEST_ASSERT_EQUAL_FLOAT(tTruth[i][j], ptMatNxM->tMat[i*ptMatNxM->tRoot.iMDim + j]); } } } +static void test_vec_index(void) +{ + VEC_3_T tVec = {.tRoot = {}, {0, 1, 2}}; + JUNO_MATH_VEC_FLOAT_T *ptFVec = (JUNO_MATH_VEC_FLOAT_T *) &tVec; + float tTruth[3] = {0, 1, 2}; + for(size_t j = 0; j < 3; j++) + { + TEST_ASSERT_EQUAL_FLOAT(tTruth[j], tVec.tVec[j]); + TEST_ASSERT_EQUAL_FLOAT(tTruth[j], ptFVec->tVec[j]); + } +} + int main(void) { UNITY_BEGIN(); RUN_TEST(test_mat_index); + RUN_TEST(test_vec_index); return UNITY_END(); } From 9e656887dc3560f0a6cd48551c79f17782553262 Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Fri, 18 Jul 2025 21:42:01 -0500 Subject: [PATCH 02/12] :sparkles: add vecs with types --- include/juno/math/juno_la.h | 67 ++++++++++++++++++----------- include/juno/math/juno_math.h | 6 +++ include/juno/math/juno_math_types.h | 19 ++++++++ include/juno/types.h | 2 + tests/test_la.c | 44 +++++++++---------- 5 files changed, 91 insertions(+), 47 deletions(-) create mode 100644 include/juno/math/juno_math_types.h diff --git a/include/juno/math/juno_la.h b/include/juno/math/juno_la.h index 602f852d..ab032079 100644 --- a/include/juno/math/juno_la.h +++ b/include/juno/math/juno_la.h @@ -4,40 +4,59 @@ #include "juno/module.h" #include "juno/types.h" #include +#include "juno_math_types.h" + #ifdef __cplusplus extern "C" { #endif -typedef struct JUNO_MATH_MAT_FLOAT_API_T JUNO_MATH_MAT_FLOAT_API_T; -JUNO_MODULE_DECLARE(JUNO_MATH_MAT_FLOAT_T); +/// The linear algebra API +typedef struct JUNO_MATH_LA_API_T JUNO_MATH_LA_API_T; +JUNO_MODULE_DECLARE(JUNO_MATH_VEC_T); + +#define JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T, N, type) \ +typedef struct TYPE_NAME_T \ +{ \ + const size_t iNdim; \ + type tVec[N]; \ +} TYPE_NAME_T; + +#define JUNO_MATH_CREATE_VEC(TYPE_NAME_T, N) \ +JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_FLOAT_T, N, float); \ +JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_DOUBLE_T, N, double); \ +JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_INT8_T, N, int8_t); \ +JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_UINT8_T, N, uint8_t); \ +JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_INT16_T, N, int16_t); \ +JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_UINT16_T, N, uint16_t); \ +JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_INT32_T, N, int32_t); \ +JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_UINT32_T, N, uint32_t); \ +JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_INT64_T, N, int64_t); \ +JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_UINT64_T, N, uint64_t); + +#define JUNO_MATH_NEW_VEC_TYPE(tVec, TYPE) ((JUNO_MATH_VEC_##TYPE##_T *)&tVec) +#define JUNO_MATH_NEW_VEC_FLOAT(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, FLOAT) +#define JUNO_MATH_NEW_VEC_DOUBLE(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, DOUBLE) +#define JUNO_MATH_NEW_VEC_INT8(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, INT8) +#define JUNO_MATH_NEW_VEC_UINT8(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, UINT8) +#define JUNO_MATH_NEW_VEC_INT16(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, INT16) +#define JUNO_MATH_NEW_VEC_UINT16(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, UINT16) +#define JUNO_MATH_NEW_VEC_INT32(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, INT32) +#define JUNO_MATH_NEW_VEC_UINT32(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, UINT32) +#define JUNO_MATH_NEW_VEC_INT64(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, INT64) +#define JUNO_MATH_NEW_VEC_UINT64(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, UINT64) -typedef struct JUNO_MATH_MAT_ROOT_TAG JUNO_MODULE_ROOT(JUNO_MATH_MAT_FLOAT_API_T, - size_t iNDim; - size_t iMDim; -) JUNO_MATH_MAT_ROOT_T; -typedef struct JUNO_MATH_MAT_NxM_FLOAT_TAG JUNO_MODULE_DERIVE(JUNO_MATH_MAT_ROOT_T, - float tMat[]; -) JUNO_MATH_MAT_NxM_FLOAT_T; +JUNO_MATH_CREATE_VEC(JUNO_MATH_VEC, ); -typedef struct JUNO_MATH_VEC_FLOAT_TAG JUNO_MODULE_DERIVE(JUNO_MATH_MAT_ROOT_T, - float tVec[]; -) JUNO_MATH_VEC_FLOAT_T; +#define JUNO_MATH_NEW_VEC2(...) {2, {__VA_ARGS__}} +JUNO_MATH_CREATE_VEC(JUNO_MATH_VEC2, 2); -#define JUNO_MATH_MAT_NxM_FLOAT(TYPE_NAME_T, N, M) \ -typedef struct TYPE_NAME_T JUNO_MODULE_DERIVE(JUNO_MATH_MAT_ROOT_T, \ - float tMat[N][M]; \ -) TYPE_NAME_T; +#define JUNO_MATH_NEW_VEC3(...) {3, {__VA_ARGS__}} +JUNO_MATH_CREATE_VEC(JUNO_MATH_VEC3, 3); -#define JUNO_MATH_VEC_N_FLOAT(TYPE_NAME_T, N) \ -typedef struct TYPE_NAME_T JUNO_MODULE_DERIVE(JUNO_MATH_MAT_ROOT_T, \ - float tVec[N]; \ -) TYPE_NAME_T; +#define JUNO_MATH_NEW_VEC4(...) {4, {__VA_ARGS__}} +JUNO_MATH_CREATE_VEC(JUNO_MATH_VEC4, 4); -struct JUNO_MATH_MAT_FLOAT_API_T -{ - JUNO_RESULT_BOOL_T (*Equals)(JUNO_MATH_MAT_FLOAT_T *ptMat1, JUNO_MATH_MAT_FLOAT_T *ptMat2); -}; #ifdef __cplusplus } diff --git a/include/juno/math/juno_math.h b/include/juno/math/juno_math.h index 1fe4f13b..b5aa087f 100644 --- a/include/juno/math/juno_math.h +++ b/include/juno/math/juno_math.h @@ -1,12 +1,18 @@ #ifndef JUNO_MATH_H #define JUNO_MATH_H +#include "juno/module.h" +#include "juno_math_types.h" #include "juno_la.h" #ifdef __cplusplus extern "C" { #endif +struct JUNO_MATH_API_T +{ + const JUNO_MATH_LA_API_T *ptLaApi; +}; #ifdef __cplusplus } diff --git a/include/juno/math/juno_math_types.h b/include/juno/math/juno_math_types.h new file mode 100644 index 00000000..202e9f45 --- /dev/null +++ b/include/juno/math/juno_math_types.h @@ -0,0 +1,19 @@ +#ifndef JUNO_MATH_TYPES_H +#define JUNO_MATH_TYPES_H + +#include "juno/module.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +typedef struct JUNO_MATH_API_T JUNO_MATH_API_T; +JUNO_MODULE_DECLARE(JUNO_MATH_T); + +typedef struct JUNO_MATH_ROOT_TAG JUNO_MODULE_ROOT(JUNO_MATH_API_T, JUNO_MODULE_EMPTY) JUNO_MATH_ROOT_T; + +#ifdef __cplusplus +} +#endif +#endif \ No newline at end of file diff --git a/include/juno/types.h b/include/juno/types.h index cb4a871e..b6de9e22 100644 --- a/include/juno/types.h +++ b/include/juno/types.h @@ -7,8 +7,10 @@ extern "C" #endif #include #include +#include typedef struct JUNO_RESULT_BOOL_TAG JUNO_MODULE_RESULT(bool) JUNO_RESULT_BOOL_T; +typedef struct JUNO_RESULT_UINT32_TAG JUNO_MODULE_RESULT(uint32_t) JUNO_RESULT_UINT32_T; #ifdef __cplusplus } diff --git a/tests/test_la.c b/tests/test_la.c index 781c93f3..457cb55e 100644 --- a/tests/test_la.c +++ b/tests/test_la.c @@ -3,7 +3,7 @@ #include "unity_internals.h" #include #include -#include "juno/math/juno_la.h" +#include "juno/math/juno_math.h" void setUp(void) { @@ -13,40 +13,38 @@ void tearDown(void) { } -JUNO_MATH_MAT_NxM_FLOAT(MAT_3x3, 3, 3); -JUNO_MATH_VEC_N_FLOAT(VEC_3_T, 3); -static void test_mat_index(void) -{ - MAT_3x3 tMat3x3 = {.tRoot = {.iNDim = 3, .iMDim = 3}, .tMat = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}}}; - float tTruth[3][3] ={{0, 1, 2}, {3, 4, 5}, {6, 7, 8}}; - for(size_t i = 0; i < 3; i++) - { - for(size_t j = 0; j < 3; j++) - { - TEST_ASSERT_EQUAL_FLOAT(tTruth[i][j], tMat3x3.tMat[i][j]); - JUNO_MATH_MAT_NxM_FLOAT_T *ptMatNxM = (JUNO_MATH_MAT_NxM_FLOAT_T*) &tMat3x3; - TEST_ASSERT_EQUAL_FLOAT(tTruth[i][j], ptMatNxM->tMat[i*ptMatNxM->tRoot.iMDim + j]); - } - } -} +// static void test_mat_index(void) +// { +// MAT_3x3 tMat3x3 = {.tRoot = {.iNDim = 3, .iMDim = 3}, .tMat = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}}}; +// float tTruth[3][3] ={{0, 1, 2}, {3, 4, 5}, {6, 7, 8}}; +// for(size_t i = 0; i < 3; i++) +// { +// for(size_t j = 0; j < 3; j++) +// { +// TEST_ASSERT_EQUAL_FLOAT(tTruth[i][j], tMat3x3.tMat[i][j]); +// JUNO_MATH_MAT_NxM_FLOAT_T *ptMatNxM = (JUNO_MATH_MAT_NxM_FLOAT_T*) &tMat3x3; +// TEST_ASSERT_EQUAL_FLOAT(tTruth[i][j], ptMatNxM->tMat[i*ptMatNxM->tRoot.iMDim + j]); +// } +// } +// } static void test_vec_index(void) { - VEC_3_T tVec = {.tRoot = {}, {0, 1, 2}}; - JUNO_MATH_VEC_FLOAT_T *ptFVec = (JUNO_MATH_VEC_FLOAT_T *) &tVec; - float tTruth[3] = {0, 1, 2}; + JUNO_MATH_VEC3_FLOAT_T tMyVec = JUNO_MATH_NEW_VEC3(1,2,3); + JUNO_MATH_VEC_FLOAT_T *ptMyVec = JUNO_MATH_NEW_VEC_FLOAT(tMyVec); + + float tTruth[3] = {1, 2,3}; for(size_t j = 0; j < 3; j++) { - TEST_ASSERT_EQUAL_FLOAT(tTruth[j], tVec.tVec[j]); - TEST_ASSERT_EQUAL_FLOAT(tTruth[j], ptFVec->tVec[j]); + TEST_ASSERT_EQUAL_FLOAT(tTruth[j], tMyVec.tVec[j]); + TEST_ASSERT_EQUAL_FLOAT(tTruth[j], ptMyVec->tVec[j]); } } int main(void) { UNITY_BEGIN(); - RUN_TEST(test_mat_index); RUN_TEST(test_vec_index); return UNITY_END(); } From caa077503f31bc2c652ae3c70966d9745fa24e27 Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Sat, 19 Jul 2025 11:52:47 -0500 Subject: [PATCH 03/12] :sparkles: Create narr --- CMakeLists.txt | 2 +- include/juno/math/juno_la.h | 64 ------------ include/juno/math/juno_math.h | 5 +- include/juno/math/juno_math_constants.h | 14 +++ include/juno/math/juno_narr.h | 132 ++++++++++++++++++++++++ tests/test_la.c | 11 +- 6 files changed, 155 insertions(+), 73 deletions(-) delete mode 100644 include/juno/math/juno_la.h create mode 100644 include/juno/math/juno_math_constants.h create mode 100644 include/juno/math/juno_narr.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 2141d2b9..4f7bb895 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,7 @@ cmake_minimum_required(VERSION 3.10) set(CMAKE_EXPORT_COMPILE_COMMANDS ON) -set(CMAKE_C_STANDARD 99) +set(CMAKE_C_STANDARD 11) set(CMAKE_C_STANDARD_REQUIRED ON) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) diff --git a/include/juno/math/juno_la.h b/include/juno/math/juno_la.h deleted file mode 100644 index ab032079..00000000 --- a/include/juno/math/juno_la.h +++ /dev/null @@ -1,64 +0,0 @@ -#ifndef JUNO_MATH_VEC_H -#define JUNO_MATH_VEC_H - -#include "juno/module.h" -#include "juno/types.h" -#include -#include "juno_math_types.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/// The linear algebra API -typedef struct JUNO_MATH_LA_API_T JUNO_MATH_LA_API_T; -JUNO_MODULE_DECLARE(JUNO_MATH_VEC_T); - -#define JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T, N, type) \ -typedef struct TYPE_NAME_T \ -{ \ - const size_t iNdim; \ - type tVec[N]; \ -} TYPE_NAME_T; - -#define JUNO_MATH_CREATE_VEC(TYPE_NAME_T, N) \ -JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_FLOAT_T, N, float); \ -JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_DOUBLE_T, N, double); \ -JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_INT8_T, N, int8_t); \ -JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_UINT8_T, N, uint8_t); \ -JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_INT16_T, N, int16_t); \ -JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_UINT16_T, N, uint16_t); \ -JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_INT32_T, N, int32_t); \ -JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_UINT32_T, N, uint32_t); \ -JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_INT64_T, N, int64_t); \ -JUNO_MATH_CREATE_VEC_TYPE(TYPE_NAME_T##_UINT64_T, N, uint64_t); - -#define JUNO_MATH_NEW_VEC_TYPE(tVec, TYPE) ((JUNO_MATH_VEC_##TYPE##_T *)&tVec) -#define JUNO_MATH_NEW_VEC_FLOAT(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, FLOAT) -#define JUNO_MATH_NEW_VEC_DOUBLE(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, DOUBLE) -#define JUNO_MATH_NEW_VEC_INT8(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, INT8) -#define JUNO_MATH_NEW_VEC_UINT8(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, UINT8) -#define JUNO_MATH_NEW_VEC_INT16(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, INT16) -#define JUNO_MATH_NEW_VEC_UINT16(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, UINT16) -#define JUNO_MATH_NEW_VEC_INT32(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, INT32) -#define JUNO_MATH_NEW_VEC_UINT32(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, UINT32) -#define JUNO_MATH_NEW_VEC_INT64(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, INT64) -#define JUNO_MATH_NEW_VEC_UINT64(tVec) JUNO_MATH_NEW_VEC_TYPE(tVec, UINT64) - - -JUNO_MATH_CREATE_VEC(JUNO_MATH_VEC, ); - -#define JUNO_MATH_NEW_VEC2(...) {2, {__VA_ARGS__}} -JUNO_MATH_CREATE_VEC(JUNO_MATH_VEC2, 2); - -#define JUNO_MATH_NEW_VEC3(...) {3, {__VA_ARGS__}} -JUNO_MATH_CREATE_VEC(JUNO_MATH_VEC3, 3); - -#define JUNO_MATH_NEW_VEC4(...) {4, {__VA_ARGS__}} -JUNO_MATH_CREATE_VEC(JUNO_MATH_VEC4, 4); - - -#ifdef __cplusplus -} -#endif -#endif diff --git a/include/juno/math/juno_math.h b/include/juno/math/juno_math.h index b5aa087f..0dae40d6 100644 --- a/include/juno/math/juno_math.h +++ b/include/juno/math/juno_math.h @@ -3,7 +3,8 @@ #include "juno/module.h" #include "juno_math_types.h" -#include "juno_la.h" +#include "juno_math_constants.h" +#include "juno_narr.h" #ifdef __cplusplus extern "C" { @@ -11,7 +12,7 @@ extern "C" { struct JUNO_MATH_API_T { - const JUNO_MATH_LA_API_T *ptLaApi; + const JUNO_MATH_NARR_API_T *ptLaApi; }; #ifdef __cplusplus diff --git a/include/juno/math/juno_math_constants.h b/include/juno/math/juno_math_constants.h new file mode 100644 index 00000000..88675945 --- /dev/null +++ b/include/juno/math/juno_math_constants.h @@ -0,0 +1,14 @@ +#ifndef JUNO_MATH_CONST_H +#define JUNO_MATH_CONST_H + +#include "juno/module.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif +#endif \ No newline at end of file diff --git a/include/juno/math/juno_narr.h b/include/juno/math/juno_narr.h new file mode 100644 index 00000000..03398a90 --- /dev/null +++ b/include/juno/math/juno_narr.h @@ -0,0 +1,132 @@ +#ifndef JUNO_MATH_NARR_H +#define JUNO_MATH_NARR_H + +#include "juno/module.h" +#include "juno/types.h" +#include +#include +#include "juno_math_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/// The linear algebra API +typedef struct JUNO_MATH_NARR_API_T JUNO_MATH_NARR_API_T; +JUNO_MODULE_DECLARE(JUNO_MATH_NARR_T); + +/// The NARR Root +typedef struct JUNO_MATH_NARR_ROOT_TAG JUNO_MODULE_ROOT(JUNO_MATH_NARR_API_T, + +) JUNO_MATH_NARR_ROOT_T; + +/// Get a value at an index of an narr +#define Juno_MathNarr_Get(narr, nIndex, mIndex) narr.data[nIndex * narr.shape.m + mIndex] +/// Get a float value at an index of an narr +#define Juno_MathNarrf_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) +/// Get a double value at an index of an narr +#define Juno_MathNarrd_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) +/// Get a int8 value at an index of an narr +#define Juno_MathNarri8_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) +/// Get a int16 value at an index of an narr +#define Juno_MathNarri16_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) +/// Get a int32 value at an index of an narr +#define Juno_MathNarri32_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) +/// Get a int64 value at an index of an narr +#define Juno_MathNarri64_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) + +typedef struct JUNO_MATH_NARR_INDEX_T +{ + size_t n; + size_t m; +} JUNO_MATH_NARR_INDEX_T; + +/// A Float NARR +typedef struct JUNO_MATH_NARRF_TAG +{ + float *data; + JUNO_MATH_NARR_INDEX_T shape; +} JUNO_MATH_NARRF_T; + +/// Create a new NARRF +static inline JUNO_MATH_NARRF_T Juno_MathNarrf_New(float data[], JUNO_MATH_NARR_INDEX_T shape) +{ + JUNO_MATH_NARRF_T tVec = {data, shape}; + return tVec; +} + +/// A double NARR +typedef struct JUNO_MATH_NARRD_TAG +{ + double *data; + JUNO_MATH_NARR_INDEX_T shape; +} JUNO_MATH_NARRD_T; + +/// Create a new double NARR +static inline JUNO_MATH_NARRD_T Juno_MathNarrd_New(double data[], JUNO_MATH_NARR_INDEX_T shape) +{ + JUNO_MATH_NARRD_T tVec = {data, shape}; + return tVec; +} + +/// A int8 NARR +typedef struct JUNO_MATH_NARRI8_TAG +{ + int8_t *data; + JUNO_MATH_NARR_INDEX_T shape; +} JUNO_MATH_NARRI8_T; + +/// Create a new int8 NARR +static inline JUNO_MATH_NARRI8_T Juno_MathNarri8_New(int8_t data[], JUNO_MATH_NARR_INDEX_T shape) +{ + JUNO_MATH_NARRI8_T tVec = {data, shape}; + return tVec; +} + +/// A int16 NARR +typedef struct JUNO_MATH_NARRI16_TAG +{ + int16_t *data; + JUNO_MATH_NARR_INDEX_T shape; +} JUNO_MATH_NARRI16_T; + +/// Create a new int16 NARR +static inline JUNO_MATH_NARRI16_T Juno_MathNarri16_New(int16_t data[], JUNO_MATH_NARR_INDEX_T shape) +{ + JUNO_MATH_NARRI16_T tVec = {data, shape}; + return tVec; +} + +/// A int32 NARR +typedef struct JUNO_MATH_NARRI32_TAG +{ + int32_t *data; + JUNO_MATH_NARR_INDEX_T shape; +} JUNO_MATH_NARRI32_T; + +/// Create a new int32 NARR +static inline JUNO_MATH_NARRI32_T Juno_MathNarri32_New(int32_t data[], JUNO_MATH_NARR_INDEX_T shape) +{ + JUNO_MATH_NARRI32_T tVec = {data, shape}; + return tVec; +} + +/// A int64 NARR +typedef struct JUNO_MATH_NARRI64_TAG +{ + int64_t *data; + JUNO_MATH_NARR_INDEX_T shape; +} JUNO_MATH_NARRI64_T; + +/// Create a new int64 NARR +static inline JUNO_MATH_NARRI64_T Juno_MathNarri64_New(int64_t data[], JUNO_MATH_NARR_INDEX_T shape) +{ + JUNO_MATH_NARRI64_T tVec = {data, shape}; + return tVec; +} + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/tests/test_la.c b/tests/test_la.c index 457cb55e..7e3b89ff 100644 --- a/tests/test_la.c +++ b/tests/test_la.c @@ -1,6 +1,7 @@ -#include "juno/memory/memory_api.h" +#include "juno/math/juno_narr.h" #include "unity.h" #include "unity_internals.h" +#include #include #include #include "juno/math/juno_math.h" @@ -31,14 +32,12 @@ void tearDown(void) static void test_vec_index(void) { - JUNO_MATH_VEC3_FLOAT_T tMyVec = JUNO_MATH_NEW_VEC3(1,2,3); - JUNO_MATH_VEC_FLOAT_T *ptMyVec = JUNO_MATH_NEW_VEC_FLOAT(tMyVec); - + float fData[] = {1, 2, 3}; + JUNO_MATH_NARRF_T tMyVec = Juno_MathNarrf_New(fData, (JUNO_MATH_NARR_INDEX_T){3,1}); float tTruth[3] = {1, 2,3}; for(size_t j = 0; j < 3; j++) { - TEST_ASSERT_EQUAL_FLOAT(tTruth[j], tMyVec.tVec[j]); - TEST_ASSERT_EQUAL_FLOAT(tTruth[j], ptMyVec->tVec[j]); + TEST_ASSERT_EQUAL_FLOAT(tTruth[j], Juno_MathNarr_Get(tMyVec, j, 0)); } } From 6e66e605cf019d104bc74fa496820d1b51de123f Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Sat, 19 Jul 2025 14:49:57 -0500 Subject: [PATCH 04/12] :sparkles: Impl vectors --- include/juno/math/juno_math.h | 6 -- include/juno/math/juno_math_types.h | 100 +++++++++++++++++++-- include/juno/math/juno_narr.h | 132 ---------------------------- tests/test_la.c | 7 +- 4 files changed, 98 insertions(+), 147 deletions(-) delete mode 100644 include/juno/math/juno_narr.h diff --git a/include/juno/math/juno_math.h b/include/juno/math/juno_math.h index 0dae40d6..89b370c1 100644 --- a/include/juno/math/juno_math.h +++ b/include/juno/math/juno_math.h @@ -4,17 +4,11 @@ #include "juno/module.h" #include "juno_math_types.h" #include "juno_math_constants.h" -#include "juno_narr.h" #ifdef __cplusplus extern "C" { #endif -struct JUNO_MATH_API_T -{ - const JUNO_MATH_NARR_API_T *ptLaApi; -}; - #ifdef __cplusplus } #endif diff --git a/include/juno/math/juno_math_types.h b/include/juno/math/juno_math_types.h index 202e9f45..e8b91895 100644 --- a/include/juno/math/juno_math_types.h +++ b/include/juno/math/juno_math_types.h @@ -1,17 +1,107 @@ #ifndef JUNO_MATH_TYPES_H #define JUNO_MATH_TYPES_H -#include "juno/module.h" - #ifdef __cplusplus extern "C" { #endif +#include + +#ifndef JUNO_MATH_INT_TYPE +#define JUNO_MATH_INT_TYPE int64_t +#endif + +#ifndef JUNO_MATH_FLOAT_TYPE +#define JUNO_MATH_FLOAT_TYPE double +#endif + +typedef JUNO_MATH_INT_TYPE JUNO_INT_T; +typedef JUNO_MATH_FLOAT_TYPE JUNO_FLOAT_T; + +typedef union JUNO_MATH_VEC2F_TAG +{ + struct{JUNO_FLOAT_T i, j;}; + struct{JUNO_FLOAT_T x, y;}; + JUNO_FLOAT_T v[2]; +} JUNO_MATH_VEC2F_T; + +typedef union JUNO_MATH_VEC2I_TAG +{ + struct{JUNO_INT_T i, j;}; + struct{JUNO_INT_T x, y;}; + JUNO_INT_T v[2]; +} JUNO_MATH_VEC2I_T; + +typedef union JUNO_MATH_VEC3F_TAG +{ + struct{JUNO_FLOAT_T i, j, k;}; + struct{JUNO_FLOAT_T x, y, z;}; + JUNO_FLOAT_T v[3]; +} JUNO_MATH_VEC3F_T; + +typedef union JUNO_MATH_VEC3I_TAG +{ + struct{JUNO_INT_T i, j, k;}; + struct{JUNO_INT_T x, y, z;}; + JUNO_INT_T v[3]; +} JUNO_MATH_VEC3I_T; + +typedef union JUNO_MATH_VEC4F_TAG +{ + struct{JUNO_FLOAT_T i, j, k, l;}; + struct{JUNO_FLOAT_T x, y, z, w;}; + JUNO_FLOAT_T v[4]; +} JUNO_MATH_VEC4F_T; + +typedef union JUNO_MATH_VEC4I_TAG +{ + struct{JUNO_INT_T i, j, k, l;}; + struct{JUNO_INT_T x, y, z, w;}; + JUNO_INT_T v[4]; +} JUNO_MATH_VEC4I_T; + +typedef struct JUNO_MATH_M3X3F_TAG +{ + JUNO_FLOAT_T m[3][3]; +} JUNO_MATH_M3X3F_T; + +typedef struct JUNO_MATH_M4X4F_TAG +{ + JUNO_FLOAT_T m[4][4]; +} JUNO_MATH_M4X4F_T; + +typedef struct JUNO_MATH_M3X3I_TAG +{ + JUNO_INT_T m[3][3]; +} JUNO_MATH_M3X3I_T; + +typedef struct JUNO_MATH_M4X4I_TAG +{ + JUNO_INT_T m[4][4]; +} JUNO_MATH_M4X4I_T; + +typedef union JUNO_MATH_RQUATF_TAG +{ + struct{JUNO_FLOAT_T s, i, j, k;}; + JUNO_FLOAT_T q[4]; +} JUNO_MATH_RQUATF_T; +typedef union JUNO_MATH_RQUATI_TAG +{ + struct{JUNO_INT_T s, i, j, k;}; + JUNO_INT_T q[4]; +} JUNO_MATH_RQUATI_T; -typedef struct JUNO_MATH_API_T JUNO_MATH_API_T; -JUNO_MODULE_DECLARE(JUNO_MATH_T); +typedef union JUNO_MATH_LQUATF_TAG +{ + struct{JUNO_FLOAT_T s, i, j, k;}; + JUNO_FLOAT_T q[4]; +} JUNO_MATH_LQUATF_T; -typedef struct JUNO_MATH_ROOT_TAG JUNO_MODULE_ROOT(JUNO_MATH_API_T, JUNO_MODULE_EMPTY) JUNO_MATH_ROOT_T; +typedef union JUNO_MATH_LQUATI_TAG +{ + struct{JUNO_INT_T s, i, j, k;}; + JUNO_INT_T q[4]; +} JUNO_MATH_LQUATI_T; #ifdef __cplusplus } diff --git a/include/juno/math/juno_narr.h b/include/juno/math/juno_narr.h deleted file mode 100644 index 03398a90..00000000 --- a/include/juno/math/juno_narr.h +++ /dev/null @@ -1,132 +0,0 @@ -#ifndef JUNO_MATH_NARR_H -#define JUNO_MATH_NARR_H - -#include "juno/module.h" -#include "juno/types.h" -#include -#include -#include "juno_math_types.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/// The linear algebra API -typedef struct JUNO_MATH_NARR_API_T JUNO_MATH_NARR_API_T; -JUNO_MODULE_DECLARE(JUNO_MATH_NARR_T); - -/// The NARR Root -typedef struct JUNO_MATH_NARR_ROOT_TAG JUNO_MODULE_ROOT(JUNO_MATH_NARR_API_T, - -) JUNO_MATH_NARR_ROOT_T; - -/// Get a value at an index of an narr -#define Juno_MathNarr_Get(narr, nIndex, mIndex) narr.data[nIndex * narr.shape.m + mIndex] -/// Get a float value at an index of an narr -#define Juno_MathNarrf_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) -/// Get a double value at an index of an narr -#define Juno_MathNarrd_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) -/// Get a int8 value at an index of an narr -#define Juno_MathNarri8_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) -/// Get a int16 value at an index of an narr -#define Juno_MathNarri16_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) -/// Get a int32 value at an index of an narr -#define Juno_MathNarri32_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) -/// Get a int64 value at an index of an narr -#define Juno_MathNarri64_Get(narr, nIndex, mIndex) Juno_MathNarr_Get(narr, nIndex, mIndex) - -typedef struct JUNO_MATH_NARR_INDEX_T -{ - size_t n; - size_t m; -} JUNO_MATH_NARR_INDEX_T; - -/// A Float NARR -typedef struct JUNO_MATH_NARRF_TAG -{ - float *data; - JUNO_MATH_NARR_INDEX_T shape; -} JUNO_MATH_NARRF_T; - -/// Create a new NARRF -static inline JUNO_MATH_NARRF_T Juno_MathNarrf_New(float data[], JUNO_MATH_NARR_INDEX_T shape) -{ - JUNO_MATH_NARRF_T tVec = {data, shape}; - return tVec; -} - -/// A double NARR -typedef struct JUNO_MATH_NARRD_TAG -{ - double *data; - JUNO_MATH_NARR_INDEX_T shape; -} JUNO_MATH_NARRD_T; - -/// Create a new double NARR -static inline JUNO_MATH_NARRD_T Juno_MathNarrd_New(double data[], JUNO_MATH_NARR_INDEX_T shape) -{ - JUNO_MATH_NARRD_T tVec = {data, shape}; - return tVec; -} - -/// A int8 NARR -typedef struct JUNO_MATH_NARRI8_TAG -{ - int8_t *data; - JUNO_MATH_NARR_INDEX_T shape; -} JUNO_MATH_NARRI8_T; - -/// Create a new int8 NARR -static inline JUNO_MATH_NARRI8_T Juno_MathNarri8_New(int8_t data[], JUNO_MATH_NARR_INDEX_T shape) -{ - JUNO_MATH_NARRI8_T tVec = {data, shape}; - return tVec; -} - -/// A int16 NARR -typedef struct JUNO_MATH_NARRI16_TAG -{ - int16_t *data; - JUNO_MATH_NARR_INDEX_T shape; -} JUNO_MATH_NARRI16_T; - -/// Create a new int16 NARR -static inline JUNO_MATH_NARRI16_T Juno_MathNarri16_New(int16_t data[], JUNO_MATH_NARR_INDEX_T shape) -{ - JUNO_MATH_NARRI16_T tVec = {data, shape}; - return tVec; -} - -/// A int32 NARR -typedef struct JUNO_MATH_NARRI32_TAG -{ - int32_t *data; - JUNO_MATH_NARR_INDEX_T shape; -} JUNO_MATH_NARRI32_T; - -/// Create a new int32 NARR -static inline JUNO_MATH_NARRI32_T Juno_MathNarri32_New(int32_t data[], JUNO_MATH_NARR_INDEX_T shape) -{ - JUNO_MATH_NARRI32_T tVec = {data, shape}; - return tVec; -} - -/// A int64 NARR -typedef struct JUNO_MATH_NARRI64_TAG -{ - int64_t *data; - JUNO_MATH_NARR_INDEX_T shape; -} JUNO_MATH_NARRI64_T; - -/// Create a new int64 NARR -static inline JUNO_MATH_NARRI64_T Juno_MathNarri64_New(int64_t data[], JUNO_MATH_NARR_INDEX_T shape) -{ - JUNO_MATH_NARRI64_T tVec = {data, shape}; - return tVec; -} - - -#ifdef __cplusplus -} -#endif -#endif diff --git a/tests/test_la.c b/tests/test_la.c index 7e3b89ff..6777b17e 100644 --- a/tests/test_la.c +++ b/tests/test_la.c @@ -1,4 +1,4 @@ -#include "juno/math/juno_narr.h" +#include "juno/math/juno_math_types.h" #include "unity.h" #include "unity_internals.h" #include @@ -32,12 +32,11 @@ void tearDown(void) static void test_vec_index(void) { - float fData[] = {1, 2, 3}; - JUNO_MATH_NARRF_T tMyVec = Juno_MathNarrf_New(fData, (JUNO_MATH_NARR_INDEX_T){3,1}); + JUNO_MATH_VEC3F_T tMyVec = {1, 2, 3}; float tTruth[3] = {1, 2,3}; for(size_t j = 0; j < 3; j++) { - TEST_ASSERT_EQUAL_FLOAT(tTruth[j], Juno_MathNarr_Get(tMyVec, j, 0)); + TEST_ASSERT_EQUAL_FLOAT(tTruth[j], tMyVec.v[j]); } } From 82897391abf127ae992d6c3e2ae619b42a9ea856 Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Sun, 20 Jul 2025 16:12:15 -0500 Subject: [PATCH 05/12] :fire: Remove support for LQuat --- CMakeLists.txt | 2 +- include/juno/math/juno_math_types.h | 12 ------------ tests/test_la.c | 2 +- 3 files changed, 2 insertions(+), 14 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 4f7bb895..2141d2b9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,7 @@ cmake_minimum_required(VERSION 3.10) set(CMAKE_EXPORT_COMPILE_COMMANDS ON) -set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD 99) set(CMAKE_C_STANDARD_REQUIRED ON) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) diff --git a/include/juno/math/juno_math_types.h b/include/juno/math/juno_math_types.h index e8b91895..442f3c90 100644 --- a/include/juno/math/juno_math_types.h +++ b/include/juno/math/juno_math_types.h @@ -91,18 +91,6 @@ typedef union JUNO_MATH_RQUATI_TAG JUNO_INT_T q[4]; } JUNO_MATH_RQUATI_T; -typedef union JUNO_MATH_LQUATF_TAG -{ - struct{JUNO_FLOAT_T s, i, j, k;}; - JUNO_FLOAT_T q[4]; -} JUNO_MATH_LQUATF_T; - -typedef union JUNO_MATH_LQUATI_TAG -{ - struct{JUNO_INT_T s, i, j, k;}; - JUNO_INT_T q[4]; -} JUNO_MATH_LQUATI_T; - #ifdef __cplusplus } #endif diff --git a/tests/test_la.c b/tests/test_la.c index 6777b17e..14625742 100644 --- a/tests/test_la.c +++ b/tests/test_la.c @@ -36,7 +36,7 @@ static void test_vec_index(void) float tTruth[3] = {1, 2,3}; for(size_t j = 0; j < 3; j++) { - TEST_ASSERT_EQUAL_FLOAT(tTruth[j], tMyVec.v[j]); + TEST_ASSERT_EQUAL_FLOAT(tTruth[j], tMyVec[j]); } } From 2e4c588dc3bea6b0e0e56db12d19a52de12b32ae Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Sun, 20 Jul 2025 17:04:14 -0500 Subject: [PATCH 06/12] :sparkles: Rename math variables --- include/juno/math/juno_math_types.h | 24 ++++++++++++------------ tests/test_la.c | 2 +- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/include/juno/math/juno_math_types.h b/include/juno/math/juno_math_types.h index 442f3c90..fedec282 100644 --- a/include/juno/math/juno_math_types.h +++ b/include/juno/math/juno_math_types.h @@ -21,74 +21,74 @@ typedef union JUNO_MATH_VEC2F_TAG { struct{JUNO_FLOAT_T i, j;}; struct{JUNO_FLOAT_T x, y;}; - JUNO_FLOAT_T v[2]; + JUNO_FLOAT_T arr[2]; } JUNO_MATH_VEC2F_T; typedef union JUNO_MATH_VEC2I_TAG { struct{JUNO_INT_T i, j;}; struct{JUNO_INT_T x, y;}; - JUNO_INT_T v[2]; + JUNO_INT_T arr[2]; } JUNO_MATH_VEC2I_T; typedef union JUNO_MATH_VEC3F_TAG { struct{JUNO_FLOAT_T i, j, k;}; struct{JUNO_FLOAT_T x, y, z;}; - JUNO_FLOAT_T v[3]; + JUNO_FLOAT_T arr[3]; } JUNO_MATH_VEC3F_T; typedef union JUNO_MATH_VEC3I_TAG { struct{JUNO_INT_T i, j, k;}; struct{JUNO_INT_T x, y, z;}; - JUNO_INT_T v[3]; + JUNO_INT_T arr[3]; } JUNO_MATH_VEC3I_T; typedef union JUNO_MATH_VEC4F_TAG { struct{JUNO_FLOAT_T i, j, k, l;}; struct{JUNO_FLOAT_T x, y, z, w;}; - JUNO_FLOAT_T v[4]; + JUNO_FLOAT_T arr[4]; } JUNO_MATH_VEC4F_T; typedef union JUNO_MATH_VEC4I_TAG { struct{JUNO_INT_T i, j, k, l;}; struct{JUNO_INT_T x, y, z, w;}; - JUNO_INT_T v[4]; + JUNO_INT_T arr[4]; } JUNO_MATH_VEC4I_T; typedef struct JUNO_MATH_M3X3F_TAG { - JUNO_FLOAT_T m[3][3]; + JUNO_FLOAT_T mat[3][3]; } JUNO_MATH_M3X3F_T; typedef struct JUNO_MATH_M4X4F_TAG { - JUNO_FLOAT_T m[4][4]; + JUNO_FLOAT_T mat[4][4]; } JUNO_MATH_M4X4F_T; typedef struct JUNO_MATH_M3X3I_TAG { - JUNO_INT_T m[3][3]; + JUNO_INT_T mat[3][3]; } JUNO_MATH_M3X3I_T; typedef struct JUNO_MATH_M4X4I_TAG { - JUNO_INT_T m[4][4]; + JUNO_INT_T mat[4][4]; } JUNO_MATH_M4X4I_T; typedef union JUNO_MATH_RQUATF_TAG { struct{JUNO_FLOAT_T s, i, j, k;}; - JUNO_FLOAT_T q[4]; + JUNO_FLOAT_T quat[4]; } JUNO_MATH_RQUATF_T; typedef union JUNO_MATH_RQUATI_TAG { struct{JUNO_INT_T s, i, j, k;}; - JUNO_INT_T q[4]; + JUNO_INT_T quat[4]; } JUNO_MATH_RQUATI_T; #ifdef __cplusplus diff --git a/tests/test_la.c b/tests/test_la.c index 14625742..6777b17e 100644 --- a/tests/test_la.c +++ b/tests/test_la.c @@ -36,7 +36,7 @@ static void test_vec_index(void) float tTruth[3] = {1, 2,3}; for(size_t j = 0; j < 3; j++) { - TEST_ASSERT_EQUAL_FLOAT(tTruth[j], tMyVec[j]); + TEST_ASSERT_EQUAL_FLOAT(tTruth[j], tMyVec.v[j]); } } From 94ac8bc950f6efe262e3f13758e38c76ec79c7c4 Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Sun, 20 Jul 2025 17:11:42 -0500 Subject: [PATCH 07/12] :sparkles: Add math constants --- include/juno/math/juno_math_constants.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/include/juno/math/juno_math_constants.h b/include/juno/math/juno_math_constants.h index 88675945..f2b11d32 100644 --- a/include/juno/math/juno_math_constants.h +++ b/include/juno/math/juno_math_constants.h @@ -7,6 +7,10 @@ extern "C" { #endif +#define JUNO_MATH_PI 3.141592653589793 +#define JUNO_MATH_HALF_PI 1.5707963267948966 +#define JUNO_MATH_QUART_PI 0.7853981633974483 +#define JUNO_MATH_E 2.718281828459045 #ifdef __cplusplus } From 9ed80be5898002006e42adb425d40df070699072 Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Sun, 20 Jul 2025 18:41:39 -0500 Subject: [PATCH 08/12] :sparkles: Add vec2 and vec3 functions --- CMakeLists.txt | 1 + include/juno/math/juno_math.h | 172 +++++++++++++++++++++++++++- include/juno/math/juno_math_types.h | 128 ++++++++++++--------- include/juno/module.h | 10 +- include/juno/types.h | 4 +- tests/test_la.c | 29 +++-- 6 files changed, 276 insertions(+), 68 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 2141d2b9..1758a0d0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -111,6 +111,7 @@ install( ) if(JUNO_TESTS) + add_definitions(-DUNITY_INCLUDE_DOUBLE) set(CMAKE_BUILD_TYPE Debug) enable_testing() add_library(unity ${juno_SOURCE_DIR}/deps/unity/src/unity.c) diff --git a/include/juno/math/juno_math.h b/include/juno/math/juno_math.h index 89b370c1..3debabcb 100644 --- a/include/juno/math/juno_math.h +++ b/include/juno/math/juno_math.h @@ -1,14 +1,182 @@ #ifndef JUNO_MATH_H #define JUNO_MATH_H -#include "juno/module.h" #include "juno_math_types.h" -#include "juno_math_constants.h" #ifdef __cplusplus extern "C" { #endif +/** + Add two vecf's together +*/ +static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2f_Add(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +{ + tVec0.i += tVec1.i; + tVec0.j += tVec1.j; + return tVec0; +} + + +/** + Subtract to vec2f's + @param tVec0 The vec to subtract from + @param tVec1 The vec to subtract +*/ +static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2f_Sub(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +{ + tVec0.i -= tVec1.i; + tVec0.j -= tVec1.j; + return tVec0; +} + +/** + Dot product of two vec2f's +*/ +static inline double Juno_MathVec2f_Dot(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +{ + return tVec0.i * tVec1.i + tVec0.j * tVec1.j; +} + +/** + The cross product of two vec2f's. + The result is a psedoscalar +*/ +static inline double Juno_MathVec2f_Cross(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +{ + return tVec0.i * tVec1.j - tVec0.j * tVec1.i; +} + +/// Add two vec2i's +static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2i_Add(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +{ + tVec0.i += tVec1.i; + tVec0.j += tVec1.j; + return tVec0; +} + + +/** + Subtract to vec2i's + @param tVec0 The vec to subtract from + @param tVec1 The vec to subtract +*/ +static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2i_Sub(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +{ + tVec0.i -= tVec1.i; + tVec0.j -= tVec1.j; + return tVec0; +} + +/** + Dot product of two vec2i's +*/ +static inline int32_t Juno_MathVec2i_Dot(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +{ + return tVec0.i * tVec1.i + tVec0.j * tVec1.j; +} + +/** + The cross product of two vec2i's. + The result is a psedoscalar +*/ +static inline int32_t Juno_MathVec2i_Cross(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +{ + return tVec0.i * tVec1.j - tVec0.j * tVec1.i; +} + +/** + Add two vecf's together +*/ +static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3f_Add(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +{ + tVec0.i += tVec1.i; + tVec0.j += tVec1.j; + tVec0.k += tVec1.k; + return tVec0; +} + + +/** + Subtract to vec2f's + @param tVec0 The vec to subtract from + @param tVec1 The vec to subtract +*/ +static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3f_Sub(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +{ + tVec0.i -= tVec1.i; + tVec0.j -= tVec1.j; + tVec0.k -= tVec1.k; + return tVec0; +} + +/** + Dot product of two vec2f's +*/ +static inline double Juno_MathVec3f_Dot(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +{ + return tVec0.i * tVec1.i + tVec0.j * tVec1.j + tVec0.k * tVec1.k; +} + +/** + The cross product of two vec2f's. + The result is a psedoscalar +*/ +static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3f_Cross(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +{ + JUNO_MATH_VEC3_F64_T tRes = { + .i = tVec0.j * tVec1.k - tVec0.k * tVec1.j, + .j = tVec0.k * tVec1.i - tVec0.i * tVec1.k, + .k = tVec0.i * tVec1.j - tVec0.j * tVec1.i + }; + return tRes; +} + +/// Add two vec2i's +static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3i_Add(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +{ + tVec0.i += tVec1.i; + tVec0.j += tVec1.j; + tVec0.k += tVec1.k; + return tVec0; +} + + +/** + Subtract to vec2i's + @param tVec0 The vec to subtract from + @param tVec1 The vec to subtract +*/ +static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3i_Sub(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +{ + tVec0.i -= tVec1.i; + tVec0.j -= tVec1.j; + tVec0.k -= tVec1.k; + return tVec0; +} + +/** + Dot product of two vec2i's +*/ +static inline int32_t Juno_MathVec3i_Dot(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +{ + return tVec0.i * tVec1.i + tVec0.j * tVec1.j + tVec0.k * tVec1.k; +} + +/** + The cross product of two vec2i's. + The result is a psedoscalar +*/ +static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3i_Cross(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +{ + JUNO_MATH_VEC3_I32_T tRes = { + .i = tVec0.j * tVec1.k - tVec0.k * tVec1.j, + .j = tVec0.k * tVec1.i - tVec0.i * tVec1.k, + .k = tVec0.i * tVec1.j - tVec0.j * tVec1.i + }; + return tRes; +} + #ifdef __cplusplus } #endif diff --git a/include/juno/math/juno_math_types.h b/include/juno/math/juno_math_types.h index fedec282..5a5a204f 100644 --- a/include/juno/math/juno_math_types.h +++ b/include/juno/math/juno_math_types.h @@ -1,6 +1,7 @@ #ifndef JUNO_MATH_TYPES_H #define JUNO_MATH_TYPES_H +#include "juno/module.h" #ifdef __cplusplus extern "C" { #endif @@ -14,82 +15,103 @@ extern "C" { #define JUNO_MATH_FLOAT_TYPE double #endif -typedef JUNO_MATH_INT_TYPE JUNO_INT_T; -typedef JUNO_MATH_FLOAT_TYPE JUNO_FLOAT_T; - -typedef union JUNO_MATH_VEC2F_TAG +typedef union JUNO_MATH_VEC2_F64_TAG { - struct{JUNO_FLOAT_T i, j;}; - struct{JUNO_FLOAT_T x, y;}; - JUNO_FLOAT_T arr[2]; -} JUNO_MATH_VEC2F_T; + struct{double i, j;}; + struct{double x, y;}; + double arr[2]; +} JUNO_MATH_VEC2_F64_T; + +JUNO_MODULE_RESULT(JUNO_MATH_VEC2F_RESULT_T, JUNO_MATH_VEC2_F64_T); -typedef union JUNO_MATH_VEC2I_TAG +typedef union JUNO_MATH_VEC2_I32_TAG { - struct{JUNO_INT_T i, j;}; - struct{JUNO_INT_T x, y;}; - JUNO_INT_T arr[2]; -} JUNO_MATH_VEC2I_T; + struct{int32_t i, j;}; + struct{int32_t x, y;}; + int32_t arr[2]; +} JUNO_MATH_VEC2_I32_T; -typedef union JUNO_MATH_VEC3F_TAG +JUNO_MODULE_RESULT(JUNO_MATH_VEC2I_RESULT_T, JUNO_MATH_VEC2_I32_T); + +typedef union JUNO_MATH_VEC3_F64_TAG { - struct{JUNO_FLOAT_T i, j, k;}; - struct{JUNO_FLOAT_T x, y, z;}; - JUNO_FLOAT_T arr[3]; -} JUNO_MATH_VEC3F_T; + struct{double i, j, k;}; + struct{double x, y, z;}; + double arr[3]; +} JUNO_MATH_VEC3_F64_T; + +JUNO_MODULE_RESULT(JUNO_MATH_VEC3F_RESULT_T, JUNO_MATH_VEC3_F64_T); -typedef union JUNO_MATH_VEC3I_TAG +typedef union JUNO_MATH_VEC3_I32_TAG { - struct{JUNO_INT_T i, j, k;}; - struct{JUNO_INT_T x, y, z;}; - JUNO_INT_T arr[3]; -} JUNO_MATH_VEC3I_T; + struct{int32_t i, j, k;}; + struct{int32_t x, y, z;}; + int32_t arr[3]; +} JUNO_MATH_VEC3_I32_T; -typedef union JUNO_MATH_VEC4F_TAG +JUNO_MODULE_RESULT(JUNO_MATH_VEC3I_RESULT_T, JUNO_MATH_VEC3_I32_T); + +typedef union JUNO_MATH_VEC4_F64_TAG { - struct{JUNO_FLOAT_T i, j, k, l;}; - struct{JUNO_FLOAT_T x, y, z, w;}; - JUNO_FLOAT_T arr[4]; -} JUNO_MATH_VEC4F_T; + struct{double i, j, k, l;}; + struct{double x, y, z, w;}; + double arr[4]; +} JUNO_MATH_VEC4_F64_T; + +JUNO_MODULE_RESULT(JUNO_MATH_VEC4F_RESULT_T, JUNO_MATH_VEC4_F64_T); -typedef union JUNO_MATH_VEC4I_TAG +typedef union JUNO_MATH_VEC4_I32_TAG { - struct{JUNO_INT_T i, j, k, l;}; - struct{JUNO_INT_T x, y, z, w;}; - JUNO_INT_T arr[4]; -} JUNO_MATH_VEC4I_T; + struct{int32_t i, j, k, l;}; + struct{int32_t x, y, z, w;}; + int32_t arr[4]; +} JUNO_MATH_VEC4_I32_T; + +JUNO_MODULE_RESULT(JUNO_MATH_VEC4I_RESULT_T, JUNO_MATH_VEC4_I32_T); -typedef struct JUNO_MATH_M3X3F_TAG +typedef struct JUNO_MATH_M3X3_F64_TAG { - JUNO_FLOAT_T mat[3][3]; -} JUNO_MATH_M3X3F_T; + double mat[3][3]; +} JUNO_MATH_M3X3_F64_T; -typedef struct JUNO_MATH_M4X4F_TAG +JUNO_MODULE_RESULT(JUNO_MATH_M3X3F_RESULT_T, JUNO_MATH_M3X3_F64_T); + +typedef struct JUNO_MATH_M4X4_F64_TAG { - JUNO_FLOAT_T mat[4][4]; -} JUNO_MATH_M4X4F_T; + double mat[4][4]; +} JUNO_MATH_M4X4_F64_T; + +JUNO_MODULE_RESULT(JUNO_MATH_M4X4F_RESULT_T, JUNO_MATH_M4X4_F64_T); -typedef struct JUNO_MATH_M3X3I_TAG +typedef struct JUNO_MATH_M3X3_I32_TAG { - JUNO_INT_T mat[3][3]; -} JUNO_MATH_M3X3I_T; + int32_t mat[3][3]; +} JUNO_MATH_M3X3_I32_T; + +JUNO_MODULE_RESULT(JUNO_MATH_M3X3I_RESULT_T, JUNO_MATH_M3X3_I32_T); -typedef struct JUNO_MATH_M4X4I_TAG +typedef struct JUNO_MATH_M4X4_I32_TAG { - JUNO_INT_T mat[4][4]; -} JUNO_MATH_M4X4I_T; + int32_t mat[4][4]; +} JUNO_MATH_M4X4_I32_T; -typedef union JUNO_MATH_RQUATF_TAG +JUNO_MODULE_RESULT(JUNO_MATH_M4X4I_RESULT_T, JUNO_MATH_M4X4_I32_T); + +typedef union JUNO_MATH_RQUAT_F64_TAG { - struct{JUNO_FLOAT_T s, i, j, k;}; - JUNO_FLOAT_T quat[4]; -} JUNO_MATH_RQUATF_T; + struct{double s, i, j, k;}; + double quat[4]; +} JUNO_MATH_RQUAT_F64_T; + +JUNO_MODULE_RESULT(JUNO_MATH_RQUATF_RESULT_T, JUNO_MATH_RQUAT_F64_T); -typedef union JUNO_MATH_RQUATI_TAG +typedef union JUNO_MATH_RQUAT_I32_TAG { - struct{JUNO_INT_T s, i, j, k;}; - JUNO_INT_T quat[4]; -} JUNO_MATH_RQUATI_T; + struct{int32_t s, i, j, k;}; + int32_t quat[4]; +} JUNO_MATH_RQUAT_I32_T; + +JUNO_MODULE_RESULT(JUNO_MATH_RQUATI_RESULT_T, JUNO_MATH_RQUAT_I32_T); #ifdef __cplusplus } diff --git a/include/juno/module.h b/include/juno/module.h index c4ca0901..edde4595 100644 --- a/include/juno/module.h +++ b/include/juno/module.h @@ -206,16 +206,18 @@ */ #define JUNO_MODULE_GET_API(ptModule, ROOT_T) ((const ROOT_T *)ptModule)->ptApi -#define JUNO_MODULE_RESULT(SUCCESS_T) \ +#define JUNO_MODULE_RESULT(NAME_T, SUCCESS_T) \ +typedef struct NAME_T \ { \ JUNO_STATUS_T tStatus; \ SUCCESS_T tSuccess; \ -} +} NAME_T -#define JUNO_MODULE_OPTION(SOME_T) \ +#define JUNO_MODULE_OPTION(NAME_T, SOME_T) \ +typedef struct NAME_T \ { \ bool bIsSome; \ SOME_T tSome; \ -} +} NAME_T; #endif // JUNO_MODULE_H diff --git a/include/juno/types.h b/include/juno/types.h index b6de9e22..7fd6f898 100644 --- a/include/juno/types.h +++ b/include/juno/types.h @@ -9,8 +9,8 @@ extern "C" #include #include -typedef struct JUNO_RESULT_BOOL_TAG JUNO_MODULE_RESULT(bool) JUNO_RESULT_BOOL_T; -typedef struct JUNO_RESULT_UINT32_TAG JUNO_MODULE_RESULT(uint32_t) JUNO_RESULT_UINT32_T; +JUNO_MODULE_RESULT(JUNO_RESULT_BOOL_T, bool); +JUNO_MODULE_RESULT(JUNO_RESULT_UINT32_T, uint32_t); #ifdef __cplusplus } diff --git a/tests/test_la.c b/tests/test_la.c index 6777b17e..40bda668 100644 --- a/tests/test_la.c +++ b/tests/test_la.c @@ -1,9 +1,9 @@ #include "juno/math/juno_math_types.h" #include "unity.h" #include "unity_internals.h" -#include #include #include +#include #include "juno/math/juno_math.h" void setUp(void) @@ -30,19 +30,34 @@ void tearDown(void) // } // } -static void test_vec_index(void) +static void test_vec3_f64_add(void) { - JUNO_MATH_VEC3F_T tMyVec = {1, 2, 3}; - float tTruth[3] = {1, 2,3}; - for(size_t j = 0; j < 3; j++) + JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; + JUNO_MATH_VEC3_F64_T tVec2 = {4, 5, 6}; + JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3f_Add(tVec1, tVec2); + JUNO_MATH_VEC3_F64_T tTruth = {5, 7, 9}; + for(uint8_t i = 0; i < 3; i++) { - TEST_ASSERT_EQUAL_FLOAT(tTruth[j], tMyVec.v[j]); + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + +static void test_vec3_f64_sub(void) +{ + JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; + JUNO_MATH_VEC3_F64_T tVec2 = {4, 5, 6}; + JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3f_Add(tVec1, tVec2); + JUNO_MATH_VEC3_F64_T tTruth = {5, 7, 9}; + for(uint8_t i = 0; i < 3; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); } } int main(void) { UNITY_BEGIN(); - RUN_TEST(test_vec_index); + RUN_TEST(test_vec3_f64_add); + RUN_TEST(test_vec3_f64_sub); return UNITY_END(); } From e85501bf18af1e71dae42b19521b49d8207f9a7b Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Sun, 20 Jul 2025 18:49:02 -0500 Subject: [PATCH 09/12] :sparkles: Add tests for vec add and sub --- include/juno/math/juno_math.h | 32 +++++++++++------------ tests/test_la.c | 48 ++++++++++++++++++++++------------- 2 files changed, 46 insertions(+), 34 deletions(-) diff --git a/include/juno/math/juno_math.h b/include/juno/math/juno_math.h index 3debabcb..83e84616 100644 --- a/include/juno/math/juno_math.h +++ b/include/juno/math/juno_math.h @@ -10,7 +10,7 @@ extern "C" { /** Add two vecf's together */ -static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2f_Add(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2_f64_Add(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) { tVec0.i += tVec1.i; tVec0.j += tVec1.j; @@ -23,7 +23,7 @@ static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2f_Add(JUNO_MATH_VEC2_F64_T tVec0 @param tVec0 The vec to subtract from @param tVec1 The vec to subtract */ -static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2f_Sub(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2_f64_Sub(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) { tVec0.i -= tVec1.i; tVec0.j -= tVec1.j; @@ -33,7 +33,7 @@ static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2f_Sub(JUNO_MATH_VEC2_F64_T tVec0 /** Dot product of two vec2f's */ -static inline double Juno_MathVec2f_Dot(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +static inline double Juno_MathVec2_f64_Dot(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) { return tVec0.i * tVec1.i + tVec0.j * tVec1.j; } @@ -42,13 +42,13 @@ static inline double Juno_MathVec2f_Dot(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VE The cross product of two vec2f's. The result is a psedoscalar */ -static inline double Juno_MathVec2f_Cross(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +static inline double Juno_MathVec2_f64_Cross(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) { return tVec0.i * tVec1.j - tVec0.j * tVec1.i; } /// Add two vec2i's -static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2i_Add(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2_i32_Add(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) { tVec0.i += tVec1.i; tVec0.j += tVec1.j; @@ -61,7 +61,7 @@ static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2i_Add(JUNO_MATH_VEC2_I32_T tVec0 @param tVec0 The vec to subtract from @param tVec1 The vec to subtract */ -static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2i_Sub(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2_i32_Sub(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) { tVec0.i -= tVec1.i; tVec0.j -= tVec1.j; @@ -71,7 +71,7 @@ static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2i_Sub(JUNO_MATH_VEC2_I32_T tVec0 /** Dot product of two vec2i's */ -static inline int32_t Juno_MathVec2i_Dot(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +static inline int32_t Juno_MathVec2_i32_Dot(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) { return tVec0.i * tVec1.i + tVec0.j * tVec1.j; } @@ -80,7 +80,7 @@ static inline int32_t Juno_MathVec2i_Dot(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_V The cross product of two vec2i's. The result is a psedoscalar */ -static inline int32_t Juno_MathVec2i_Cross(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +static inline int32_t Juno_MathVec2_i32_Cross(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) { return tVec0.i * tVec1.j - tVec0.j * tVec1.i; } @@ -88,7 +88,7 @@ static inline int32_t Juno_MathVec2i_Cross(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH /** Add two vecf's together */ -static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3f_Add(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3_f64_Add(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) { tVec0.i += tVec1.i; tVec0.j += tVec1.j; @@ -102,7 +102,7 @@ static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3f_Add(JUNO_MATH_VEC3_F64_T tVec0 @param tVec0 The vec to subtract from @param tVec1 The vec to subtract */ -static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3f_Sub(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3_f64_Sub(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) { tVec0.i -= tVec1.i; tVec0.j -= tVec1.j; @@ -113,7 +113,7 @@ static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3f_Sub(JUNO_MATH_VEC3_F64_T tVec0 /** Dot product of two vec2f's */ -static inline double Juno_MathVec3f_Dot(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +static inline double Juno_MathVec3_f64_Dot(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) { return tVec0.i * tVec1.i + tVec0.j * tVec1.j + tVec0.k * tVec1.k; } @@ -122,7 +122,7 @@ static inline double Juno_MathVec3f_Dot(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VE The cross product of two vec2f's. The result is a psedoscalar */ -static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3f_Cross(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3_f64_Cross(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) { JUNO_MATH_VEC3_F64_T tRes = { .i = tVec0.j * tVec1.k - tVec0.k * tVec1.j, @@ -133,7 +133,7 @@ static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3f_Cross(JUNO_MATH_VEC3_F64_T tVe } /// Add two vec2i's -static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3i_Add(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3_i32_Add(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) { tVec0.i += tVec1.i; tVec0.j += tVec1.j; @@ -147,7 +147,7 @@ static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3i_Add(JUNO_MATH_VEC3_I32_T tVec0 @param tVec0 The vec to subtract from @param tVec1 The vec to subtract */ -static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3i_Sub(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3_i32_Sub(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) { tVec0.i -= tVec1.i; tVec0.j -= tVec1.j; @@ -158,7 +158,7 @@ static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3i_Sub(JUNO_MATH_VEC3_I32_T tVec0 /** Dot product of two vec2i's */ -static inline int32_t Juno_MathVec3i_Dot(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +static inline int32_t Juno_MathVec3_i32_Dot(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) { return tVec0.i * tVec1.i + tVec0.j * tVec1.j + tVec0.k * tVec1.k; } @@ -167,7 +167,7 @@ static inline int32_t Juno_MathVec3i_Dot(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_V The cross product of two vec2i's. The result is a psedoscalar */ -static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3i_Cross(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3_i32_Cross(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) { JUNO_MATH_VEC3_I32_T tRes = { .i = tVec0.j * tVec1.k - tVec0.k * tVec1.j, diff --git a/tests/test_la.c b/tests/test_la.c index 40bda668..581fc376 100644 --- a/tests/test_la.c +++ b/tests/test_la.c @@ -15,26 +15,11 @@ void tearDown(void) } -// static void test_mat_index(void) -// { -// MAT_3x3 tMat3x3 = {.tRoot = {.iNDim = 3, .iMDim = 3}, .tMat = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}}}; -// float tTruth[3][3] ={{0, 1, 2}, {3, 4, 5}, {6, 7, 8}}; -// for(size_t i = 0; i < 3; i++) -// { -// for(size_t j = 0; j < 3; j++) -// { -// TEST_ASSERT_EQUAL_FLOAT(tTruth[i][j], tMat3x3.tMat[i][j]); -// JUNO_MATH_MAT_NxM_FLOAT_T *ptMatNxM = (JUNO_MATH_MAT_NxM_FLOAT_T*) &tMat3x3; -// TEST_ASSERT_EQUAL_FLOAT(tTruth[i][j], ptMatNxM->tMat[i*ptMatNxM->tRoot.iMDim + j]); -// } -// } -// } - static void test_vec3_f64_add(void) { JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; JUNO_MATH_VEC3_F64_T tVec2 = {4, 5, 6}; - JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3f_Add(tVec1, tVec2); + JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3_f64_Add(tVec1, tVec2); JUNO_MATH_VEC3_F64_T tTruth = {5, 7, 9}; for(uint8_t i = 0; i < 3; i++) { @@ -46,18 +31,45 @@ static void test_vec3_f64_sub(void) { JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; JUNO_MATH_VEC3_F64_T tVec2 = {4, 5, 6}; - JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3f_Add(tVec1, tVec2); - JUNO_MATH_VEC3_F64_T tTruth = {5, 7, 9}; + JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3_f64_Sub(tVec1, tVec2); + JUNO_MATH_VEC3_F64_T tTruth = {-3, -3, -3}; + for(uint8_t i = 0; i < 3; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + +static void test_vec3_i32_add(void) +{ + JUNO_MATH_VEC3_I32_T tVec1 = {1, 2, 3}; + JUNO_MATH_VEC3_I32_T tVec2 = {4, 5, 6}; + JUNO_MATH_VEC3_I32_T tRes = Juno_MathVec3_i32_Add(tVec1, tVec2); + JUNO_MATH_VEC3_I32_T tTruth = {5, 7, 9}; for(uint8_t i = 0; i < 3; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); } } +static void test_vec3_i32_sub(void) +{ + JUNO_MATH_VEC3_I32_T tVec1 = {1, 2, 3}; + JUNO_MATH_VEC3_I32_T tVec2 = {4, 5, 6}; + JUNO_MATH_VEC3_I32_T tRes = Juno_MathVec3_i32_Sub(tVec1, tVec2); + JUNO_MATH_VEC3_I32_T tTruth = {-3, -3, -3}; + for(uint8_t i = 0; i < 3; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + + int main(void) { UNITY_BEGIN(); RUN_TEST(test_vec3_f64_add); RUN_TEST(test_vec3_f64_sub); + RUN_TEST(test_vec3_i32_add); + RUN_TEST(test_vec3_i32_sub); return UNITY_END(); } From 589e4dcaee0a49a1e6919bd912e3cc7c41d79ba5 Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Sun, 20 Jul 2025 19:18:06 -0500 Subject: [PATCH 10/12] :sparkles: Add tests for vec2 and vec3 for mult --- include/juno/math/juno_math.h | 43 ++++++++ tests/test_la.c | 186 ++++++++++++++++++++++++++++++++++ 2 files changed, 229 insertions(+) diff --git a/include/juno/math/juno_math.h b/include/juno/math/juno_math.h index 83e84616..544c0054 100644 --- a/include/juno/math/juno_math.h +++ b/include/juno/math/juno_math.h @@ -2,6 +2,7 @@ #define JUNO_MATH_H #include "juno_math_types.h" +#include #ifdef __cplusplus extern "C" { @@ -30,6 +31,16 @@ static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2_f64_Sub(JUNO_MATH_VEC2_F64_T tV return tVec0; } +/** + Multiply scalar with vec2f's +*/ +static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2_f64_Mult(JUNO_MATH_VEC2_F64_T tVec0, double dScalar) +{ + tVec0.i *= dScalar; + tVec0.j *= dScalar; + return tVec0; +} + /** Dot product of two vec2f's */ @@ -68,6 +79,16 @@ static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2_i32_Sub(JUNO_MATH_VEC2_I32_T tV return tVec0; } +/** + Multiply scalar with vec2f's +*/ +static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2_i32_Mult(JUNO_MATH_VEC2_I32_T tVec0, int32_t dScalar) +{ + tVec0.i *= dScalar; + tVec0.j *= dScalar; + return tVec0; +} + /** Dot product of two vec2i's */ @@ -110,6 +131,17 @@ static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3_f64_Sub(JUNO_MATH_VEC3_F64_T tV return tVec0; } +/** + Multiply scalar with vec2f's +*/ +static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3_f64_Mult(JUNO_MATH_VEC3_F64_T tVec0, double dScalar) +{ + tVec0.i *= dScalar; + tVec0.j *= dScalar; + tVec0.k *= dScalar; + return tVec0; +} + /** Dot product of two vec2f's */ @@ -155,6 +187,17 @@ static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3_i32_Sub(JUNO_MATH_VEC3_I32_T tV return tVec0; } +/** + Multiply scalar with vec2f's +*/ +static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3_i32_Mult(JUNO_MATH_VEC3_I32_T tVec0, int32_t dScalar) +{ + tVec0.i *= dScalar; + tVec0.j *= dScalar; + tVec0.k *= dScalar; + return tVec0; +} + /** Dot product of two vec2i's */ diff --git a/tests/test_la.c b/tests/test_la.c index 581fc376..a39e0159 100644 --- a/tests/test_la.c +++ b/tests/test_la.c @@ -15,6 +15,113 @@ void tearDown(void) } +static void test_vec2_f64_add(void) +{ + JUNO_MATH_VEC2_F64_T tVec1 = {1, 2}; + JUNO_MATH_VEC2_F64_T tVec2 = {4, 5}; + JUNO_MATH_VEC2_F64_T tRes = Juno_MathVec2_f64_Add(tVec1, tVec2); + JUNO_MATH_VEC2_F64_T tTruth = {5, 7}; + for(uint8_t i = 0; i < 2; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + +static void test_vec2_f64_sub(void) +{ + JUNO_MATH_VEC2_F64_T tVec1 = {1, 2}; + JUNO_MATH_VEC2_F64_T tVec2 = {4, 5}; + JUNO_MATH_VEC2_F64_T tRes = Juno_MathVec2_f64_Sub(tVec1, tVec2); + JUNO_MATH_VEC2_F64_T tTruth = {-3, -3}; + for(uint8_t i = 0; i < 2; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + +static void test_vec2_f64_mult(void) +{ + JUNO_MATH_VEC2_F64_T tVec1 = {1, 2}; + JUNO_MATH_VEC2_F64_T tRes = Juno_MathVec2_f64_Mult(tVec1, 2); + JUNO_MATH_VEC2_F64_T tTruth = {2, 4}; + for(uint8_t i = 0; i < 2; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + +static void test_vec2_f64_dot(void) +{ + JUNO_MATH_VEC2_F64_T tVec1 = {1, 2}; + JUNO_MATH_VEC2_F64_T tVec2 = {4, 5}; + double tRes = Juno_MathVec2_f64_Dot(tVec1, tVec2); + double tTruth = 14; + TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); +} + +static void test_vec2_f64_cross(void) +{ + JUNO_MATH_VEC2_F64_T tVec1 = {1, 2}; + JUNO_MATH_VEC2_F64_T tVec2 = {4, 5}; + double tRes = Juno_MathVec2_f64_Cross(tVec1, tVec2); + double tTruth = -3; + TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); +} + +static void test_vec2_i32_add(void) +{ + JUNO_MATH_VEC2_I32_T tVec1 = {1, 2}; + JUNO_MATH_VEC2_I32_T tVec2 = {4, 5}; + JUNO_MATH_VEC2_I32_T tRes = Juno_MathVec2_i32_Add(tVec1, tVec2); + JUNO_MATH_VEC2_I32_T tTruth = {5, 7}; + for(uint8_t i = 0; i < 2; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + +static void test_vec2_i32_sub(void) +{ + JUNO_MATH_VEC2_I32_T tVec1 = {1, 2}; + JUNO_MATH_VEC2_I32_T tVec2 = {4, 5}; + JUNO_MATH_VEC2_I32_T tRes = Juno_MathVec2_i32_Sub(tVec1, tVec2); + JUNO_MATH_VEC2_I32_T tTruth = {-3, -3}; + for(uint8_t i = 0; i < 2; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + +static void test_vec2_i32_mult(void) +{ + JUNO_MATH_VEC2_I32_T tVec1 = {1, 2}; + JUNO_MATH_VEC2_I32_T tRes = Juno_MathVec2_i32_Mult(tVec1, 2); + JUNO_MATH_VEC2_I32_T tTruth = {2, 4}; + for(uint8_t i = 0; i < 2; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + +static void test_vec2_i32_dot(void) +{ + JUNO_MATH_VEC2_I32_T tVec1 = {1, 2}; + JUNO_MATH_VEC2_I32_T tVec2 = {4, 5}; + int32_t tRes = Juno_MathVec2_i32_Dot(tVec1, tVec2); + int32_t tTruth = 14; + TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); +} + +static void test_vec2_i32_cross(void) +{ + JUNO_MATH_VEC2_I32_T tVec1 = {1, 2}; + JUNO_MATH_VEC2_I32_T tVec2 = {4, 5}; + int32_t tRes = Juno_MathVec2_i32_Cross(tVec1, tVec2); + int32_t tTruth = -3; + TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); +} + + static void test_vec3_f64_add(void) { JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; @@ -39,6 +146,38 @@ static void test_vec3_f64_sub(void) } } +static void test_vec3_f64_mult(void) +{ + JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; + JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3_f64_Mult(tVec1, 2); + JUNO_MATH_VEC3_F64_T tTruth = {2, 4, 6}; + for(uint8_t i = 0; i < 3; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + +static void test_vec3_f64_dot(void) +{ + JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; + JUNO_MATH_VEC3_F64_T tVec2 = {4, 5, 6}; + double tRes = Juno_MathVec3_f64_Dot(tVec1, tVec2); + double tTruth = 32; + TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); +} + +static void test_vec3_f64_cross(void) +{ + JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; + JUNO_MATH_VEC3_F64_T tVec2 = {4, 5, 6}; + JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3_f64_Cross(tVec1, tVec2); + JUNO_MATH_VEC3_F64_T tTruth = {-3, 6, -3}; + for(uint8_t i = 0; i < 3; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + static void test_vec3_i32_add(void) { JUNO_MATH_VEC3_I32_T tVec1 = {1, 2, 3}; @@ -63,13 +202,60 @@ static void test_vec3_i32_sub(void) } } +static void test_vec3_i32_mult(void) +{ + JUNO_MATH_VEC3_I32_T tVec1 = {1, 2, 3}; + JUNO_MATH_VEC3_I32_T tRes = Juno_MathVec3_i32_Mult(tVec1, 2); + JUNO_MATH_VEC3_I32_T tTruth = {2, 4, 6}; + for(uint8_t i = 0; i < 3; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} + +static void test_vec3_i32_dot(void) +{ + JUNO_MATH_VEC3_I32_T tVec1 = {1, 2, 3}; + JUNO_MATH_VEC3_I32_T tVec2 = {4, 5, 6}; + double tRes = Juno_MathVec3_i32_Dot(tVec1, tVec2); + double tTruth = 32; + TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); +} + +static void test_vec3_i32_cross(void) +{ + JUNO_MATH_VEC3_I32_T tVec1 = {1, 2, 3}; + JUNO_MATH_VEC3_I32_T tVec2 = {4, 5, 6}; + JUNO_MATH_VEC3_I32_T tRes = Juno_MathVec3_i32_Cross(tVec1, tVec2); + JUNO_MATH_VEC3_I32_T tTruth = {-3, 6, -3}; + for(uint8_t i = 0; i < 3; i++) + { + TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); + } +} int main(void) { UNITY_BEGIN(); + RUN_TEST(test_vec2_f64_add); + RUN_TEST(test_vec2_f64_sub); + RUN_TEST(test_vec2_f64_mult); + RUN_TEST(test_vec2_f64_dot); + RUN_TEST(test_vec2_f64_cross); + RUN_TEST(test_vec2_i32_add); + RUN_TEST(test_vec2_i32_sub); + RUN_TEST(test_vec2_i32_mult); + RUN_TEST(test_vec2_i32_dot); + RUN_TEST(test_vec2_i32_cross); RUN_TEST(test_vec3_f64_add); RUN_TEST(test_vec3_f64_sub); + RUN_TEST(test_vec3_f64_mult); + RUN_TEST(test_vec3_f64_dot); + RUN_TEST(test_vec3_f64_cross); RUN_TEST(test_vec3_i32_add); RUN_TEST(test_vec3_i32_sub); + RUN_TEST(test_vec3_i32_mult); + RUN_TEST(test_vec3_i32_dot); + RUN_TEST(test_vec3_i32_cross); return UNITY_END(); } From 760961618e8abfaa02d36a7d9ea0113bef374b61 Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Tue, 22 Jul 2025 06:15:11 -0500 Subject: [PATCH 11/12] :sparkles: Add types for coordinates --- include/juno/math/juno_math.h | 132 ++++++++--------- include/juno/math/juno_math_constants.h | 12 +- include/juno/math/juno_math_types.h | 181 +++++++++++++++++------- tests/test_la.c | 140 +++++++++--------- 4 files changed, 275 insertions(+), 190 deletions(-) diff --git a/include/juno/math/juno_math.h b/include/juno/math/juno_math.h index 544c0054..46c299ae 100644 --- a/include/juno/math/juno_math.h +++ b/include/juno/math/juno_math.h @@ -1,5 +1,5 @@ -#ifndef JUNO_MATH_H -#define JUNO_MATH_H +#ifndef JUNO_H +#define JUNO_H #include "juno_math_types.h" #include @@ -11,10 +11,10 @@ extern "C" { /** Add two vecf's together */ -static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2_f64_Add(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +static inline JUNO_VEC2_F64_T Juno_Vec2_f64_Add(JUNO_VEC2_F64_T tVec0, JUNO_VEC2_F64_T tVec1) { - tVec0.i += tVec1.i; - tVec0.j += tVec1.j; + tVec0.arr[0] += tVec1.arr[0]; + tVec0.arr[1] += tVec1.arr[1]; return tVec0; } @@ -24,45 +24,45 @@ static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2_f64_Add(JUNO_MATH_VEC2_F64_T tV @param tVec0 The vec to subtract from @param tVec1 The vec to subtract */ -static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2_f64_Sub(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +static inline JUNO_VEC2_F64_T Juno_Vec2_f64_Sub(JUNO_VEC2_F64_T tVec0, JUNO_VEC2_F64_T tVec1) { - tVec0.i -= tVec1.i; - tVec0.j -= tVec1.j; + tVec0.arr[0] -= tVec1.arr[0]; + tVec0.arr[1] -= tVec1.arr[1]; return tVec0; } /** Multiply scalar with vec2f's */ -static inline JUNO_MATH_VEC2_F64_T Juno_MathVec2_f64_Mult(JUNO_MATH_VEC2_F64_T tVec0, double dScalar) +static inline JUNO_VEC2_F64_T Juno_Vec2_f64_Mult(JUNO_VEC2_F64_T tVec0, double dScalar) { - tVec0.i *= dScalar; - tVec0.j *= dScalar; + tVec0.arr[0] *= dScalar; + tVec0.arr[1] *= dScalar; return tVec0; } /** Dot product of two vec2f's */ -static inline double Juno_MathVec2_f64_Dot(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +static inline double Juno_Vec2_f64_Dot(JUNO_VEC2_F64_T tVec0, JUNO_VEC2_F64_T tVec1) { - return tVec0.i * tVec1.i + tVec0.j * tVec1.j; + return tVec0.arr[0] * tVec1.arr[0] + tVec0.arr[1] * tVec1.arr[1]; } /** The cross product of two vec2f's. The result is a psedoscalar */ -static inline double Juno_MathVec2_f64_Cross(JUNO_MATH_VEC2_F64_T tVec0, JUNO_MATH_VEC2_F64_T tVec1) +static inline double Juno_Vec2_f64_Cross(JUNO_VEC2_F64_T tVec0, JUNO_VEC2_F64_T tVec1) { - return tVec0.i * tVec1.j - tVec0.j * tVec1.i; + return tVec0.arr[0] * tVec1.arr[1] - tVec0.arr[1] * tVec1.arr[0]; } /// Add two vec2i's -static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2_i32_Add(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +static inline JUNO_VEC2_I32_T Juno_Vec2_i32_Add(JUNO_VEC2_I32_T tVec0, JUNO_VEC2_I32_T tVec1) { - tVec0.i += tVec1.i; - tVec0.j += tVec1.j; + tVec0.arr[0] += tVec1.arr[0]; + tVec0.arr[1] += tVec1.arr[1]; return tVec0; } @@ -72,48 +72,48 @@ static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2_i32_Add(JUNO_MATH_VEC2_I32_T tV @param tVec0 The vec to subtract from @param tVec1 The vec to subtract */ -static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2_i32_Sub(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +static inline JUNO_VEC2_I32_T Juno_Vec2_i32_Sub(JUNO_VEC2_I32_T tVec0, JUNO_VEC2_I32_T tVec1) { - tVec0.i -= tVec1.i; - tVec0.j -= tVec1.j; + tVec0.arr[0] -= tVec1.arr[0]; + tVec0.arr[1] -= tVec1.arr[1]; return tVec0; } /** Multiply scalar with vec2f's */ -static inline JUNO_MATH_VEC2_I32_T Juno_MathVec2_i32_Mult(JUNO_MATH_VEC2_I32_T tVec0, int32_t dScalar) +static inline JUNO_VEC2_I32_T Juno_Vec2_i32_Mult(JUNO_VEC2_I32_T tVec0, int32_t dScalar) { - tVec0.i *= dScalar; - tVec0.j *= dScalar; + tVec0.arr[0] *= dScalar; + tVec0.arr[1] *= dScalar; return tVec0; } /** Dot product of two vec2i's */ -static inline int32_t Juno_MathVec2_i32_Dot(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +static inline int32_t Juno_Vec2_i32_Dot(JUNO_VEC2_I32_T tVec0, JUNO_VEC2_I32_T tVec1) { - return tVec0.i * tVec1.i + tVec0.j * tVec1.j; + return tVec0.arr[0] * tVec1.arr[0] + tVec0.arr[1] * tVec1.arr[1]; } /** The cross product of two vec2i's. The result is a psedoscalar */ -static inline int32_t Juno_MathVec2_i32_Cross(JUNO_MATH_VEC2_I32_T tVec0, JUNO_MATH_VEC2_I32_T tVec1) +static inline int32_t Juno_Vec2_i32_Cross(JUNO_VEC2_I32_T tVec0, JUNO_VEC2_I32_T tVec1) { - return tVec0.i * tVec1.j - tVec0.j * tVec1.i; + return tVec0.arr[0] * tVec1.arr[1] - tVec0.arr[1] * tVec1.arr[0]; } /** Add two vecf's together */ -static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3_f64_Add(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +static inline JUNO_VEC3_F64_T Juno_Vec3_f64_Add(JUNO_VEC3_F64_T tVec0, JUNO_VEC3_F64_T tVec1) { - tVec0.i += tVec1.i; - tVec0.j += tVec1.j; - tVec0.k += tVec1.k; + tVec0.arr[0] += tVec1.arr[0]; + tVec0.arr[1] += tVec1.arr[1]; + tVec0.arr[2] += tVec1.arr[2]; return tVec0; } @@ -123,53 +123,53 @@ static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3_f64_Add(JUNO_MATH_VEC3_F64_T tV @param tVec0 The vec to subtract from @param tVec1 The vec to subtract */ -static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3_f64_Sub(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +static inline JUNO_VEC3_F64_T Juno_Vec3_f64_Sub(JUNO_VEC3_F64_T tVec0, JUNO_VEC3_F64_T tVec1) { - tVec0.i -= tVec1.i; - tVec0.j -= tVec1.j; - tVec0.k -= tVec1.k; + tVec0.arr[0] -= tVec1.arr[0]; + tVec0.arr[1] -= tVec1.arr[1]; + tVec0.arr[2] -= tVec1.arr[2]; return tVec0; } /** Multiply scalar with vec2f's */ -static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3_f64_Mult(JUNO_MATH_VEC3_F64_T tVec0, double dScalar) +static inline JUNO_VEC3_F64_T Juno_Vec3_f64_Mult(JUNO_VEC3_F64_T tVec0, double dScalar) { - tVec0.i *= dScalar; - tVec0.j *= dScalar; - tVec0.k *= dScalar; + tVec0.arr[0] *= dScalar; + tVec0.arr[1] *= dScalar; + tVec0.arr[2] *= dScalar; return tVec0; } /** Dot product of two vec2f's */ -static inline double Juno_MathVec3_f64_Dot(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +static inline double Juno_Vec3_f64_Dot(JUNO_VEC3_F64_T tVec0, JUNO_VEC3_F64_T tVec1) { - return tVec0.i * tVec1.i + tVec0.j * tVec1.j + tVec0.k * tVec1.k; + return tVec0.arr[0] * tVec1.arr[0] + tVec0.arr[1] * tVec1.arr[1] + tVec0.arr[2] * tVec1.arr[2]; } /** The cross product of two vec2f's. The result is a psedoscalar */ -static inline JUNO_MATH_VEC3_F64_T Juno_MathVec3_f64_Cross(JUNO_MATH_VEC3_F64_T tVec0, JUNO_MATH_VEC3_F64_T tVec1) +static inline JUNO_VEC3_F64_T Juno_Vec3_f64_Cross(JUNO_VEC3_F64_T tVec0, JUNO_VEC3_F64_T tVec1) { - JUNO_MATH_VEC3_F64_T tRes = { - .i = tVec0.j * tVec1.k - tVec0.k * tVec1.j, - .j = tVec0.k * tVec1.i - tVec0.i * tVec1.k, - .k = tVec0.i * tVec1.j - tVec0.j * tVec1.i + JUNO_VEC3_F64_T tRes = { + .arr[0] = tVec0.arr[1] * tVec1.arr[2] - tVec0.arr[2] * tVec1.arr[1], + .arr[1] = tVec0.arr[2] * tVec1.arr[0] - tVec0.arr[0] * tVec1.arr[2], + .arr[2] = tVec0.arr[0] * tVec1.arr[1] - tVec0.arr[1] * tVec1.arr[0] }; return tRes; } /// Add two vec2i's -static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3_i32_Add(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +static inline JUNO_VEC3_I32_T Juno_Vec3_i32_Add(JUNO_VEC3_I32_T tVec0, JUNO_VEC3_I32_T tVec1) { - tVec0.i += tVec1.i; - tVec0.j += tVec1.j; - tVec0.k += tVec1.k; + tVec0.arr[0] += tVec1.arr[0]; + tVec0.arr[1] += tVec1.arr[1]; + tVec0.arr[2] += tVec1.arr[2]; return tVec0; } @@ -179,43 +179,43 @@ static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3_i32_Add(JUNO_MATH_VEC3_I32_T tV @param tVec0 The vec to subtract from @param tVec1 The vec to subtract */ -static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3_i32_Sub(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +static inline JUNO_VEC3_I32_T Juno_Vec3_i32_Sub(JUNO_VEC3_I32_T tVec0, JUNO_VEC3_I32_T tVec1) { - tVec0.i -= tVec1.i; - tVec0.j -= tVec1.j; - tVec0.k -= tVec1.k; + tVec0.arr[0] -= tVec1.arr[0]; + tVec0.arr[1] -= tVec1.arr[1]; + tVec0.arr[2] -= tVec1.arr[2]; return tVec0; } /** Multiply scalar with vec2f's */ -static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3_i32_Mult(JUNO_MATH_VEC3_I32_T tVec0, int32_t dScalar) +static inline JUNO_VEC3_I32_T Juno_Vec3_i32_Mult(JUNO_VEC3_I32_T tVec0, int32_t dScalar) { - tVec0.i *= dScalar; - tVec0.j *= dScalar; - tVec0.k *= dScalar; + tVec0.arr[0] *= dScalar; + tVec0.arr[1] *= dScalar; + tVec0.arr[2] *= dScalar; return tVec0; } /** Dot product of two vec2i's */ -static inline int32_t Juno_MathVec3_i32_Dot(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +static inline int32_t Juno_Vec3_i32_Dot(JUNO_VEC3_I32_T tVec0, JUNO_VEC3_I32_T tVec1) { - return tVec0.i * tVec1.i + tVec0.j * tVec1.j + tVec0.k * tVec1.k; + return tVec0.arr[0] * tVec1.arr[0] + tVec0.arr[1] * tVec1.arr[1] + tVec0.arr[2] * tVec1.arr[2]; } /** The cross product of two vec2i's. The result is a psedoscalar */ -static inline JUNO_MATH_VEC3_I32_T Juno_MathVec3_i32_Cross(JUNO_MATH_VEC3_I32_T tVec0, JUNO_MATH_VEC3_I32_T tVec1) +static inline JUNO_VEC3_I32_T Juno_Vec3_i32_Cross(JUNO_VEC3_I32_T tVec0, JUNO_VEC3_I32_T tVec1) { - JUNO_MATH_VEC3_I32_T tRes = { - .i = tVec0.j * tVec1.k - tVec0.k * tVec1.j, - .j = tVec0.k * tVec1.i - tVec0.i * tVec1.k, - .k = tVec0.i * tVec1.j - tVec0.j * tVec1.i + JUNO_VEC3_I32_T tRes = { + .arr[0] = tVec0.arr[1] * tVec1.arr[2] - tVec0.arr[2] * tVec1.arr[1], + .arr[1] = tVec0.arr[2] * tVec1.arr[0] - tVec0.arr[0] * tVec1.arr[2], + .arr[2] = tVec0.arr[0] * tVec1.arr[1] - tVec0.arr[1] * tVec1.arr[0] }; return tRes; } diff --git a/include/juno/math/juno_math_constants.h b/include/juno/math/juno_math_constants.h index f2b11d32..f5a2b946 100644 --- a/include/juno/math/juno_math_constants.h +++ b/include/juno/math/juno_math_constants.h @@ -1,5 +1,5 @@ -#ifndef JUNO_MATH_CONST_H -#define JUNO_MATH_CONST_H +#ifndef JUNO_CONST_H +#define JUNO_CONST_H #include "juno/module.h" @@ -7,10 +7,10 @@ extern "C" { #endif -#define JUNO_MATH_PI 3.141592653589793 -#define JUNO_MATH_HALF_PI 1.5707963267948966 -#define JUNO_MATH_QUART_PI 0.7853981633974483 -#define JUNO_MATH_E 2.718281828459045 +#define JUNO_PI 3.141592653589793 +#define JUNO_HALF_PI 1.5707963267948966 +#define JUNO_QUART_PI 0.7853981633974483 +#define JUNO_E 2.718281828459045 #ifdef __cplusplus } diff --git a/include/juno/math/juno_math_types.h b/include/juno/math/juno_math_types.h index 5a5a204f..3f4aa5a7 100644 --- a/include/juno/math/juno_math_types.h +++ b/include/juno/math/juno_math_types.h @@ -1,5 +1,5 @@ -#ifndef JUNO_MATH_TYPES_H -#define JUNO_MATH_TYPES_H +#ifndef JUNO_TYPES_H +#define JUNO_TYPES_H #include "juno/module.h" #ifdef __cplusplus @@ -7,111 +7,196 @@ extern "C" { #endif #include -#ifndef JUNO_MATH_INT_TYPE -#define JUNO_MATH_INT_TYPE int64_t +#ifndef JUNO_INT_TYPE +#define JUNO_INT_TYPE int64_t #endif -#ifndef JUNO_MATH_FLOAT_TYPE -#define JUNO_MATH_FLOAT_TYPE double +#ifndef JUNO_FLOAT_TYPE +#define JUNO_FLOAT_TYPE double #endif -typedef union JUNO_MATH_VEC2_F64_TAG +typedef struct JUNO_VEC2_F64_POLAR_TAG +{ + struct{double r, phi;}; +} JUNO_VEC2_F64_POLAR_T; + +JUNO_MODULE_RESULT(JUNO_VEC2_F64_POLAR_RESULT_T, JUNO_VEC2_F64_POLAR_T); + +typedef struct JUNO_VEC2_F64_CART_TAG { - struct{double i, j;}; struct{double x, y;}; +} JUNO_VEC2_F64_CART_T; + +JUNO_MODULE_RESULT(JUNO_VEC2_F64_CART_RESULT_T, JUNO_VEC2_F64_CART_T); + +typedef union JUNO_VEC2_F64_TAG +{ + JUNO_VEC2_F64_CART_T tCart; + JUNO_VEC2_F64_POLAR_T tPolar; double arr[2]; -} JUNO_MATH_VEC2_F64_T; +} JUNO_VEC2_F64_T; -JUNO_MODULE_RESULT(JUNO_MATH_VEC2F_RESULT_T, JUNO_MATH_VEC2_F64_T); +JUNO_MODULE_RESULT(JUNO_VEC2_F64_RESULT_T, JUNO_VEC2_F64_T); -typedef union JUNO_MATH_VEC2_I32_TAG +typedef struct JUNO_VEC2_I32_POLAR_TAG +{ + struct{int32_t r, phi;}; +} JUNO_VEC2_I32_POLAR_T; + +JUNO_MODULE_RESULT(JUNO_VEC2_I32_POLAR_RESULT_T, JUNO_VEC2_I32_POLAR_T); + +typedef struct JUNO_VEC2_I32_CART_TAG { - struct{int32_t i, j;}; struct{int32_t x, y;}; +} JUNO_VEC2_I32_CART_T; + +JUNO_MODULE_RESULT(JUNO_VEC2_I32_CART_RESULT_T, JUNO_VEC2_I32_CART_T); + +typedef union JUNO_VEC2_I32_TAG +{ + JUNO_VEC2_I32_CART_T tCart; + JUNO_VEC2_I32_POLAR_T tPolar; int32_t arr[2]; -} JUNO_MATH_VEC2_I32_T; +} JUNO_VEC2_I32_T; + +JUNO_MODULE_RESULT(JUNO_VEC2_I32_RESULT_T, JUNO_VEC2_I32_T); + +typedef struct JUNO_VEC3_F64_POLAR_TAG +{ + struct{double r, phi, theta;}; +} JUNO_VEC3_F64_POLAR_T; -JUNO_MODULE_RESULT(JUNO_MATH_VEC2I_RESULT_T, JUNO_MATH_VEC2_I32_T); +JUNO_MODULE_RESULT(JUNO_VEC3_F64_POLAR_RESULT_T, JUNO_VEC3_F64_POLAR_T); -typedef union JUNO_MATH_VEC3_F64_TAG +typedef struct JUNO_VEC3_F64_CART_TAG { - struct{double i, j, k;}; struct{double x, y, z;}; +} JUNO_VEC3_F64_CART_T; + +JUNO_MODULE_RESULT(JUNO_VEC3_F64_CART_RESULT_T, JUNO_VEC3_F64_CART_T); + +typedef union JUNO_VEC3_F64_TAG +{ + JUNO_VEC3_F64_CART_T tCart; + JUNO_VEC3_F64_POLAR_T tPolar; double arr[3]; -} JUNO_MATH_VEC3_F64_T; +} JUNO_VEC3_F64_T; -JUNO_MODULE_RESULT(JUNO_MATH_VEC3F_RESULT_T, JUNO_MATH_VEC3_F64_T); +JUNO_MODULE_RESULT(JUNO_VEC3F_RESULT_T, JUNO_VEC3_F64_T); -typedef union JUNO_MATH_VEC3_I32_TAG +typedef struct JUNO_VEC3_I32_POLAR_TAG +{ + struct{int32_t r, phi, theta;}; +} JUNO_VEC3_I32_POLAR_T; + +JUNO_MODULE_RESULT(JUNO_VEC3_I32_POLAR_RESULT_T, JUNO_VEC3_I32_POLAR_T); + +typedef struct JUNO_VEC3_I32_CART_TAG { - struct{int32_t i, j, k;}; struct{int32_t x, y, z;}; +} JUNO_VEC3_I32_CART_T; + +JUNO_MODULE_RESULT(JUNO_VEC3_I32_CART_RESULT_T, JUNO_VEC3_I32_CART_T); + +typedef union JUNO_VEC3_I32_TAG +{ + JUNO_VEC3_I32_CART_T tCart; + JUNO_VEC3_I32_POLAR_T tPolar; int32_t arr[3]; -} JUNO_MATH_VEC3_I32_T; +} JUNO_VEC3_I32_T; -JUNO_MODULE_RESULT(JUNO_MATH_VEC3I_RESULT_T, JUNO_MATH_VEC3_I32_T); +JUNO_MODULE_RESULT(JUNO_VEC3_I32_RESULT_T, JUNO_VEC3_I32_T); -typedef union JUNO_MATH_VEC4_F64_TAG +typedef struct JUNO_VEC4_F64_POLAR_TAG +{ + struct{double r, phi, theta, rho;}; +} JUNO_VEC4_F64_POLAR_T; + +JUNO_MODULE_RESULT(JUNO_VEC4_F64_POLAR_RESULT_T, JUNO_VEC4_F64_POLAR_T); + +typedef struct JUNO_VEC4_F64_CART_TAG { - struct{double i, j, k, l;}; struct{double x, y, z, w;}; +} JUNO_VEC4_F64_CART_T; + +JUNO_MODULE_RESULT(JUNO_VEC4_F64_CART_RESULT_T, JUNO_VEC4_F64_CART_T); + +typedef union JUNO_VEC4_F64_TAG +{ + JUNO_VEC4_F64_CART_T tCart; + JUNO_VEC4_F64_POLAR_T tPolar; double arr[4]; -} JUNO_MATH_VEC4_F64_T; +} JUNO_VEC4_F64_T; + +JUNO_MODULE_RESULT(JUNO_VEC4F_RESULT_T, JUNO_VEC3_F64_T); + +typedef struct JUNO_VEC4_I32_POLAR_TAG +{ + struct{int32_t r, phi, theta, rho;}; +} JUNO_VEC4_I32_POLAR_T; -JUNO_MODULE_RESULT(JUNO_MATH_VEC4F_RESULT_T, JUNO_MATH_VEC4_F64_T); +JUNO_MODULE_RESULT(JUNO_VEC4_I32_POLAR_RESULT_T, JUNO_VEC4_I32_POLAR_T); -typedef union JUNO_MATH_VEC4_I32_TAG +typedef struct JUNO_VEC4_I32_CART_TAG { - struct{int32_t i, j, k, l;}; struct{int32_t x, y, z, w;}; +} JUNO_VEC4_I32_CART_T; + +JUNO_MODULE_RESULT(JUNO_VEC4_I32_CART_RESULT_T, JUNO_VEC4_I32_CART_T); + +typedef union JUNO_VEC4_I32_TAG +{ + JUNO_VEC4_I32_CART_T tCart; + JUNO_VEC4_I32_POLAR_T tPolar; int32_t arr[4]; -} JUNO_MATH_VEC4_I32_T; +} JUNO_VEC4_I32_T; + +JUNO_MODULE_RESULT(JUNO_VEC4_I32_RESULT_T, JUNO_VEC4_I32_T); -JUNO_MODULE_RESULT(JUNO_MATH_VEC4I_RESULT_T, JUNO_MATH_VEC4_I32_T); -typedef struct JUNO_MATH_M3X3_F64_TAG +typedef struct JUNO_M3X3_F64_TAG { double mat[3][3]; -} JUNO_MATH_M3X3_F64_T; +} JUNO_M3X3_F64_T; -JUNO_MODULE_RESULT(JUNO_MATH_M3X3F_RESULT_T, JUNO_MATH_M3X3_F64_T); +JUNO_MODULE_RESULT(JUNO_M3X3F_RESULT_T, JUNO_M3X3_F64_T); -typedef struct JUNO_MATH_M4X4_F64_TAG +typedef struct JUNO_M4X4_F64_TAG { double mat[4][4]; -} JUNO_MATH_M4X4_F64_T; +} JUNO_M4X4_F64_T; -JUNO_MODULE_RESULT(JUNO_MATH_M4X4F_RESULT_T, JUNO_MATH_M4X4_F64_T); +JUNO_MODULE_RESULT(JUNO_M4X4F_RESULT_T, JUNO_M4X4_F64_T); -typedef struct JUNO_MATH_M3X3_I32_TAG +typedef struct JUNO_M3X3_I32_TAG { int32_t mat[3][3]; -} JUNO_MATH_M3X3_I32_T; +} JUNO_M3X3_I32_T; -JUNO_MODULE_RESULT(JUNO_MATH_M3X3I_RESULT_T, JUNO_MATH_M3X3_I32_T); +JUNO_MODULE_RESULT(JUNO_M3X3I_RESULT_T, JUNO_M3X3_I32_T); -typedef struct JUNO_MATH_M4X4_I32_TAG +typedef struct JUNO_M4X4_I32_TAG { int32_t mat[4][4]; -} JUNO_MATH_M4X4_I32_T; +} JUNO_M4X4_I32_T; -JUNO_MODULE_RESULT(JUNO_MATH_M4X4I_RESULT_T, JUNO_MATH_M4X4_I32_T); +JUNO_MODULE_RESULT(JUNO_M4X4I_RESULT_T, JUNO_M4X4_I32_T); -typedef union JUNO_MATH_RQUAT_F64_TAG +typedef union JUNO_RQUAT_F64_TAG { struct{double s, i, j, k;}; double quat[4]; -} JUNO_MATH_RQUAT_F64_T; +} JUNO_RQUAT_F64_T; -JUNO_MODULE_RESULT(JUNO_MATH_RQUATF_RESULT_T, JUNO_MATH_RQUAT_F64_T); +JUNO_MODULE_RESULT(JUNO_RQUATF_RESULT_T, JUNO_RQUAT_F64_T); -typedef union JUNO_MATH_RQUAT_I32_TAG +typedef union JUNO_RQUAT_I32_TAG { struct{int32_t s, i, j, k;}; int32_t quat[4]; -} JUNO_MATH_RQUAT_I32_T; +} JUNO_RQUAT_I32_T; -JUNO_MODULE_RESULT(JUNO_MATH_RQUATI_RESULT_T, JUNO_MATH_RQUAT_I32_T); +JUNO_MODULE_RESULT(JUNO_RQUATI_RESULT_T, JUNO_RQUAT_I32_T); #ifdef __cplusplus } diff --git a/tests/test_la.c b/tests/test_la.c index a39e0159..892e26bb 100644 --- a/tests/test_la.c +++ b/tests/test_la.c @@ -17,10 +17,10 @@ void tearDown(void) static void test_vec2_f64_add(void) { - JUNO_MATH_VEC2_F64_T tVec1 = {1, 2}; - JUNO_MATH_VEC2_F64_T tVec2 = {4, 5}; - JUNO_MATH_VEC2_F64_T tRes = Juno_MathVec2_f64_Add(tVec1, tVec2); - JUNO_MATH_VEC2_F64_T tTruth = {5, 7}; + JUNO_VEC2_F64_T tVec1 = {1, 2}; + JUNO_VEC2_F64_T tVec2 = {4, 5}; + JUNO_VEC2_F64_T tRes = Juno_Vec2_f64_Add(tVec1, tVec2); + JUNO_VEC2_F64_T tTruth = {5, 7}; for(uint8_t i = 0; i < 2; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -29,10 +29,10 @@ static void test_vec2_f64_add(void) static void test_vec2_f64_sub(void) { - JUNO_MATH_VEC2_F64_T tVec1 = {1, 2}; - JUNO_MATH_VEC2_F64_T tVec2 = {4, 5}; - JUNO_MATH_VEC2_F64_T tRes = Juno_MathVec2_f64_Sub(tVec1, tVec2); - JUNO_MATH_VEC2_F64_T tTruth = {-3, -3}; + JUNO_VEC2_F64_T tVec1 = {1, 2}; + JUNO_VEC2_F64_T tVec2 = {4, 5}; + JUNO_VEC2_F64_T tRes = Juno_Vec2_f64_Sub(tVec1, tVec2); + JUNO_VEC2_F64_T tTruth = {-3, -3}; for(uint8_t i = 0; i < 2; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -41,9 +41,9 @@ static void test_vec2_f64_sub(void) static void test_vec2_f64_mult(void) { - JUNO_MATH_VEC2_F64_T tVec1 = {1, 2}; - JUNO_MATH_VEC2_F64_T tRes = Juno_MathVec2_f64_Mult(tVec1, 2); - JUNO_MATH_VEC2_F64_T tTruth = {2, 4}; + JUNO_VEC2_F64_T tVec1 = {1, 2}; + JUNO_VEC2_F64_T tRes = Juno_Vec2_f64_Mult(tVec1, 2); + JUNO_VEC2_F64_T tTruth = {2, 4}; for(uint8_t i = 0; i < 2; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -52,28 +52,28 @@ static void test_vec2_f64_mult(void) static void test_vec2_f64_dot(void) { - JUNO_MATH_VEC2_F64_T tVec1 = {1, 2}; - JUNO_MATH_VEC2_F64_T tVec2 = {4, 5}; - double tRes = Juno_MathVec2_f64_Dot(tVec1, tVec2); + JUNO_VEC2_F64_T tVec1 = {1, 2}; + JUNO_VEC2_F64_T tVec2 = {4, 5}; + double tRes = Juno_Vec2_f64_Dot(tVec1, tVec2); double tTruth = 14; TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); } static void test_vec2_f64_cross(void) { - JUNO_MATH_VEC2_F64_T tVec1 = {1, 2}; - JUNO_MATH_VEC2_F64_T tVec2 = {4, 5}; - double tRes = Juno_MathVec2_f64_Cross(tVec1, tVec2); + JUNO_VEC2_F64_T tVec1 = {1, 2}; + JUNO_VEC2_F64_T tVec2 = {4, 5}; + double tRes = Juno_Vec2_f64_Cross(tVec1, tVec2); double tTruth = -3; TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); } static void test_vec2_i32_add(void) { - JUNO_MATH_VEC2_I32_T tVec1 = {1, 2}; - JUNO_MATH_VEC2_I32_T tVec2 = {4, 5}; - JUNO_MATH_VEC2_I32_T tRes = Juno_MathVec2_i32_Add(tVec1, tVec2); - JUNO_MATH_VEC2_I32_T tTruth = {5, 7}; + JUNO_VEC2_I32_T tVec1 = {1, 2}; + JUNO_VEC2_I32_T tVec2 = {4, 5}; + JUNO_VEC2_I32_T tRes = Juno_Vec2_i32_Add(tVec1, tVec2); + JUNO_VEC2_I32_T tTruth = {5, 7}; for(uint8_t i = 0; i < 2; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -82,10 +82,10 @@ static void test_vec2_i32_add(void) static void test_vec2_i32_sub(void) { - JUNO_MATH_VEC2_I32_T tVec1 = {1, 2}; - JUNO_MATH_VEC2_I32_T tVec2 = {4, 5}; - JUNO_MATH_VEC2_I32_T tRes = Juno_MathVec2_i32_Sub(tVec1, tVec2); - JUNO_MATH_VEC2_I32_T tTruth = {-3, -3}; + JUNO_VEC2_I32_T tVec1 = {1, 2}; + JUNO_VEC2_I32_T tVec2 = {4, 5}; + JUNO_VEC2_I32_T tRes = Juno_Vec2_i32_Sub(tVec1, tVec2); + JUNO_VEC2_I32_T tTruth = {-3, -3}; for(uint8_t i = 0; i < 2; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -94,9 +94,9 @@ static void test_vec2_i32_sub(void) static void test_vec2_i32_mult(void) { - JUNO_MATH_VEC2_I32_T tVec1 = {1, 2}; - JUNO_MATH_VEC2_I32_T tRes = Juno_MathVec2_i32_Mult(tVec1, 2); - JUNO_MATH_VEC2_I32_T tTruth = {2, 4}; + JUNO_VEC2_I32_T tVec1 = {1, 2}; + JUNO_VEC2_I32_T tRes = Juno_Vec2_i32_Mult(tVec1, 2); + JUNO_VEC2_I32_T tTruth = {2, 4}; for(uint8_t i = 0; i < 2; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -105,18 +105,18 @@ static void test_vec2_i32_mult(void) static void test_vec2_i32_dot(void) { - JUNO_MATH_VEC2_I32_T tVec1 = {1, 2}; - JUNO_MATH_VEC2_I32_T tVec2 = {4, 5}; - int32_t tRes = Juno_MathVec2_i32_Dot(tVec1, tVec2); + JUNO_VEC2_I32_T tVec1 = {1, 2}; + JUNO_VEC2_I32_T tVec2 = {4, 5}; + int32_t tRes = Juno_Vec2_i32_Dot(tVec1, tVec2); int32_t tTruth = 14; TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); } static void test_vec2_i32_cross(void) { - JUNO_MATH_VEC2_I32_T tVec1 = {1, 2}; - JUNO_MATH_VEC2_I32_T tVec2 = {4, 5}; - int32_t tRes = Juno_MathVec2_i32_Cross(tVec1, tVec2); + JUNO_VEC2_I32_T tVec1 = {1, 2}; + JUNO_VEC2_I32_T tVec2 = {4, 5}; + int32_t tRes = Juno_Vec2_i32_Cross(tVec1, tVec2); int32_t tTruth = -3; TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); } @@ -124,10 +124,10 @@ static void test_vec2_i32_cross(void) static void test_vec3_f64_add(void) { - JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; - JUNO_MATH_VEC3_F64_T tVec2 = {4, 5, 6}; - JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3_f64_Add(tVec1, tVec2); - JUNO_MATH_VEC3_F64_T tTruth = {5, 7, 9}; + JUNO_VEC3_F64_T tVec1 = {1, 2, 3}; + JUNO_VEC3_F64_T tVec2 = {4, 5, 6}; + JUNO_VEC3_F64_T tRes = Juno_Vec3_f64_Add(tVec1, tVec2); + JUNO_VEC3_F64_T tTruth = {5, 7, 9}; for(uint8_t i = 0; i < 3; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -136,10 +136,10 @@ static void test_vec3_f64_add(void) static void test_vec3_f64_sub(void) { - JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; - JUNO_MATH_VEC3_F64_T tVec2 = {4, 5, 6}; - JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3_f64_Sub(tVec1, tVec2); - JUNO_MATH_VEC3_F64_T tTruth = {-3, -3, -3}; + JUNO_VEC3_F64_T tVec1 = {1, 2, 3}; + JUNO_VEC3_F64_T tVec2 = {4, 5, 6}; + JUNO_VEC3_F64_T tRes = Juno_Vec3_f64_Sub(tVec1, tVec2); + JUNO_VEC3_F64_T tTruth = {-3, -3, -3}; for(uint8_t i = 0; i < 3; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -148,9 +148,9 @@ static void test_vec3_f64_sub(void) static void test_vec3_f64_mult(void) { - JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; - JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3_f64_Mult(tVec1, 2); - JUNO_MATH_VEC3_F64_T tTruth = {2, 4, 6}; + JUNO_VEC3_F64_T tVec1 = {1, 2, 3}; + JUNO_VEC3_F64_T tRes = Juno_Vec3_f64_Mult(tVec1, 2); + JUNO_VEC3_F64_T tTruth = {2, 4, 6}; for(uint8_t i = 0; i < 3; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -159,19 +159,19 @@ static void test_vec3_f64_mult(void) static void test_vec3_f64_dot(void) { - JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; - JUNO_MATH_VEC3_F64_T tVec2 = {4, 5, 6}; - double tRes = Juno_MathVec3_f64_Dot(tVec1, tVec2); + JUNO_VEC3_F64_T tVec1 = {1, 2, 3}; + JUNO_VEC3_F64_T tVec2 = {4, 5, 6}; + double tRes = Juno_Vec3_f64_Dot(tVec1, tVec2); double tTruth = 32; TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); } static void test_vec3_f64_cross(void) { - JUNO_MATH_VEC3_F64_T tVec1 = {1, 2, 3}; - JUNO_MATH_VEC3_F64_T tVec2 = {4, 5, 6}; - JUNO_MATH_VEC3_F64_T tRes = Juno_MathVec3_f64_Cross(tVec1, tVec2); - JUNO_MATH_VEC3_F64_T tTruth = {-3, 6, -3}; + JUNO_VEC3_F64_T tVec1 = {1, 2, 3}; + JUNO_VEC3_F64_T tVec2 = {4, 5, 6}; + JUNO_VEC3_F64_T tRes = Juno_Vec3_f64_Cross(tVec1, tVec2); + JUNO_VEC3_F64_T tTruth = {-3, 6, -3}; for(uint8_t i = 0; i < 3; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -180,10 +180,10 @@ static void test_vec3_f64_cross(void) static void test_vec3_i32_add(void) { - JUNO_MATH_VEC3_I32_T tVec1 = {1, 2, 3}; - JUNO_MATH_VEC3_I32_T tVec2 = {4, 5, 6}; - JUNO_MATH_VEC3_I32_T tRes = Juno_MathVec3_i32_Add(tVec1, tVec2); - JUNO_MATH_VEC3_I32_T tTruth = {5, 7, 9}; + JUNO_VEC3_I32_T tVec1 = {1, 2, 3}; + JUNO_VEC3_I32_T tVec2 = {4, 5, 6}; + JUNO_VEC3_I32_T tRes = Juno_Vec3_i32_Add(tVec1, tVec2); + JUNO_VEC3_I32_T tTruth = {5, 7, 9}; for(uint8_t i = 0; i < 3; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -192,10 +192,10 @@ static void test_vec3_i32_add(void) static void test_vec3_i32_sub(void) { - JUNO_MATH_VEC3_I32_T tVec1 = {1, 2, 3}; - JUNO_MATH_VEC3_I32_T tVec2 = {4, 5, 6}; - JUNO_MATH_VEC3_I32_T tRes = Juno_MathVec3_i32_Sub(tVec1, tVec2); - JUNO_MATH_VEC3_I32_T tTruth = {-3, -3, -3}; + JUNO_VEC3_I32_T tVec1 = {1, 2, 3}; + JUNO_VEC3_I32_T tVec2 = {4, 5, 6}; + JUNO_VEC3_I32_T tRes = Juno_Vec3_i32_Sub(tVec1, tVec2); + JUNO_VEC3_I32_T tTruth = {-3, -3, -3}; for(uint8_t i = 0; i < 3; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -204,9 +204,9 @@ static void test_vec3_i32_sub(void) static void test_vec3_i32_mult(void) { - JUNO_MATH_VEC3_I32_T tVec1 = {1, 2, 3}; - JUNO_MATH_VEC3_I32_T tRes = Juno_MathVec3_i32_Mult(tVec1, 2); - JUNO_MATH_VEC3_I32_T tTruth = {2, 4, 6}; + JUNO_VEC3_I32_T tVec1 = {1, 2, 3}; + JUNO_VEC3_I32_T tRes = Juno_Vec3_i32_Mult(tVec1, 2); + JUNO_VEC3_I32_T tTruth = {2, 4, 6}; for(uint8_t i = 0; i < 3; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); @@ -215,19 +215,19 @@ static void test_vec3_i32_mult(void) static void test_vec3_i32_dot(void) { - JUNO_MATH_VEC3_I32_T tVec1 = {1, 2, 3}; - JUNO_MATH_VEC3_I32_T tVec2 = {4, 5, 6}; - double tRes = Juno_MathVec3_i32_Dot(tVec1, tVec2); + JUNO_VEC3_I32_T tVec1 = {1, 2, 3}; + JUNO_VEC3_I32_T tVec2 = {4, 5, 6}; + double tRes = Juno_Vec3_i32_Dot(tVec1, tVec2); double tTruth = 32; TEST_ASSERT_EQUAL_DOUBLE(tTruth, tRes); } static void test_vec3_i32_cross(void) { - JUNO_MATH_VEC3_I32_T tVec1 = {1, 2, 3}; - JUNO_MATH_VEC3_I32_T tVec2 = {4, 5, 6}; - JUNO_MATH_VEC3_I32_T tRes = Juno_MathVec3_i32_Cross(tVec1, tVec2); - JUNO_MATH_VEC3_I32_T tTruth = {-3, 6, -3}; + JUNO_VEC3_I32_T tVec1 = {1, 2, 3}; + JUNO_VEC3_I32_T tVec2 = {4, 5, 6}; + JUNO_VEC3_I32_T tRes = Juno_Vec3_i32_Cross(tVec1, tVec2); + JUNO_VEC3_I32_T tTruth = {-3, 6, -3}; for(uint8_t i = 0; i < 3; i++) { TEST_ASSERT_EQUAL_DOUBLE(tTruth.arr[i], tRes.arr[i]); From ed66cb80282125740ac75e5e38999beb47350c6f Mon Sep 17 00:00:00 2001 From: Robin Onsay Date: Tue, 22 Jul 2025 06:49:34 -0500 Subject: [PATCH 12/12] :sparkles: Add documentation to math types --- include/juno/math/juno_math_types.h | 418 +++++++++++++++++++++++----- include/juno/module.h | 13 + 2 files changed, 366 insertions(+), 65 deletions(-) diff --git a/include/juno/math/juno_math_types.h b/include/juno/math/juno_math_types.h index 3f4aa5a7..af121a4b 100644 --- a/include/juno/math/juno_math_types.h +++ b/include/juno/math/juno_math_types.h @@ -14,191 +14,479 @@ extern "C" { #ifndef JUNO_FLOAT_TYPE #define JUNO_FLOAT_TYPE double #endif - +/** + * @struct JUNO_VEC2_F64_POLAR_TAG + * @brief 2D vector in polar coordinates (double precision). + * + * Contains radial distance and angle in radians. + */ typedef struct JUNO_VEC2_F64_POLAR_TAG { - struct{double r, phi;}; + struct { + double r; /**< Radial distance from the origin. */ + double phi; /**< Angle in radians from the x-axis. */ + }; } JUNO_VEC2_F64_POLAR_T; -JUNO_MODULE_RESULT(JUNO_VEC2_F64_POLAR_RESULT_T, JUNO_VEC2_F64_POLAR_T); - +/** + * @struct JUNO_VEC2_F64_CART_TAG + * @brief 2D vector in Cartesian coordinates (double precision). + * + * Contains x and y components. + */ typedef struct JUNO_VEC2_F64_CART_TAG { - struct{double x, y;}; + struct { + double x; /**< X component. */ + double y; /**< Y component. */ + }; } JUNO_VEC2_F64_CART_T; -JUNO_MODULE_RESULT(JUNO_VEC2_F64_CART_RESULT_T, JUNO_VEC2_F64_CART_T); - +/** + * @union JUNO_VEC2_F64_TAG + * @brief 2D vector union supporting Cartesian, polar, and array access (double precision). + * + * - tCart: Cartesian form. + * - tPolar: Polar form. + * - arr: Raw component array [0]=x/r, [1]=y/phi. + */ typedef union JUNO_VEC2_F64_TAG { - JUNO_VEC2_F64_CART_T tCart; - JUNO_VEC2_F64_POLAR_T tPolar; - double arr[2]; + JUNO_VEC2_F64_CART_T tCart; /**< Cartesian coordinates. */ + JUNO_VEC2_F64_POLAR_T tPolar; /**< Polar coordinates. */ + double arr[2]; /**< Raw component array. */ } JUNO_VEC2_F64_T; +/** + * @typedef JUNO_VEC2_F64_POLAR_RESULT_T + * @brief Result type for functions returning JUNO_VEC2_F64_POLAR_T. + */ +JUNO_MODULE_RESULT(JUNO_VEC2_F64_POLAR_RESULT_T, JUNO_VEC2_F64_POLAR_T); + +/** + * @typedef JUNO_VEC2_F64_CART_RESULT_T + * @brief Result type for functions returning JUNO_VEC2_F64_CART_T. + */ +JUNO_MODULE_RESULT(JUNO_VEC2_F64_CART_RESULT_T, JUNO_VEC2_F64_CART_T); + +/** + * @typedef JUNO_VEC2_F64_RESULT_T + * @brief Result type for functions returning JUNO_VEC2_F64_T. + */ JUNO_MODULE_RESULT(JUNO_VEC2_F64_RESULT_T, JUNO_VEC2_F64_T); +/** + * @struct JUNO_VEC2_I32_POLAR_TAG + * @brief 2D vector in polar coordinates (32-bit integer). + * + * Contains radial distance and angle. + */ typedef struct JUNO_VEC2_I32_POLAR_TAG { - struct{int32_t r, phi;}; + struct { + int32_t r; /**< Radial distance from the origin. */ + int32_t phi; /**< Angle unit (e.g., degrees or custom). */ + }; } JUNO_VEC2_I32_POLAR_T; -JUNO_MODULE_RESULT(JUNO_VEC2_I32_POLAR_RESULT_T, JUNO_VEC2_I32_POLAR_T); - +/** + * @struct JUNO_VEC2_I32_CART_TAG + * @brief 2D vector in Cartesian coordinates (32-bit integer). + * + * Contains x and y components. + */ typedef struct JUNO_VEC2_I32_CART_TAG { - struct{int32_t x, y;}; + struct { + int32_t x; /**< X component. */ + int32_t y; /**< Y component. */ + }; } JUNO_VEC2_I32_CART_T; -JUNO_MODULE_RESULT(JUNO_VEC2_I32_CART_RESULT_T, JUNO_VEC2_I32_CART_T); - +/** + * @union JUNO_VEC2_I32_TAG + * @brief 2D vector union supporting Cartesian, polar, and array access (32-bit integer). + * + * - tCart: Cartesian form. + * - tPolar: Polar form. + * - arr: Raw component array [0]=x/r, [1]=y/phi. + */ typedef union JUNO_VEC2_I32_TAG { - JUNO_VEC2_I32_CART_T tCart; - JUNO_VEC2_I32_POLAR_T tPolar; - int32_t arr[2]; + JUNO_VEC2_I32_CART_T tCart; /**< Cartesian coordinates. */ + JUNO_VEC2_I32_POLAR_T tPolar; /**< Polar coordinates. */ + int32_t arr[2]; /**< Raw component array. */ } JUNO_VEC2_I32_T; +/** + * @typedef JUNO_VEC2_I32_POLAR_RESULT_T + * @brief Result type for functions returning JUNO_VEC2_I32_POLAR_T. + */ +JUNO_MODULE_RESULT(JUNO_VEC2_I32_POLAR_RESULT_T, JUNO_VEC2_I32_POLAR_T); + +/** + * @typedef JUNO_VEC2_I32_CART_RESULT_T + * @brief Result type for functions returning JUNO_VEC2_I32_CART_T. + */ +JUNO_MODULE_RESULT(JUNO_VEC2_I32_CART_RESULT_T, JUNO_VEC2_I32_CART_T); + +/** + * @typedef JUNO_VEC2_I32_RESULT_T + * @brief Result type for functions returning JUNO_VEC2_I32_T. + */ JUNO_MODULE_RESULT(JUNO_VEC2_I32_RESULT_T, JUNO_VEC2_I32_T); +/** + * @struct JUNO_VEC3_F64_POLAR_TAG + * @brief 3D vector in spherical coordinates (double precision). + * + * Contains radius, azimuthal angle (phi), and polar angle (theta). + */ typedef struct JUNO_VEC3_F64_POLAR_TAG { - struct{double r, phi, theta;}; + struct { + double r; /**< Radial distance from the origin. */ + double phi; /**< Azimuthal angle in radians. */ + double theta; /**< Polar angle in radians. */ + }; } JUNO_VEC3_F64_POLAR_T; -JUNO_MODULE_RESULT(JUNO_VEC3_F64_POLAR_RESULT_T, JUNO_VEC3_F64_POLAR_T); - +/** + * @struct JUNO_VEC3_F64_CART_TAG + * @brief 3D vector in Cartesian coordinates (double precision). + * + * Contains x, y, and z components. + */ typedef struct JUNO_VEC3_F64_CART_TAG { - struct{double x, y, z;}; + struct { + double x; /**< X component. */ + double y; /**< Y component. */ + double z; /**< Z component. */ + }; } JUNO_VEC3_F64_CART_T; -JUNO_MODULE_RESULT(JUNO_VEC3_F64_CART_RESULT_T, JUNO_VEC3_F64_CART_T); - +/** + * @union JUNO_VEC3_F64_TAG + * @brief 3D vector union supporting Cartesian, spherical, and array access (double precision). + * + * - tCart: Cartesian form. + * - tPolar: Spherical form. + * - arr: Raw component array [0]=x/r, [1]=y/phi, [2]=z/theta. + */ typedef union JUNO_VEC3_F64_TAG { - JUNO_VEC3_F64_CART_T tCart; - JUNO_VEC3_F64_POLAR_T tPolar; - double arr[3]; + JUNO_VEC3_F64_CART_T tCart; /**< Cartesian coordinates. */ + JUNO_VEC3_F64_POLAR_T tPolar; /**< Spherical coordinates. */ + double arr[3]; /**< Raw component array. */ } JUNO_VEC3_F64_T; +/** + * @typedef JUNO_VEC3_F64_POLAR_RESULT_T + * @brief Result type for functions returning JUNO_VEC3_F64_POLAR_T. + */ +JUNO_MODULE_RESULT(JUNO_VEC3_F64_POLAR_RESULT_T, JUNO_VEC3_F64_POLAR_T); + +/** + * @typedef JUNO_VEC3_F64_CART_RESULT_T + * @brief Result type for functions returning JUNO_VEC3_F64_CART_T. + */ +JUNO_MODULE_RESULT(JUNO_VEC3_F64_CART_RESULT_T, JUNO_VEC3_F64_CART_T); + +/** + * @typedef JUNO_VEC3F_RESULT_T + * @brief Result type for functions returning JUNO_VEC3_F64_T. + */ JUNO_MODULE_RESULT(JUNO_VEC3F_RESULT_T, JUNO_VEC3_F64_T); +/** + * @struct JUNO_VEC3_I32_POLAR_TAG + * @brief 3D vector in spherical coordinates (32-bit integer). + * + * Contains radius, azimuthal angle, and polar angle. + */ typedef struct JUNO_VEC3_I32_POLAR_TAG { - struct{int32_t r, phi, theta;}; + struct { + int32_t r; /**< Radial distance from the origin. */ + int32_t phi; /**< Azimuthal angle unit. */ + int32_t theta; /**< Polar angle unit. */ + }; } JUNO_VEC3_I32_POLAR_T; -JUNO_MODULE_RESULT(JUNO_VEC3_I32_POLAR_RESULT_T, JUNO_VEC3_I32_POLAR_T); - +/** + * @struct JUNO_VEC3_I32_CART_TAG + * @brief 3D vector in Cartesian coordinates (32-bit integer). + * + * Contains x, y, and z components. + */ typedef struct JUNO_VEC3_I32_CART_TAG { - struct{int32_t x, y, z;}; + struct { + int32_t x; /**< X component. */ + int32_t y; /**< Y component. */ + int32_t z; /**< Z component. */ + }; } JUNO_VEC3_I32_CART_T; -JUNO_MODULE_RESULT(JUNO_VEC3_I32_CART_RESULT_T, JUNO_VEC3_I32_CART_T); - +/** + * @union JUNO_VEC3_I32_TAG + * @brief 3D vector union supporting Cartesian, spherical, and array access (32-bit integer). + * + * - tCart: Cartesian form. + * - tPolar: Spherical form. + * - arr: Raw component array [0]=x/r, [1]=y/phi, [2]=z/theta. + */ typedef union JUNO_VEC3_I32_TAG { - JUNO_VEC3_I32_CART_T tCart; - JUNO_VEC3_I32_POLAR_T tPolar; - int32_t arr[3]; + JUNO_VEC3_I32_CART_T tCart; /**< Cartesian coordinates. */ + JUNO_VEC3_I32_POLAR_T tPolar; /**< Spherical coordinates. */ + int32_t arr[3]; /**< Raw component array. */ } JUNO_VEC3_I32_T; +/** + * @typedef JUNO_VEC3_I32_POLAR_RESULT_T + * @brief Result type for functions returning JUNO_VEC3_I32_POLAR_T. + */ +JUNO_MODULE_RESULT(JUNO_VEC3_I32_POLAR_RESULT_T, JUNO_VEC3_I32_POLAR_T); + +/** + * @typedef JUNO_VEC3_I32_CART_RESULT_T + * @brief Result type for functions returning JUNO_VEC3_I32_CART_T. + */ +JUNO_MODULE_RESULT(JUNO_VEC3_I32_CART_RESULT_T, JUNO_VEC3_I32_CART_T); + +/** + * @typedef JUNO_VEC3_I32_RESULT_T + * @brief Result type for functions returning JUNO_VEC3_I32_T. + */ JUNO_MODULE_RESULT(JUNO_VEC3_I32_RESULT_T, JUNO_VEC3_I32_T); +/** + * @struct JUNO_VEC4_F64_POLAR_TAG + * @brief 4D vector in hyperspherical coordinates (double precision). + * + * Contains radial distance and three angles. + */ typedef struct JUNO_VEC4_F64_POLAR_TAG { - struct{double r, phi, theta, rho;}; + struct { + double r; /**< Radial distance from the origin. */ + double phi; /**< First angular coordinate. */ + double theta; /**< Second angular coordinate. */ + double rho; /**< Third angular coordinate. */ + }; } JUNO_VEC4_F64_POLAR_T; -JUNO_MODULE_RESULT(JUNO_VEC4_F64_POLAR_RESULT_T, JUNO_VEC4_F64_POLAR_T); - +/** + * @struct JUNO_VEC4_F64_CART_TAG + * @brief 4D vector in Cartesian coordinates (double precision). + * + * Contains x, y, z, and w components. + */ typedef struct JUNO_VEC4_F64_CART_TAG { - struct{double x, y, z, w;}; + struct { + double x; /**< X component. */ + double y; /**< Y component. */ + double z; /**< Z component. */ + double w; /**< W component. */ + }; } JUNO_VEC4_F64_CART_T; -JUNO_MODULE_RESULT(JUNO_VEC4_F64_CART_RESULT_T, JUNO_VEC4_F64_CART_T); - +/** + * @union JUNO_VEC4_F64_TAG + * @brief 4D vector union supporting Cartesian, hyperspherical, and array access (double precision). + * + * - tCart: Cartesian form. + * - tPolar: Hyperspherical form. + * - arr: Raw component array [0]=x/r, [1]=y/phi, [2]=z/theta, [3]=w/rho. + */ typedef union JUNO_VEC4_F64_TAG { - JUNO_VEC4_F64_CART_T tCart; - JUNO_VEC4_F64_POLAR_T tPolar; - double arr[4]; + JUNO_VEC4_F64_CART_T tCart; /**< Cartesian coordinates. */ + JUNO_VEC4_F64_POLAR_T tPolar; /**< Hyperspherical coordinates. */ + double arr[4]; /**< Raw component array. */ } JUNO_VEC4_F64_T; +/** + * @typedef JUNO_VEC4F_RESULT_T + * @brief Result type for functions returning JUNO_VEC3_F64_T (per original macro invocation). + */ JUNO_MODULE_RESULT(JUNO_VEC4F_RESULT_T, JUNO_VEC3_F64_T); +/** + * @struct JUNO_VEC4_I32_POLAR_TAG + * @brief 4D vector in hyperspherical coordinates (32-bit integer). + * + * Contains radial distance and three angles. + */ typedef struct JUNO_VEC4_I32_POLAR_TAG { - struct{int32_t r, phi, theta, rho;}; + struct { + int32_t r; /**< Radial distance from the origin. */ + int32_t phi; /**< First angular coordinate. */ + int32_t theta; /**< Second angular coordinate. */ + int32_t rho; /**< Third angular coordinate. */ + }; } JUNO_VEC4_I32_POLAR_T; -JUNO_MODULE_RESULT(JUNO_VEC4_I32_POLAR_RESULT_T, JUNO_VEC4_I32_POLAR_T); - +/** + * @struct JUNO_VEC4_I32_CART_TAG + * @brief 4D vector in Cartesian coordinates (32-bit integer). + * + * Contains x, y, z, and w components. + */ typedef struct JUNO_VEC4_I32_CART_TAG { - struct{int32_t x, y, z, w;}; + struct { + int32_t x; /**< X component. */ + int32_t y; /**< Y component. */ + int32_t z; /**< Z component. */ + int32_t w; /**< W component. */ + }; } JUNO_VEC4_I32_CART_T; -JUNO_MODULE_RESULT(JUNO_VEC4_I32_CART_RESULT_T, JUNO_VEC4_I32_CART_T); - +/** + * @union JUNO_VEC4_I32_TAG + * @brief 4D vector union supporting Cartesian, hyperspherical, and array access (32-bit integer). + * + * - tCart: Cartesian form. + * - tPolar: Hyperspherical form. + * - arr: Raw component array [0]=x/r, [1]=y/phi, [2]=z/theta, [3]=w/rho. + */ typedef union JUNO_VEC4_I32_TAG { - JUNO_VEC4_I32_CART_T tCart; - JUNO_VEC4_I32_POLAR_T tPolar; - int32_t arr[4]; + JUNO_VEC4_I32_CART_T tCart; /**< Cartesian coordinates. */ + JUNO_VEC4_I32_POLAR_T tPolar; /**< Hyperspherical coordinates. */ + int32_t arr[4]; /**< Raw component array. */ } JUNO_VEC4_I32_T; -JUNO_MODULE_RESULT(JUNO_VEC4_I32_RESULT_T, JUNO_VEC4_I32_T); +/** + * @typedef JUNO_VEC4_I32_POLAR_RESULT_T + * @brief Result type for functions returning JUNO_VEC4_I32_POLAR_T. + */ +JUNO_MODULE_RESULT(JUNO_VEC4_I32_POLAR_RESULT_T, JUNO_VEC4_I32_POLAR_T); +/** + * @typedef JUNO_VEC4_I32_CART_RESULT_T + * @brief Result type for functions returning JUNO_VEC4_I32_CART_T. + */ +JUNO_MODULE_RESULT(JUNO_VEC4_I32_CART_RESULT_T, JUNO_VEC4_I32_CART_T); +/** + * @typedef JUNO_VEC4_I32_RESULT_T + * @brief Result type for functions returning JUNO_VEC4_I32_T. + */ +JUNO_MODULE_RESULT(JUNO_VEC4_I32_RESULT_T, JUNO_VEC4_I32_T); + +/** + * @struct JUNO_M3X3_F64_TAG + * @brief 3×3 matrix of double-precision values. + */ typedef struct JUNO_M3X3_F64_TAG { - double mat[3][3]; + double mat[3][3]; /**< Row-major 3×3 matrix. */ } JUNO_M3X3_F64_T; +/** + * @typedef JUNO_M3X3F_RESULT_T + * @brief Result type for functions returning JUNO_M3X3_F64_T. + */ JUNO_MODULE_RESULT(JUNO_M3X3F_RESULT_T, JUNO_M3X3_F64_T); +/** + * @struct JUNO_M4X4_F64_TAG + * @brief 4×4 matrix of double-precision values. + */ typedef struct JUNO_M4X4_F64_TAG { - double mat[4][4]; + double mat[4][4]; /**< Row-major 4×4 matrix. */ } JUNO_M4X4_F64_T; +/** + * @typedef JUNO_M4X4F_RESULT_T + * @brief Result type for functions returning JUNO_M4X4_F64_T. + */ JUNO_MODULE_RESULT(JUNO_M4X4F_RESULT_T, JUNO_M4X4_F64_T); +/** + * @struct JUNO_M3X3_I32_TAG + * @brief 3×3 matrix of 32-bit integers. + */ typedef struct JUNO_M3X3_I32_TAG { - int32_t mat[3][3]; + int32_t mat[3][3]; /**< Row-major 3×3 matrix. */ } JUNO_M3X3_I32_T; +/** + * @typedef JUNO_M3X3I_RESULT_T + * @brief Result type for functions returning JUNO_M3X3_I32_T. + */ JUNO_MODULE_RESULT(JUNO_M3X3I_RESULT_T, JUNO_M3X3_I32_T); +/** + * @struct JUNO_M4X4_I32_TAG + * @brief 4×4 matrix of 32-bit integers. + */ typedef struct JUNO_M4X4_I32_TAG { - int32_t mat[4][4]; + int32_t mat[4][4]; /**< Row-major 4×4 matrix. */ } JUNO_M4X4_I32_T; +/** + * @typedef JUNO_M4X4I_RESULT_T + * @brief Result type for functions returning JUNO_M4X4_I32_T. + */ JUNO_MODULE_RESULT(JUNO_M4X4I_RESULT_T, JUNO_M4X4_I32_T); +/** + * @union JUNO_RQUAT_F64_TAG + * @brief Right-handed quaternion (double precision). + * + * Can be accessed as individual components or raw array. + */ typedef union JUNO_RQUAT_F64_TAG { - struct{double s, i, j, k;}; - double quat[4]; + struct { + double s; /**< Scalar part. */ + double i; /**< First vector part. */ + double j; /**< Second vector part. */ + double k; /**< Third vector part. */ + }; + double quat[4]; /**< Raw quaternion array [s,i,j,k]. */ } JUNO_RQUAT_F64_T; +/** + * @typedef JUNO_RQUATF_RESULT_T + * @brief Result type for functions returning JUNO_RQUAT_F64_T. + */ JUNO_MODULE_RESULT(JUNO_RQUATF_RESULT_T, JUNO_RQUAT_F64_T); +/** + * @union JUNO_RQUAT_I32_TAG + * @brief Right-handed quaternion (32-bit integer). + * + * Can be accessed as individual components or raw array. + */ typedef union JUNO_RQUAT_I32_TAG { - struct{int32_t s, i, j, k;}; - int32_t quat[4]; + struct { + int32_t s; /**< Scalar part. */ + int32_t i; /**< First vector part. */ + int32_t j; /**< Second vector part. */ + int32_t k; /**< Third vector part. */ + }; + int32_t quat[4]; /**< Raw quaternion array [s,i,j,k]. */ } JUNO_RQUAT_I32_T; +/** + * @typedef JUNO_RQUATI_RESULT_T + * @brief Result type for functions returning JUNO_RQUAT_I32_T. + */ JUNO_MODULE_RESULT(JUNO_RQUATI_RESULT_T, JUNO_RQUAT_I32_T); #ifdef __cplusplus } #endif -#endif \ No newline at end of file +#endif diff --git a/include/juno/module.h b/include/juno/module.h index edde4595..d07dcfbc 100644 --- a/include/juno/module.h +++ b/include/juno/module.h @@ -206,6 +206,13 @@ */ #define JUNO_MODULE_GET_API(ptModule, ROOT_T) ((const ROOT_T *)ptModule)->ptApi + +/** + * @def JUNO_MODULE_RESULT(NAME_T, SUCCESS_T) + * @brief Defines a result type combining a status and a success payload. + * @param NAME_T Name of the result struct to define. + * @param SUCCESS_T Type of the success payload contained in the result. + */ #define JUNO_MODULE_RESULT(NAME_T, SUCCESS_T) \ typedef struct NAME_T \ { \ @@ -213,6 +220,12 @@ typedef struct NAME_T \ SUCCESS_T tSuccess; \ } NAME_T +/** + * @def JUNO_MODULE_OPTION(NAME_T, SUCCESS_T) + * @brief Defines an option type combining a flag to indicate some and a success payload. + * @param NAME_T Name of the result struct to define. + * @param SUCCESS_T Type of the success payload contained in the result. + */ #define JUNO_MODULE_OPTION(NAME_T, SOME_T) \ typedef struct NAME_T \ { \