added new addon functions for simpler working

Author: TheGAzed

include/cerpec.h

@@ -12,6 +12,13 @@
 #   define CERPEC_CHUNK 256
 #elif CERPEC_CHUNK <= 0
 #   error "Chunk size must be greater than zero."
+#elif (CERPEC_CHUNK & (CERPEC_CHUNK - 1))
+#   error "Chunk size must be a power of 2."
+#endif
+
+#ifdef NDEBUG
+#   define NERROR
+#   define NVALID
 #endif
 
 #ifndef NVALID

include/dodac.h

@@ -0,0 +1,239 @@
+#ifndef DODAC_H
+#define DODAC_H
+
+#include <stddef.h>
+#include <stdbool.h>
+
+#ifndef DODAC_SEED
+#    define DODAC_SEED 0x12345678
+#endif
+
+#define CHAR_FORMAT "%c"
+#define UCHAR_FORMAT "%c"
+#define INT_FORMAT "%d "
+#define UINT_FORMAT "%u "
+#define FLOAT_FORMAT "%f "
+#define FLOAT_FORMAT "%f "
+#define DOUBLE_FORMAT "%lf "
+#define SIZE_FORMAT "%zu "
+#define STRING_FORMAT "%s "
+
+void chardst(void * const element);
+
+void * charcpy(void * const destination, void const * const source);
+
+void * charsum(void * const sum, void const * const addent);
+
+size_t charhshsame(void const * const element);
+
+int charcmp(void const * const a, void const * const b);
+
+int charrcmp(void const * const a, void const * const b);
+
+bool charprint(void * const element, void * const format);
+
+bool chartolower(void * const element, void * const null);
+
+bool chartoupper(void * const element, void * const null);
+
+void charqsort(void * const array, size_t const lenght, void * const null);
+
+void charrqsort(void * const array, size_t const lenght, void * const null);
+
+bool chareven(void const * const element, void * const null);
+
+bool charodd(void const * const element, void * const null);
+
+bool charalnum(void const * const element, void * const null);
+
+bool charalpha(void const * const element, void * const null);
+
+bool charcntrl(void const * const element, void * const null);
+
+bool chardigit(void const * const element, void * const null);
+
+bool charlower(void const * const element, void * const null);
+
+bool charupper(void const * const element, void * const null);
+
+bool charpunct(void const * const element, void * const null);
+
+bool charspace(void const * const element, void * const null);
+
+bool charxdigit(void const * const element, void * const null);
+
+bool charprime(void const * const element, void * const null);
+
+void uchardst(void * const element);
+
+void * ucharcpy(void * const destination, void const * const source);
+
+void * ucharsum(void * const sum, void const * const addent);
+
+size_t ucharhshsame(void const * const element);
+
+int ucharcmp(void const * const a, void const * const b);
+
+int ucharrcmp(void const * const a, void const * const b);
+
+bool ucharprint(void * const element, void * const format);
+
+bool uchartolower(void * const element, void * const null);
+
+bool uchartoupper(void * const element, void * const null);
+
+void ucharqsort(void * const array, size_t const lenght, void * const null);
+
+void ucharrqsort(void * const array, size_t const lenght, void * const null);
+
+bool uchareven(void const * const element, void * const null);
+
+bool ucharodd(void const * const element, void * const null);
+
+bool ucharalnum(void const * const element, void * const null);
+
+bool ucharalpha(void const * const element, void * const null);
+
+bool ucharcntrl(void const * const element, void * const null);
+
+bool uchardigit(void const * const element, void * const null);
+
+bool ucharlower(void const * const element, void * const null);
+
+bool ucharupper(void const * const element, void * const null);
+
+bool ucharpunct(void const * const element, void * const null);
+
+bool ucharspace(void const * const element, void * const null);
+
+bool ucharxdigit(void const * const element, void * const null);
+
+bool ucharprime(void const * const element, void * const null);
+
+void intdst(void * const element);
+
+void * intcpy(void * const destination, void const * const source);
+
+void * intsum(void * const sum, void const * const addent);
+
+size_t inthshsame(void const * const element);
+
+size_t inthshmurmur(void const * const element);
+
+int intcmp(void const * const a, void const * const b);
+
+int intrcmp(void const * const a, void const * const b);
+
+bool intprint(void * const element, void * const format);
+
+bool intincrement(void * const element, void * const value);
+
+bool intdecrement(void * const element, void * const value);
+
+void intqsort(void * const array, size_t const lenght, void * const null);
+
+void intrqsort(void * const array, size_t const lenght, void * const null);
+
+bool inteven(void const * const element, void * const null);
+
+bool intodd(void const * const element, void * const null);
+
+bool intprime(void const * const element, void * const null);
+
+void uintdst(void * const element);
+
+void * uintcpy(void * const destination, void const * const source);
+
+void * uintsum(void * const sum, void const * const addent);
+
+size_t uinthshsame(void const * const element);
+
+int uintcmp(void const * const a, void const * const b);
+
+int uintrcmp(void const * const a, void const * const b);
+
+bool uintprint(void * const element, void * const format);
+
+void uintqsort(void * const array, size_t const lenght, void * const null);
+
+void uintrqsort(void * const array, size_t const lenght, void * const null);
+
+bool uinteven(void const * const element, void * const null);
+
+bool uintodd(void const * const element, void * const null);
+
+bool uintprime(void const * const element, void * const null);
+
+void floatdst(void * const element);
+
+void * floatcpy(void * const destination, void const * const source);
+
+void * floatsum(void * const sum, void const * const addent);
+
+size_t floathshsame(void const * const element);
+
+int floatcmp(void const * const a, void const * const b);
+
+int floatrcmp(void const * const a, void const * const b);
+
+bool floatprint(void * const element, void * const format);
+
+void floatqsort(void * const array, size_t const lenght, void * const null);
+
+void floatrqsort(void * const array, size_t const lenght, void * const null);
+
+void doubledst(void * const element);
+
+void * doublecpy(void * const destination, void const * const source);
+
+void * doublesum(void * const sum, void const * const addent);
+
+size_t doublehshsame(void const * const element);
+
+int doublecmp(void const * const a, void const * const b);
+
+int doublercmp(void const * const a, void const * const b);
+
+bool doubleprint(void * const element, void * const format);
+
+void doubleqsort(void * const array, size_t const lenght, void * const null);
+
+void doublerqsort(void * const array, size_t const lenght, void * const null);
+
+void sizedst(void * const element);
+
+void * sizecpy(void * const destination, void const * const source);
+
+void * sizesum(void * const sum, void const * const addent);
+
+size_t sizehshsame(void const * const element);
+
+int sizecmp(void const * const a, void const * const b);
+
+int sizercmp(void const * const a, void const * const b);
+
+bool sizeprint(void * const element, void * const format);
+
+void sizeqsort(void * const array, size_t const lenght, void * const null);
+
+void sizerqsort(void * const array, size_t const lenght, void * const null);
+
+bool sizeeven(void const * const element, void * const null);
+
+bool sizeodd(void const * const element, void * const null);
+
+bool sizeprime(void const * const element, void * const null);
+
+size_t stringhshmurmur(void const * const element);
+
+int stringcmp(void const * const a, void const * const b);
+
+int stringrcmp(void const * const a, void const * const b);
+
+bool stringprint(void * const element, void * const format);
+
+void stringqsort(void * const array, size_t const lenght, void * const null);
+
+void stringrqsort(void * const array, size_t const lenght, void * const null);
+
+#endif // DODAC_H

