{"id":18595707,"url":"https://github.com/zncl2222/c_array_tools","last_synced_at":"2026-03-01T15:31:19.894Z","repository":{"id":65519860,"uuid":"582631924","full_name":"Zncl2222/c_array_tools","owner":"Zncl2222","description":"This is a simple dynamic array tool implemented in C with a single header file","archived":false,"fork":false,"pushed_at":"2024-07-03T16:16:11.000Z","size":244,"stargazers_count":2,"open_issues_count":2,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-02-23T11:45:19.296Z","etag":null,"topics":["arrays","c","dynamic-array","single-header-lib"],"latest_commit_sha":null,"homepage":"","language":"C","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Zncl2222.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2022-12-27T12:23:22.000Z","updated_at":"2024-07-03T16:16:12.000Z","dependencies_parsed_at":"2024-06-13T13:55:01.273Z","dependency_job_id":"f0fbcb20-4f37-428e-83f7-1f1118804840","html_url":"https://github.com/Zncl2222/c_array_tools","commit_stats":null,"previous_names":[],"tags_count":13,"template":false,"template_full_name":null,"purl":"pkg:github/Zncl2222/c_array_tools","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Zncl2222%2Fc_array_tools","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Zncl2222%2Fc_array_tools/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Zncl2222%2Fc_array_tools/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Zncl2222%2Fc_array_tools/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Zncl2222","download_url":"https://codeload.github.com/Zncl2222/c_array_tools/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Zncl2222%2Fc_array_tools/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":29973313,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-03-01T15:29:09.406Z","status":"ssl_error","status_checked_at":"2026-03-01T15:28:28.558Z","response_time":124,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["arrays","c","dynamic-array","single-header-lib"],"created_at":"2024-11-07T01:20:47.354Z","updated_at":"2026-03-01T15:31:19.875Z","avatar_url":"https://github.com/Zncl2222.png","language":"C","readme":"![licence](https://img.shields.io/github/license/Zncl2222/c_array_tools)\n![size](https://img.shields.io/github/repo-size/Zncl2222/c_array_tools)\n![language](https://img.shields.io/badge/-Solutions-blue.svg?style=flat\u0026logo=c%2B%2B)\n![language_percent](https://img.shields.io/github/languages/top/Zncl2222/c_array_tools)\n![cmake](https://img.shields.io/github/actions/workflow/status/Zncl2222/c_array_tools/cmake.yml?logo=cmake\u0026logoColor=red\u0026label=CMake)\n[![build](https://github.com/Zncl2222/c_array_tools/actions/workflows/codeql.yml/badge.svg)](https://github.com/Zncl2222/c_array_tools/actions/workflows/codeql.yml)\n\n[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Zncl2222_c_array_tools\u0026metric=alert_status)](https://sonarcloud.io/summary/new_code?id=Zncl2222_c_array_tools)\n[![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=Zncl2222_c_array_tools\u0026metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=Zncl2222_c_array_tools)\n[![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=Zncl2222_c_array_tools\u0026metric=security_rating)](https://sonarcloud.io/summary/new_code?id=Zncl2222_c_array_tools)\n[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=Zncl2222_c_array_tools\u0026metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=Zncl2222_c_array_tools)\n\n\n# c_array_tools\nThis is a simple dynamic array tool, similar to C++'s **```std::vector```**, implemented in C. It is coded using macros to simulate **```template-like```** functions found in languages like C++. This allows users to work with arrays in C more easily, without the need to repeatedly declare the data type.\n\n# Installation\nIt's a single-header library. For most basic dynamic array functionality, you only need to include `src/c_array.h` in your project. If you want to use extended features such as statistical calculations and the `mt19937 random number generator`, you should also link either `src/c_array.c` or `src/c_array_mt.c` when compiling your code. (All the functions are declared in `src/c_array.h`, so you can call any of them by including the header file `src/c_array.h` in your source code.)\n\nFor example, if you have a program like main.c:\n\n\n### main.c\n\n```C\n# include \"c_array.h\"\n\nint main() {\n    c_array_int array;\n    mt19937_state state;\n    mt19937_init(\u0026state, 1314);\n\n    // This funciton is implemented in c_array_mt.c\n    c_array_rand_range(\u0026array, 10, mt19937_get_int32_range(\u0026state, -5, 20));\n\n     // This funciton is implemented in c_array.c\n    int sum = c_array_sum(\u0026array);\n\n    c_array_free(\u0026array);\n}\n```\n\ncompile with gcc (remember to add -lm to link math.h in linux os)\n```bash\ngcc main.c c_array_mt.c c_array.c -lm -o main.out\n```\n\nBecause of the `typeof` and `_Generic` features in the code, the project has been tested exclusively with the GCC compiler on both Windows (MinGW) and Ubuntu operating systems. (A minimum version of GCC 4.9 is required, as `_Generic` support was introduced starting from version 4.9.)\n\n\n\u003cdiv align='center'\u003e\n\n| Compiler                      | Windows            | Ubuntu             | Mac                 |\n| ----------------------------- | :----------------: | :----------------: | ------------------  |\n| GNU Compiler Collection (gcc) | -                  | :white_check_mark: | Not  yet tested     |\n| x86_64 mingw series (gcc)     | :white_check_mark: | -                  | Not  yet tested     |\n| Visual Studio Build Tools     | :x:                | :x:                | Not  yet tested     |\n\n\u003c/div\u003e\n\n### Extension in c_array.c\n- [c_array_sum](#c_array_sumarr)\n- [c_array_mean](#c_array_meanarr)\n- [c_array_std](#c_array_stdarr--c_array_vararr)\n- [c_array_var](#c_array_stdarr--c_array_vararr)\n- [c_array_max](#c_array_maxarr--c_array_minarr)\n- [c_array_min](#c_array_maxarr--c_array_minarr)\n- [c_array_argmax](#c_array_argmaxarr)\n- [c_array_argmin](#c_array_argminarr)\n- [c_array_qsort](#c_array_qsortarr--c_array_msortarr)\n- [c_matrix_flatten](#c_matrix_flattenmat)\n- [c_matrix_reshape](#c_matrix_reshapemat-row-col)\n- [c_matrix_sum](#c_matrix_summat)\n- [c_matrix_mean](#c_matrix_meanmat)\n- [c_matrix_max](#c_matrix_maxmat)\n- [c_matrix_min](#c_matrix_minmat)\n- [c_matrix_var](#c_matrix_varmat)\n- [c_matrix_std](#c_matrix_stdmat)\n- [c_array_search](#c_array_searcharr-target)\n\n### Extension in c_array_mt.c\n- [mt19937_init](#void-mt19937_initmt19937_state-state-unsigned-int-seed)\n- [mt19937_generate](#unsigned-long-mt19937_generatemt19937_state-state)\n- [mt19937_get_int32_range](#int-mt19937_get_int32_rangemt19937_state-state-int-m-int-n)\n- [mt19937_get_float](#float-mt19937_get_floatmt19937_state-state)\n- [mt19937_get_float_range](#float-mt19937_get_float_rangemt19937_state-state-float-m-float-n)\n- [mt19937_get_double](#double-mt19937_get_doublemt19937_state-state)\n- [mt19937_get_double_range](#double-mt19937_get_double_rangemt19937_state-state-double-m-double-n)\n- [random_normal](#double-random_normalmt19937_state-state)\n- [c_array_randnormal](#c_array_randnormalarr-c-rng_state)\n- [c_array_rand_range](#c_array_rand_rangearr-c-rng_function)\n\n# Usuage\nHere is an example in `example.c` that demonstrates how to use this library. You can simply use the shell script `example.sh (for Linux)` or the batch file `example.bat` to compile and run the program. The example program prints out results to help users understand how it works.\n\n### Example\n```C\n# include \u003cstdio.h\u003e\n# include \"./src/c_array.h\"\n\nint main() {\n    printf(\"\\nc_array Example\\n\\n\");\n\n    // Initialize the array. If capacity \u003e 0, then it will initialize with 0 val.\n    c_array_int array;\n    c_array_init(\u0026array, 0);\n\n    // add element to the back (the idx of back is the current size of array)\n    c_array_push_back(\u0026array, 10);\n    c_array_push_back(\u0026array, 2222);\n    c_array_push_back(\u0026array, -1024);\n\n    // print the array in this style -\u003e arr = [1, 2, 3]\n    printf(\"After push back\\n\");\n    c_array_printf(array, \"%d\");\n    printf(\"Array size = %zu\\n\", array.size);\n    printf(\"Array capacity = %zu\\n\\n\", array.capacity);\n\n    // assign value directly or via function.\n    // assign by function can help to check if the memory is allocated.\n    c_array_assign(\u0026array, 0, 999);\n    printf(\"Use c_array_assign: \\n\");\n    c_array_print(array, \"%d\");\n    printf(\"Assign directly: \\n\");\n    array.data[0] = 111;\n    c_array_printf(array, \"%d\");\n\n    // pop the last element in array.\n    // That element will be reseted to 0, and - 1 to the array size.\n    c_array_pop_back(\u0026array);\n    printf(\"\\nAfter pop_back\\n\");\n    c_array_printf(array, \"%d\");\n    printf(\"Array size = %zu\\n\", array.size);\n    printf(\"Array capacity = %zu\\n\\n\", array.capacity);\n\n    // insert the element at certain idx of the array\n    // c_array_insert(array, index, value)\n    c_array_insert(\u0026array, 1, 90);\n    printf(\"\\nAfter insert\\n\");\n    c_array_printf(array, \"%d\");\n    printf(\"Array size = %zu\\n\", array.size);\n    printf(\"Array capacity = %zu\\n\\n\", array.capacity);\n\n    // remove the element at certain idx of the array\n    // c_array_remove(array, index)\n    c_array_remove(\u0026array, 1);\n    printf(\"\\nAfter remove\\n\");\n    c_array_printf(array, \"%d\");\n    printf(\"Array size = %zu\\n\", array.size);\n    printf(\"Array capacity = %zu\\n\\n\", array.capacity);\n\n    // adjust the array capacity\n    // should be careful the value was not initialize\n    c_array_resize(\u0026array, 20);\n    printf(\"\\nAfter resize\\n\");\n    c_array_printf(array, \"%d\");\n    printf(\"Array size = %zu\\n\", array.size);\n    printf(\"Array capacity = %zu\\n\\n\", array.capacity);\n\n    // adjust the array size\n    c_array_set_size(\u0026array, 20);\n    printf(\"\\nAfter set size\\n\");\n    c_array_printf(array, \"%d\");\n    printf(\"Array size = %zu\\n\", array.size);\n    printf(\"Array capacity = %zu\\n\\n\", array.capacity);\n\n    // Remember to free the memory after you don't need it.\n    c_array_free(\u0026array);\n\n    return 0;\n}\n```\n\n----\n### `c_array(T)` \u0026 `c_array_init(arr, c)`\n- params:\u003cbr\u003e\n`T`: the data type of the array -\u003e (**int, long long, float, double etc..**)\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`c`: the capacity for init -\u003e (**size_t**)\u003cbr\u003e\n\nCreate the array with given datatype by `c_array(datatype) arr;`. You should initialize it before use. `arr.size` is the logical size of the array and `arr.capacity` is the whole space for the container. However it is better to use `c_array_int`, `c_array_float`, `c_array_doulbe` which was defined by `typdef`. You can also define your own type like `typedef c_array_long c_array(long);`.\n\nInitialize the array with the given size \u0026 capacity by `c_array_init(\u0026arr, size)`.\n```C\nint main() {\n    c_array(int) arr;  // You can use this method to declare array, but it can't be used in other function which need to declare the dtype.\n    c_array_int array; // This is the dtype of c_array(int). You can use this in any function which need to declare dtype like void foo(c_array_int array, int num);\n    c_array_init(\u0026arr, 10); // arr[0] ~ arr[9] will be initialized with 0\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_empty_init(arr, c)`\n- params:\u003cbr\u003e\n`T`: the data type of the array -\u003e (**int, long long, float, double etc..**)\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`c`: the capacity for init -\u003e (**size_t**)\u003cbr\u003e\n\nAllocate memory of the array with the given size \u0026 capacity (No initialize value).\n```C\nint main() {\n    c_array(int) arr;  // You can use this method to declare array, but it can't be used in other function which need to declare the dtype.\n    c_array_int array; // This is the dtype of c_array(int). You can use this in any function which need to declare dtype like void foo(c_array_int array, int num);\n    c_array_init(\u0026arr, 10); // arr[0] ~ arr[9] will be initialized with 0\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_copy(arr_old, arr_new)`\n- params:\u003cbr\u003e\n`arr_old`: c_array structure you want to copy -\u003e (**c_array**)\u003cbr\u003e\n`arr_new`: new c_array structure -\u003e (**c_array**)\u003cbr\u003e\n\nCopy an array to the target arry.\n```C\nint main() {\n    c_array_int arr;\n    c_array_init(\u0026arr, 0); // arr[0] ~ arr[9] will be initialized with 0\n    c_array_push_back(\u0026arr, 7);\n    c_array_push_back(\u0026arr, 8);\n    c_array_push_back(\u0026arr, 9);\n\n    c_array_int arr_new;  // declare arr_new without initialize.\n    c_array_copy(\u0026arr, \u0026arr_new); // copy the memory from arr to arr_new\n    c_array_print(arr_new, \"%d\"); // arr_new = [7, 8, 9], size and capacity are also equals to arr\n    c_array_free(\u0026arr); // free memory\n\n    return 0;\n}\n```\n\n----\n### `c_array_capacity(arr)` \u0026 `c_array_size(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n\nGet array capacity and size.\n```C\nint main() {\n    c_array_int arr;\n    c_array_init(\u0026arr, 10);\n    // Get size and capacity by macro\n    int size = c_array_size(\u0026arr); // equals to 10\n    int capacity = c_array_capacity(\u0026arr); // equals to 10\n\n    // Get these attributes by struct\n    size = arr.size;\n    capacity = arr.capacity;\n    c_array_free(\u0026arr);\n    return 0;\n}\n```\n\n----\n### `c_array_assign(arr, idx, val)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`idx`: index of the array -\u003e (**int**)\u003cbr\u003e\n`val`: value -\u003e (**int, long long, float, double etc..**)\u003cbr\u003e\n\nAssign the value at given location. This funciton will help to check if the memory is allocated before assigning the value. If memory is not allocated, then the program will abort with error.\n```C\nint main() {\n    c_array_int arr;\n    c_array_init(\u0026arr, 10);\n    c_array_assign(\u0026arr, 0, 150); // arr.data[0] now is 150\n    c_array_assign(\u0026arr, 11, 150); // program abort due to the size of array is only 10.\n\n    // Assign value in struct directly\n    arr.data[0] = -150; // warning: this method didn't check if the memory is allocated.\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_grow`\nThis macro is for array to grow the capacity while the memory is not enough. \u003cb\u003e\u003cfont color=#ec733f\u003eUser don't have to call it manually\u003c/font\u003e\u003c/b\u003e. If you want to adjust the size or the capacity, please refer to the `c_array_resize` and `c_array_set_size`. Features in c_array_tools will grow the capacity while the memory space is not enough. By default, each growing will **double** the **current capacity**.\n\n----\n### `c_array_resize(arr, c)` \u0026 `c_array_set_size(arr, size)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`c`: capacity -\u003e (**size_t**)\u003cbr\u003e\n`size`: size -\u003e (**size_t**)\u003cbr\u003e\n\nResize the capacity to given value.\n```c\nint main() {\n    c_array_int arr;\n    c_array_init(\u0026arr, 0); // capacity and size are both 0 now\n    c_array_resize(\u0026arr, 10); // capacity become 10 and size remain 0.\n    c_array_set_size(\u0026arr, 8); // capacity is 10 and size is 8 (element will initialize with 0)\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_push_back(arr, val)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`val`: value -\u003e (**int, long long, float, double etc..**)\u003cbr\u003e\n\nPush the element at the end of the array (depend on arr.size). If the capacity is not enough, this funciton will call `c_array_grow` to enlarge the capacity automatically. Notice if you need to push_back frequently, please use `c_array_resize` to set enough capacity to avoid the realloc of memory.\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1); // capacity and size is 1 now\n    c_array_push_back(\u0026arr, 2); // capacity and size is 2 now\n    c_array_push_back(\u0026arr, 3); // capacity is 4 and size is 3 now\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_pop_back(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n\nRemove the last element of the array (depend on arr.size).\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3); // arr = [1, 2, 3]\n    c_array_pop_back(\u0026arr);     // arr = [1, 2]\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_move_left` \u0026 `c_array_move_right`\nThese are the feature for c_array_insert and c_array_remove.\n\n----\n### `c_array_insert(arr, idx, val)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`idx`: index of the array -\u003e (**int**)\u003cbr\u003e\n`val`: value -\u003e (**int, long long, float, double etc..**)\u003cbr\u003e\n\nInsert the element at given index.\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3);  // arr = [1, 2, 3]\n    c_array_insert(\u0026arr, 1, 99); // arr = [1, 99, 2, 3]\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_remove(arr, idx)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`idx`: index of the array -\u003e (**int**)\u003cbr\u003e\n\nRemove the elemnt at given index.\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3); // arr = [1, 2, 3]\n    c_array_remove(\u0026arr, 1);    // arr = [1, 3]\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_print(arr)` \u0026 `c_array_printf(arr, format)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`format`: format specifier -\u003e (**char\\***)\u003cbr\u003e\n\nPrint the array with clean style.\n```C\nint main() {\n    c_array_int arr_print_test;\n    c_array(\u0026arr_print_test, 0);\n    c_array_push_back(\u0026arr_print_test, 1);\n    c_array_push_back(\u0026arr_print_test, 2);\n    c_array_push_back(\u0026arr_print_test, 3);\n    c_array_printf(arr_print_test, \"%d\");   // Custom format to print the array\n    // Results shows: arr_print_test = [1, 2, 3]\n\n    c_array_print(arr_print_test); // Default format like %d %lld %f %lf. You can add more format in c_array_autoformat macro\n    // Results shows: arr_print_test = [1, 2, 3]\n\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_empty(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n- return: 0 or 1 -\u003e (**int**)\u003cbr\u003e\n\nCheck if array is empty, if yes return 1 else 0\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    int e = c_array_empty(\u0026arr); // e = 1\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_swap(arr, idx1, idx2)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`idx1`: index 1 -\u003e (**int**)\u003cbr\u003e\n`idx2`: index 2 -\u003e (**int**)\u003cbr\u003e\n\nSwap the data in array\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3); // arr = [1, 2, 3]\n    c_array_swap(\u0026arr, 0, 1);   // arr = [2, 1, 3]\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_reverse(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n\nReverse the array\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3); // arr = [1, 2, 3]\n    c_array_reverse(\u0026arr);      // arr = [3, 2, 1]\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_concat(arr1, arr2)`\n- params:\u003cbr\u003e\n`arr1`: c_array structure (result will concat at this array) -\u003e (**c_array**)\u003cbr\u003e\n`arr2`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n\nConcat two arrays.\n```C\nint main() {\n    c_array_int arr;\n    c_array_int arr2;\n    c_array(\u0026arr, 0);\n    c_array(\u0026arr2, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr2, 9);\n    c_array_push_back(\u0026arr2, -45);\n\n    c_array_concat(\u0026arr1, \u0026arr2); // arr1 = [1, 2, 9, -45], arr2 = [9, -45]\n\n    c_array_free(\u0026arr); // free memory\n    c_array_free(\u0026arr2); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_free(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n\nFree the memory allocated from heap.\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_free(\u0026arr);\n    return 0;\n}\n```\n\n----\n### `c_array_qsort(arr)` \u0026 `c_array_msort(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n\nSort the array by the qsort function in \u003cstdlib.h\u003e, or sort the array by the 'merge sort'.\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 99);\n    c_array_push_back(\u0026arr, -2);\n    c_array_push_back(\u0026arr, 2); // arr = [99, -2, 2]\n    c_array_qsort(\u0026arr); // arr = [-2, 2, 99]\n\n    c_array_push_back(\u0026arr, -91);\n    c_array_push_back(\u0026arr, 1); // arr = [-2, 2, 99, -91, 1]\n    c_array_msort(\u0026arr); // arr = [-91, -2, 1, 2, 99]\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_sum(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n- return: `sum` -\u003e (**int, long long, float, double etc..**)\u003cbr\u003e\n\nGet the sum of an array.\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3);\n    int sum = c_array_sum(\u0026arr); // sum = 6\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_max(arr)` \u0026 `c_array_min(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n- return: `min or max` -\u003e (**int, long long, float, double etc..**)\u003cbr\u003e\n\nGet min or max value of an array\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3);\n    int max = c_array_max(\u0026arr); // max = 3\n    int min = c_array_min(\u0026arr); // min = 1\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_maxmin(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n- return: `pointer contain min and max (arr[0] = min, arr[1] = max)` -\u003e (**int*, long long*, float*, double* etc..**)\u003cbr\u003e\n\nGet min or max value of an array\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3);\n    int* max_min = c_array_maxmin(\u0026arr); // max_min[0] = 1, max_min[1] = 3\n    c_array_free(\u0026arr); // free memory\n    free(max_min);\n    return 0;\n}\n```\n\n----\n### `c_array_argmax(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n- return: `pointer contain the index of max value in array` -\u003e (**int*, long long*, float*, double* etc..**)\u003cbr\u003e\n\nGet index of max value of an array\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3);\n    c_array_push_back(\u0026arr, 3);\n    int* max_indices = c_array_argmax(\u0026arr); // max_indices[0] = 2, max_indices[1] = 3\n    c_array_free(\u0026arr); // free memory\n    free(max_min); // You should free the max_indices manually.\n    return 0;\n}\n```\n\n----\n### `c_array_argmin(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n- return: `pointer contain the index of min value in array` -\u003e (**int*, long long*, float*, double* etc..**)\u003cbr\u003e\n\nGet the index of min value of an array\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3);\n    c_array_push_back(\u0026arr, 3);\n    int* min_indices = c_array_argmin(\u0026arr); // min_indices[0] = 2, min_indices[1] = 3\n    c_array_free(\u0026arr); // free memory\n    free(min_min); // You should free the min_indices manually.\n    return 0;\n}\n```\n\n----\n### `c_array_mean(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n- return: `mean value` -\u003e (**mean_t**)\u003cbr\u003e\n\nGet mean value of an array\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3);\n    mean_t mean = c_arry_mean(\u0026arr); // mean = 2\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_std(arr)` \u0026 `c_array_var(arr)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n- return: `standard deviation or variance` -\u003e (**std_t, var_t**)\u003cbr\u003e\n\nGet the standard deviation or the variance of an array\n```C\nint main() {\n    c_array_int arr;\n    c_array(\u0026arr, 0);\n    c_array_push_back(\u0026arr, 1);\n    c_array_push_back(\u0026arr, 2);\n    c_array_push_back(\u0026arr, 3);\n    std_t std = c_array_std(\u0026arr); // std = 0.8164\n    var_t var = c_array_var(\u0026arr); // var =  0.6667\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `void mt19937_init(mt19937_state* state, unsigned int seed)`\n- params:\u003cbr\u003e\n`state`: state of random seed generator -\u003e (**mt19937_state***)\u003cbr\u003e\n`seed`: random seed number -\u003e (**unsigned int**)\u003cbr\u003e\n- return: `void` -\u003e (**void**)\u003cbr\u003e\n\nCreate the random seed generator with the given random seed.\n```C\nint main() {\n    mt19937_state state;\n    mt19937_init(\u0026state, 12345);\n    return 0;\n}\n```\n\n----\n### `unsigned long mt19937_generate(mt19937_state* state)`\n- params:\u003cbr\u003e\n`state`: state of random seed generator -\u003e (**mt19937_state***)\u003cbr\u003e\n- return: `random value` -\u003e (**unsigned long**)\u003cbr\u003e\n\nGet the long or integer type random value between 0 ~ 4294967296.\n```C\nint main() {\n    mt19937_state state;\n    mt19937_init(\u0026state, 12345);\n    long num = mt19937_generate(\u0026state);\n    return 0;\n}\n```\n\n----\n### `float mt19937_get_float(mt19937_state* state)`\n- params:\u003cbr\u003e\n`state`: state of random seed generator -\u003e (**mt19937_state***)\u003cbr\u003e\n- return: `random value` -\u003e (**float**)\u003cbr\u003e\n\nGet the float type random value between 0 ~ 1.\n```C\nint main() {\n    mt19937_state state;\n    mt19937_init(\u0026state, 12345);\n    float num = mt19937_get_float(\u0026state);\n    return 0;\n}\n```\n\n----\n### `double mt19937_get_double(mt19937_state* state)`\n- params:\u003cbr\u003e\n`state`: state of random seed generator -\u003e (**mt19937_state***)\u003cbr\u003e\n- return: `random value` -\u003e (**double**)\u003cbr\u003e\n\nGet the double type random value between 0 ~ 1.\n```C\nint main() {\n    mt19937_state state;\n    mt19937_init(\u0026state, 12345);\n    double num = mt19937_get_double(\u0026state);\n    return 0;\n}\n```\n\n----\n### `int mt19937_get_int32_range(mt19937_state* state, int m, int n)`\n- params:\u003cbr\u003e\n`state`: state of random seed generator -\u003e (**mt19937_state***)\u003cbr\u003e\n`m`: min value -\u003e (**int**)\u003cbr\u003e\n`n`: max value -\u003e (**int**)\u003cbr\u003e\n- return: `random value` -\u003e (**int**)\u003cbr\u003e\n\nGet the random value between given min and max.\n```C\nint main() {\n    mt19937_state state;\n    mt19937_init(\u0026state, 12345);\n    int num = mt19937_get_int32_range(\u0026state, -10, 20); // -10 \u003c= num \u003c= 20\n    return 0;\n}\n```\n\n----\n### `float mt19937_get_float_range(mt19937_state* state, float m, float n)`\n- params:\u003cbr\u003e\n`state`: state of random seed generator -\u003e (**mt19937_state***)\u003cbr\u003e\n`m`: min value -\u003e (**float**)\u003cbr\u003e\n`n`: max value -\u003e (**float**)\u003cbr\u003e\n- return: `random value` -\u003e (**float**)\u003cbr\u003e\n\nGet the random value between given min and max.\n```C\nint main() {\n    mt19937_state state;\n    mt19937_init(\u0026state, 12345);\n    float num = mt19937_get_float_range(\u0026state, -5.65, 20.11); // -5.65 \u003c= num \u003c 20.11\n    return 0;\n}\n```\n\n----\n### `double mt19937_get_double_range(mt19937_state* state, double m, double n)`\n- params:\u003cbr\u003e\n`state`: state of random seed generator -\u003e (**mt19937_state***)\u003cbr\u003e\n`m`: min value -\u003e (**double**)\u003cbr\u003e\n`n`: max value -\u003e (**double**)\u003cbr\u003e\n- return: `random value` -\u003e (**double**)\u003cbr\u003e\n\nGet the random value between given min and max.\n```C\nint main() {\n    mt19937_state state;\n    mt19937_init(\u0026state, 12345);\n    double num = mt19937_get_double_range(\u0026state, -5.65, 20.11); // -5.65 \u003c= num \u003c 20.11\n    return 0;\n}\n```\n\n----\n### `double random_normal(mt19937_state* state)`\n- params:\u003cbr\u003e\n`state`: state of random seed generator -\u003e (**mt19937_state***)\u003cbr\u003e\n- return: `random value` -\u003e (**double**)\u003cbr\u003e\n\nDraw the random value from standard normal distribution.\n```C\nint main() {\n    mt19937_state state;\n    mt19937_init(\u0026state, 12345);\n    double num = random_normal(\u0026state);\n    return 0;\n}\n```\n\n----\n### `c_array_randnormal(arr, c, rng_state)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`c`: capacity and size for init -\u003e (**int**)\u003cbr\u003e\n`rng_state`: state of random seed generator -\u003e (**mt19937_state***)\u003cbr\u003e\n\nInitialize the c_array with the random value from standard normal distribution.\n```C\nint main() {\n    mt19937_state state;\n    mt19937_init(\u0026state, 12345);\n    c_array_double array;\n    c_array_randnormal(\u0026array, 10, \u0026state);\n    c_array_free(\u0026array); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_rand_range(arr, c, rng_function)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`c`: capacity and size for init -\u003e (**int**)\u003cbr\u003e\n`rng_function`: rng_function -\u003e (**rng_function**)\u003cbr\u003e\n\nInitialize the c_array with the random value from given random function\n```C\nint main() {\n    mt19937_state state;\n    mt19937_init(\u0026state, 12345);\n    c_array_double array;\n    double num = random_normal(\u0026state);\n    c_array_rand_range(\u0026arr, c, mt19937_get_int32_range(\u0026state, -5, 20));\n    c_array_free(\u0026array); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_search(arr, target)`\n- params:\u003cbr\u003e\n`arr`: c_array structure -\u003e (**c_array**)\u003cbr\u003e\n`target`: target you want to search -\u003e (**int, long long, float, double etc..**)\u003cbr\u003e\n- return: `Index of the target` -\u003e (**int**)\u003cbr\u003e\n\nInitialize the c_array with the random value from given random function\n```C\nint main() {\n    c_array_int array;\n    c_array_init(\u0026array, 0);\n    for (int i = 0; i \u003c 5; i++) {\n        array.data[i] = i * 2;\n    }\n    int idx = c_array_search(\u0026array, 8); // idx = 4\n    c_array_free(\u0026array); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_init(mat, rows, cols)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n`rows`: number of rows -\u003e (**int**)\u003cbr\u003e\n`cols`: number of cols -\u003e (**int**)\u003cbr\u003e\n\nInitialize c_matrix with given rows and cols.\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_init(\u0026mat, 2, 2); // matrix will init with value = 0\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_copy(mat_old, mat_new)`\n- params:\u003cbr\u003e\n`mat_old`: c_matrix structure to be copied -\u003e (**c_matrix**)\u003cbr\u003e\n`mat_new`: The new clone of c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n\nCopy memory of mat_old to mat_new.\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_int mat_new;\n    c_matrix_init(\u0026mat, 4, 5);\n    c_matrix_copy(\u0026mat, \u0026mat_new); // mat_new row = 4, mat_new col = 5\n    c_matrix_free(\u0026mat); // free memory\n    c_matrix_free(\u0026mat_new);\n    return 0;\n}\n```\n\n----\n### `c_matrix_empty_init(mat, rows, cols)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n`rows`: number of rows -\u003e (**int**)\u003cbr\u003e\n`cols`: number of cols -\u003e (**int**)\u003cbr\u003e\n\nAllocate memory of the matrix with given rows and cols (No initialize value).\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_empty_init(\u0026mat, 2, 2);\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_randnormal(mat, r, c, rng_state)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n`r`: number of rows -\u003e (**int**)\u003cbr\u003e\n`c`: number of cols -\u003e (**int**)\u003cbr\u003e\n`rng_state`: state of random seed generator -\u003e (**mt19937_state***)\u003cbr\u003e\n\nInitialize c_matrix with random value draw from noraml distribution.\n```C\nint main() {\n    c_matrix_double mat;\n    mt19937_state rng;\n    unsigned int seed = 12345;\n    mt19937_init(\u0026rng, seed);\n    c_matrix_randnormal(\u0026mat, 10, 10, \u0026rng);\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_rand_range(mat, r, c, rng_function)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n`r`: number of rows -\u003e (**int**)\u003cbr\u003e\n`c`: number of cols -\u003e (**int**)\u003cbr\u003e\n`rng_state`: state of random seed generator -\u003e (**mt19937_state***)\u003cbr\u003e\n\nInitialize the c_matrix with the random value from given random function.\n```C\nint main() {\n    c_matrix_int mat;\n    mt19937_state rng;\n    unsigned int seed = 12345;\n    mt19937_init(\u0026rng, seed);\n    c_matrix_rand_range(\u0026mat, r, c, mt19937_get_int32_range(\u0026state, -5, 20));\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_assign(mat, rows, cols, val)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n`rows`: number of rows -\u003e (**int**)\u003cbr\u003e\n`cols`: number of cols -\u003e (**int**)\u003cbr\u003e\n`val`: value -\u003e (**int, long long, float, double etc..**)\u003cbr\u003e\n\nAssign given value at given row and col.\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_init(\u0026mat, 2, 2);\n    c_matrix_assign(\u0026mat, 2, 2, 10);\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_print(mat)` \u0026 `c_matrix_printf(mat, format)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n`format`: format specifier -\u003e (**char\\***)\u003cbr\u003e\n\nPrint matirx with clean style.\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_init(\u0026mat, 2, 2);\n    for (int i = 0; i \u003c mat.rows; i++) {\n        for (int j = 0; j \u003c mat.cols; j++) {\n            mat.data[i][j] = i + j;\n        }\n    }\n\n    c_matrix_print(mat);\n    c_matrix_printf(mat, \"%d\");\n\n    c_array_free(\u0026arr); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_free(mat)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n\nFree memory\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_init(\u0026mat, 2, 2);\n    for (int i = 0; i \u003c mat.rows; i++) {\n        for (int j = 0; j \u003c mat.cols; j++) {\n            mat.data[i][j] = i + j;\n        }\n    }\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n----\n### `c_array_matrix_form(arr, n_row)`\n- params:\u003cbr\u003e\n`arr`: c_matrix structure -\u003e (**c_array**)\u003cbr\u003e\n`n_row`: number of rows -\u003e (**int**)\u003cbr\u003e\n- return: `c_matrix` -\u003e (**c_matrix**)\u003cbr\u003e\n\nReshape array to matrix with given row numbers.\n```C\nint main() {\n    c_array_int arr;\n    c_matrix_init(\u0026mat, 20);\n    for (int i = 0; i \u003c arr.size; i++) {\n        arr.data[i] = i;\n    }\n    c_matrix_int mat = c_array_matrix_form(\u0026arr, 4); // mat.rows = 4, mat.cols = 5\n    c_array_free(\u0026arr);\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_flatten(mat)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n- return: `c_array` -\u003e (**c_array**)\u003cbr\u003e\n\nFlatten c_matrix and return c_array\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_init(\u0026mat, 2, 2);\n    for (int i = 0; i \u003c mat.rows; i++) {\n        for (int j = 0; j \u003c mat.cols; j++) {\n            mat.data[i][j] = i + j;\n        }\n    }\n    c_array_int arr = c_matrix_flatten(\u0026mat);\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_reshape(mat, row, col)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n`row`: row number -\u003e (**int**)\u003cbr\u003e\n`col`: col number -\u003e (**int**)\u003cbr\u003e\n- return: `c_matrix` -\u003e (**c_matrix**)\u003cbr\u003e\n\nReshape c_matrix.\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_init(\u0026mat, 2, 2);\n    for (int i = 0; i \u003c mat.rows; i++) {\n        for (int j = 0; j \u003c mat.cols; j++) {\n            mat.data[i][j] = i + j;\n        }\n    }\n    c_array_int arr = c_matrix_reshape(\u0026mat, 4, 1);\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_sum(mat)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n- return: `sum` -\u003e (**int, long long, float, double etc..**)\u003cbr\u003e\n\nCalculate the sum of the matrix.\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_init(\u0026mat, 2, 2);\n    for (int i = 0; i \u003c mat.rows; i++) {\n        for (int j = 0; j \u003c mat.cols; j++) {\n            mat.data[i][j] = 5;\n        }\n    }\n    int sum_i = c_matrix_sum(\u0026mat); // sum i = 20\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_mean(mat)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n- return: `mean` -\u003e (**mean_t**)\u003cbr\u003e\n\nCalculate the mean value of the matrix.\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_init(\u0026mat, 2, 2);\n    for (int i = 0; i \u003c mat.rows; i++) {\n        for (int j = 0; j \u003c mat.cols; j++) {\n            mat.data[i][j] = 5;\n        }\n    }\n    mean_t mean = c_matrix_mean(\u0026mat); // mean = 5\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n----\n### `c_matrix_max(mat) and c_matrix_min(mat)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n- return: `max or min` -\u003e (**int, long long, float, double etc..**)\u003cbr\u003e\n\nGet the max or min of the matrix.\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_init(\u0026mat, 2, 2);\n    for (int i = 0; i \u003c mat.rows; i++) {\n        for (int j = 0; j \u003c mat.cols; j++) {\n            mat.data[i][j] = i + j;\n        }\n    }\n    int max = c_matrix_max(\u0026mat); // mean = 2\n    int min = c_matrix_min(\u0026mat); // min = 0\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```\n\n\n----\n### `c_matrix_var(mat) and c_matrix_std(mat)`\n- params:\u003cbr\u003e\n`mat`: c_matrix structure -\u003e (**c_matrix**)\u003cbr\u003e\n- return: `std or var` -\u003e (**std_t, var_t**)\u003cbr\u003e\n\nCalculate the variance or the standard deviation of the matrix.\n```C\nint main() {\n    c_matrix_int mat;\n    c_matrix_init(\u0026mat, 3, 3);\n    for (int i = 0; i \u003c mat.rows; i++) {\n        for (int j = 0; j \u003c mat.cols; j++) {\n            mat.data[i][j] = i + j;\n        }\n    }\n    var_t var = c_matrix_var(\u0026mat); // var = 1.3333333\n    std_t std = c_matrix_std(\u0026mat); // std = 1.154701\n    c_matrix_free(\u0026mat); // free memory\n    return 0;\n}\n```","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fzncl2222%2Fc_array_tools","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fzncl2222%2Fc_array_tools","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fzncl2222%2Fc_array_tools/lists"}