arithmos: vector calculus and matrix algebra infrastructure

Author: pavly-gerges

electrostatic-sandbox-framework/electrostatic-core/src/include/electrostatic/electronetsoft/algorithm/arithmos/README.md

@@ -1,14 +1,14 @@
 # Arithmos _αριθμός_
 
-Arithmos is a set of APIs that target different taxonomies of algorithms to solve problems through providing _algorithm generic utilities_, and several implementations for the common _abstract data types (adt)_ commonly encountered during solving problems while building commericial applications or participating in problem solving contests.
+Arithmos is a set of APIs that target different taxonomies of algorithms to solve problems through providing _algorithm generic utilities_, and several implementations for the common _abstract data types (adt)_ commonly encountered during solving problems while building commercial applications or participating in problem solving contests.
 
 Arithmos is essentially composed of the following:
 - [x] Vector2d Library (Finished).
-- [ ] Vector3d Library.
-- [ ] MatrixNd Library.
+- [x] Vector3d Library (Partially Finished).
+- [x] MatrixNd Library (Partially Finished).
 - [ ] Discrete Sets Operations (Conjunctive, Disjunctive, Subtraction, Powersets, De'Morgans formulas).
 - [ ] Physics Simulation Library (Collision detection - Force Control - Objects interactions).
-- [ ] Statistics Algoritms Library (Present in Java - WIP to port).
+- [ ] Statistics Algorithms Library (Present in Java - WIP to port).
 - [ ] Differential and Integral Calculus Library.
 - [ ] Generic Algorithms Utilities Library.
 - [ ] Linear Algorithms Library.
@@ -52,7 +52,7 @@ Most of these libraries rely on the _Generic Algorithms Utilities Library_; this
     - Hashing Algorithms.
       - [ ] Modular Arithmetics.
     - Un-hashing Algorithms.
-    - Switching Algebra ALgorithms.
+    - Switching Algebra Algorithms.
       - [ ] Elementary Bit switching.
       - [ ] Elementary Bit shifting.
       - [ ] Elementary Byte switching.

electrostatic-sandbox-framework/electrostatic-core/src/libs/electrostatic-primer/electronetsoft/algorithm/arithmos/matrix/mat_add.c

@@ -0,0 +1,105 @@
+#include <electrostatic/electronetsoft/algorithm/arithmos/vectorspaces/matrix/matrix.h>
+
+struct mat_add_metadata {
+    matrix *m1;
+    matrix *output;
+    mat_processors *processors;
+};
+
+static inline status_code __on_entry_iterated(mat_proc_sig proc_sig) {
+    // preprocessing automata -- Machine Input
+    matrix m0 = proc_sig.mat;
+    uint64_t row = proc_sig.row_index;
+    uint64_t column = proc_sig.col_index;
+    struct mat_add_metadata *metadata = proc_sig.proc.metadata;
+
+    matrix m1 = *(metadata->m1);
+    matrix *out = metadata->output;
+    mat_processors user_proc = *(metadata->processors);
+
+    status_code __code;
+
+    // preprocessing automata -- Execute preprocessing sub-automata
+    if (NULL != user_proc.on_binary_op_preprocessor) {
+        __code = user_proc.on_binary_op_preprocessor((mat_binary_op_sig) {
+            .m0 = m0,
+            .m1 = m1,
+            .row_index = row,
+            .col_index = column,
+            .proc = user_proc,
+        });
+        if (PASS != __code) {
+            return __code;
+        }
+    }
+
+    // processing automata
+    out->element[row][column] =
+            m0.element[row][column] +
+                    m1.element[row][column];
+
+    // postprocessing chain
+    if (NULL != user_proc.on_elementary_op_postprocessor) {
+        __code = user_proc.on_elementary_op_postprocessor(proc_sig);
+        if (PASS != __code) {
+            return __code;
+        }
+    }
+    return PASS;
+}
+
+status_code mat_add(matrix m0, matrix m1,
+                    matrix *out,
+                    mat_processors processors) {
+
+    caller_graph caller = {
+      .api = "arithmos:matrix#mat_add",
+      .func = &mat_add,
+      .root = processors.root,
+    };
+
+    mat_proc_sig proc_sig = {
+        .proc = processors,
+        .caller = caller,
+        .metadata = processors.metadata,
+    };
+
+    if (rvalue(out) == NULL ||
+            rvalue(out->element) == NULL) {
+        return EUNDEFINEDBUFFER;
+    }
+
+    proc_sig.mat = *out;
+
+    if (m0.m != m1.m ||
+        m0.n != m1.n ||
+        m0.m != out->m ||
+        m0.n != out->n) {
+        return EBUFFERTURNCATION;
+    }
+
+    struct mat_add_metadata metadata = {
+        .m1 = &m1,
+        .output = out,
+        .processors = &processors, // performed a chained automata processors
+    };
+
+    mat_processors __proc = {
+         .on_entry_iterated = &__on_entry_iterated,
+         .metadata = &metadata
+    };
+
+    status_code __code = mat_iterate_elements(m0, ROW_CONVENTION_ITERATOR, __proc);
+    if (PASS != __code) {
+        if (NULL != processors.on_op_failure) {
+            processors.on_op_failure(proc_sig, __code);
+        }
+        return __code;
+    }
+
+    if (NULL != processors.on_op_success) {
+        processors.on_op_success(proc_sig);
+    }
+
+    return PASS;
+}

electrostatic-sandbox-framework/electrostatic-core/src/libs/electrostatic-primer/electronetsoft/algorithm/arithmos/matrix/mat_create_from_vector2d.c

@@ -0,0 +1,44 @@
+#include <electrostatic/electronetsoft/algorithm/arithmos/vectorspaces/matrix/matrix.h>
+
+status_code mat_create_from_vector2d(vector2d v, matrix *mat, mat_processors processors) {
+    caller_graph caller = {
+            .api = "arithmos:matrix#mat_create_from_vector2d",
+            .func = &mat_create_from_vector2d,
+            .root = processors.root,
+    };
+
+    mat_proc_sig proc_sig = {
+            .proc = processors,
+            .caller = caller,
+            .metadata = processors.metadata,
+    };
+
+    // preprocessor automata -- Test main matrix memory addresses
+    if (rvalue(mat) == NULL ||
+                rvalue(mat->element) == NULL) {
+        if (NULL != processors.on_op_failure) {
+            processors.on_op_failure(proc_sig, EUNDEFINEDBUFFER);
+        }
+        return EUNDEFINEDBUFFER;
+    }
+
+    // preprocessor automata -- Test elements allocation
+    if (rvalue(mat->element + 1) == NULL) {
+        if (NULL != processors.on_op_failure) {
+            processors.on_op_failure(proc_sig, EBUFFERTURNCATION);
+        }
+        return EBUFFERTURNCATION;
+    }
+
+    proc_sig.mat = *mat;
+
+    // processing automata -- Adapt elements
+    *(mat->element[0]) = v.x;
+    *(mat->element[1]) = v.y;
+
+    if (NULL != processors.on_op_success) {
+        processors.on_op_success(proc_sig);
+    }
+
+    return PASS;
+}

electrostatic-sandbox-framework/electrostatic-core/src/libs/electrostatic-primer/electronetsoft/algorithm/arithmos/matrix/mat_create_from_vector3d.c

@@ -0,0 +1,41 @@
+#include <electrostatic/electronetsoft/algorithm/arithmos/vectorspaces/matrix/matrix.h>
+
+status_code mat_create_from_vector3d(vector3d v, matrix *mat, mat_processors processors) {
+    caller_graph caller = {
+            .api = "arithmos:matrix#mat_create_from_vector3d",
+            .func = &mat_create_from_vector3d,
+            .root = processors.root,
+    };
+
+    mat_proc_sig proc_sig = {
+            .proc = processors,
+            .caller = caller,
+            .metadata = processors.metadata,
+    };
+
+    // preprocessor automata -- Test main matrix memory addresses
+    if (rvalue(mat) == NULL ||
+            rvalue(mat->element) == NULL) {
+        if (NULL != processors.on_op_failure) {
+            processors.on_op_failure(proc_sig, EUNDEFINEDBUFFER);
+        }
+        return EUNDEFINEDBUFFER;
+    }
+
+    proc_sig.mat = *mat;
+
+    // preprocessor automata -- Test elements allocation
+    if (rvalue(mat->element + 1) == NULL || rvalue(mat->element + 2) == NULL) {
+        if (NULL != processors.on_op_failure) {
+            processors.on_op_failure(proc_sig, EBUFFERTURNCATION);
+        }
+        return EBUFFERTURNCATION;
+    }
+
+    // processing automata -- Adapt elements
+    *(mat->element[0]) = v.x;
+    *(mat->element[1]) = v.y;
+    *(mat->element[2]) = v.z;
+
+    return PASS;
+}