include/graph/iam_graph.h

@@ -7,6 +7,8 @@
 #   define IAM_GRAPH_CHUNK CERPEC_CHUNK
 #elif IAM_GRAPH_CHUNK <= 0
 #   error "Chunk size must be greater than zero."
+#elif (IAM_GRAPH_CHUNK & (IAM_GRAPH_CHUNK - 1))
+#   error "Chunk size must be a power of 2."
 #endif
 
 #define IAM_NIL ((size_t)(-1))
@@ -39,7 +41,7 @@ typedef struct infinite_matrix_graph_table {
     iam_cost_s const * data;
     size_t * previous;
     char * costs;
-} iam_list_s;
+} iam_table_s;
 
 /// @brief Composes a structure via its parametric properties.
 /// @param size Size of cost.
@@ -99,12 +101,18 @@ bool is_empty_iam_graph(iam_graph_s const * const graph);
 /// @return 'true' if graph is complete, 'false' otherwise.
 bool is_complete_iam_graph(iam_graph_s const * const graph);
 
-/// @brief A graph is connected if a path exists between every pair of vertices
+/// @brief A graph is connected if a path exists between every pair of vertices.
 /// @param graph Structure to check.
 /// @return 'true' if graph is connected, 'false' otherwise.
 /// @note The algorithm uses DFS to determine connectivity.
 bool is_connected_iam_graph(iam_graph_s const * const graph);
 
+/// @brief A graph is a tree if it's connected and contains no cycles.
+/// @param graph Structure to check.
+/// @return 'true' if graph is a tree, 'false' otherwise.
+/// @note The algorithm uses DFS to determine tree-ness.
+bool is_tree_iam_graph(iam_graph_s const * const graph);
+
 /// @brief Inserts a single vertex element into the structure.
 /// @param graph Structure to insert into.
 /// @param vertex Element buffer to insert.
@@ -168,23 +176,23 @@ size_t degree_iam_graph(iam_graph_s const * const graph, size_t const index);
 /// @param start Starting vertex index.
 /// @param end Last vertex index, or 'IAM_NIL' if all vertex shortest path.
 /// @return Breadth first search lookup table with subgraph from start node to all other nodes.
-iam_list_s bfs_iam_graph(iam_graph_s const * const graph, iam_cost_s const * const cost, size_t const start, size_t const end);
+iam_table_s bfs_iam_graph(iam_graph_s const * const graph, iam_cost_s const * const cost, size_t const start, size_t const end);
 
 /// @brief Traverses the vertices of the specified structure using depth first search.
 /// @param graph Structure to traverse.
 /// @param cost Cost structure that defines the distance properties in table.
 /// @param start Starting vertex index.
 /// @param end Last vertex index, or 'IAM_NIL' if all vertex paths.
 /// @return Depth first search lookup table with subgraph from start node to all other nodes.
-iam_list_s dfs_iam_graph(iam_graph_s const * const graph, iam_cost_s const * const cost, size_t const start, size_t const end);
+iam_table_s dfs_iam_graph(iam_graph_s const * const graph, iam_cost_s const * const cost, size_t const start, size_t const end);
 
 /// @brief Generate a Dijkstra lookup array table with nodes' edge sums and previous indexes.
 /// @param graph Structure to generate from.
 /// @param start Starting vertex index.
 /// @param end Last vertex index, or 'IAM_NIL' if all vertex shortest path.
 /// @param cost Cost structure that defines the distance properties in table.
 /// @return Dijkstra lookup table with subgraph of shortest paths from start node to all other nodes.
-iam_list_s dijkstra_iam_graph(iam_graph_s const * const graph, iam_cost_s const * const cost, size_t const start, size_t const end);
+iam_table_s dijkstra_iam_graph(iam_graph_s const * const graph, iam_cost_s const * const cost, size_t const start, size_t const end);
 
 /// @brief Generate an A* lookup array table with nodes' edges and previous indexes.
 /// @param graph Structure to generate from.
@@ -193,14 +201,14 @@ iam_list_s dijkstra_iam_graph(iam_graph_s const * const graph, iam_cost_s const
 /// @param cost Cost structure that defines the distance properties in table.
 /// @param heuristic Function pointer to calculate heuristic cost based on two vectices.
 /// @return A* lookup table with subgraph of shortest paths from start to end node.
-iam_list_s a_star_iam_graph(iam_graph_s const * const graph, iam_cost_s const * const cost, size_t const start, size_t const end, operate_fn const heuristic);
+iam_table_s a_star_iam_graph(iam_graph_s const * const graph, iam_cost_s const * const cost, size_t const start, size_t const end, operate_fn const heuristic);
 
 /// @brief Generate a Prim lookup array table with nodes' edges and previous indexes.
 /// @param graph Structure to generate from.
 /// @param start Starting vertex index.
 /// @param cost Cost structure that defines the distance properties in table.
 /// @return Prim lookup table with subgraph of minimum spanning tree from start node to all other nodes.
-iam_list_s prim_iam_list(iam_graph_s const * const graph, iam_cost_s const * const cost, size_t const start);
+iam_table_s prim_iam_list(iam_graph_s const * const graph, iam_cost_s const * const cost, size_t const start);
 
 /// @brief Generate a Kruskal lookup array table with nodes' ranks and previous indexes.
 /// @param graph Structure to generate from.
@@ -209,11 +217,11 @@ iam_list_s prim_iam_list(iam_graph_s const * const graph, iam_cost_s const * con
 /// @param arguments Arguments for sorting function.
 /// @param increment Function pointer to increment rank cost by one.
 /// @return Kruskal lookup table with subgraph of minimum spanning tree from start node to all other nodes.
-iam_list_s kruskal_iam_list(iam_graph_s const * const graph, iam_cost_s const * const cost, process_fn const sort, void * const arguments, set_fn const increment);
+iam_table_s kruskal_iam_list(iam_graph_s const * const graph, iam_cost_s const * const cost, process_fn const sort, void * const arguments, set_fn const increment);
 
 /// @brief Destroys a structure, and its elements and makes it unusable.
 /// @param table Structure to destroy.
-void destroy_iam_list(iam_list_s * const table);
+void destroy_iam_list(iam_table_s * const table);
 
 /// @brief Creates a subgraph copy of specified graph based on its table.
 /// @param table Structure to reference.
@@ -222,7 +230,7 @@ void destroy_iam_list(iam_list_s * const table);
 /// @return Matrix graph structure.
 /// @note The algorithm should be used for minimum spanning tree implementations like Prim and Kruskal,
 /// but one can also generate trees from path finding implementations.
-iam_graph_s subgraph_iam_list(iam_list_s const * const table, copy_fn const copy_vertex, copy_fn const copy_edge);
+iam_graph_s subgraph_iam_list(iam_table_s const * const table, copy_fn const copy_vertex, copy_fn const copy_edge);
 
 /// @brief Iterates over each vertex element in structure starting from the beginning.
 /// @param graph Structure to iterate.
@@ -247,7 +255,7 @@ void each_edge_iam_graph(iam_graph_s const * const graph, handle_fn const handle
 /// @param table Structure to iterate.
 /// @param handle Operate function pointer to operate on each vertex.
 /// @param arguments Arguments for operate function pointer.
-void each_cost_iam_list(iam_list_s const * const table, handle_fn const handle, void * const arguments);
+void each_cost_iam_list(iam_table_s const * const table, handle_fn const handle, void * const arguments);
 
 /// @brief Traverses the costs paths of the specified structure using a generated table.
 /// @param table Structure to traverse.
@@ -257,6 +265,6 @@ void each_cost_iam_list(iam_list_s const * const table, handle_fn const handle,
 /// @return 'true' if path exists, 'false' otherwise.
 /// @note The algorithm shoul be used with shortest path find implementations, i.e. Dijkstra and A*,
 /// to traverse the path from 'end' vertex to the start one, but one can also traverse MSP tables with it.
-bool each_path_iam_list(iam_list_s const * const table, size_t const end, handle_fn const handle, void * const arguments);
+bool each_path_iam_list(iam_table_s const * const table, size_t const end, handle_fn const handle, void * const arguments);
 
 #endif // IAM_GRAPH_H

include/list/icircular_list.h

@@ -7,6 +7,8 @@
 #   define ICIRCULAR_LIST_CHUNK CERPEC_CHUNK
 #elif ICIRCULAR_LIST_CHUNK <= 0
 #   error "Chunk size must be greater than zero."
+#elif (ICIRCULAR_LIST_CHUNK & (ICIRCULAR_LIST_CHUNK - 1))
+#   error "Chunk size must be a power of 2."
 #endif
 
 /// @brief Infinite circular list data structure.

include/list/idouble_list.h

@@ -7,6 +7,8 @@
 #   define IDOUBLE_LIST_CHUNK CERPEC_CHUNK
 #elif IDOUBLE_LIST_CHUNK <= 0
 #   error "Chunk size must be greater than zero."
+#elif (IDOUBLE_LIST_CHUNK & (IDOUBLE_LIST_CHUNK - 1))
+#   error "Chunk size must be a power of 2."
 #endif
 
 #define IDL_NODE 2