Jingga/cOMS
1
0
Fork 0
mirror of https://github.com/Karaka-Management/cOMS.git synced 2026-01-24 08:48:40 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Add functions

Browse Source
This commit is contained in:
Dennis Eichhorn 2023-11-09 00:26:13 +00:00
parent f6982b5fb6
commit 748e82358d
2 changed files with 172 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
Utils/ArraySort.h
View File

@ -18,19 +18,19 @@ namespace Utils
namespace ArraySort
{
inline
void reverse_int(int *arr, int size)
void reverse_int(int64_t *arr, size_t size)
{
for (int low = 0, high = size - 1; low < high; ++low, --high) {
int tmp = arr[low];
for (size_t low = 0, high = size - 1; low < high; ++low, --high) {
int64_t tmp = arr[low];
arr[low] = arr[high];
arr[high] = tmp;
}
}
inline
void reverse_float(float *arr, int size)
void reverse_float(float *arr, size_t size)
{
for (int low = 0, high = size - 1; low < high; ++low, --high) {
for (size_t low = 0, high = size - 1; low < high; ++low, --high) {
float tmp = arr[low];
arr[low] = arr[high];
arr[high] = tmp;
@ -38,9 +38,9 @@ namespace Utils
}
inline
void reverse_double(double *arr, int size)
void reverse_double(double *arr, size_t size)
{
for (int low = 0, high = size - 1; low < high; ++low, --high) {
for (size_t low = 0, high = size - 1; low < high; ++low, --high) {
double tmp = arr[low];
arr[low] = arr[high];
arr[high] = tmp;
@ -48,9 +48,9 @@ namespace Utils
}
inline
void reverse_char(char **arr, int size)
void reverse_char(char **arr, size_t size)
{
for (int low = 0, high = size - 1; low < high; ++low, --high) {
for (size_t low = 0, high = size - 1; low < high; ++low, --high) {
char* tmp = arr[low];
arr[low] = arr[high];
arr[high] = tmp;

168
Utils/ArrayUtils.h
View File

@ -21,15 +21,15 @@ namespace Utils
namespace ArrayUtils
{
inline
char* get_arg(const char *id, char **argv, int length)
char* get_arg(const char *id, char **argv, size_t size)
{
if (Utils::StringUtils::is_number(id)) {
return argv[atoi(id)];
}
for (int i = 0; i < length - 1; ++i) {
for (size_t i = 0; i < size - 1; ++i) {
if (strcmp(id, argv[i]) == 0) {
return i + 1 >= length ? NULL : argv[i + 1];
return i + 1 >= size ? NULL : argv[i + 1];
}
}
@ -37,9 +37,9 @@ namespace Utils
}
inline
bool has_arg(const char *id, char **argv, int length)
bool has_arg(const char *id, char **argv, size_t size)
{
for (int i = 0; i < length; ++i) {
for (size_t i = 0; i < size; ++i) {
if (strcmp(id, argv[i]) == 0) {
return true;
}
@ -47,6 +47,164 @@ namespace Utils
return false;
}
inline
double array_sum_double(double *array, size_t size)
{
double sum = 0.0;
for (size_t i = 0; i < size; ++i) {
sum += array[i];
}
return sum;
}
inline
float array_sum_float(float *array, size_t size)
{
float sum = 0.0;
for (size_t i = 0; i < size; ++i) {
sum += array[i];
}
return sum;
}
inline
int64_t array_sum_int(int64_t *array, size_t size)
{
int64_t sum = 0;
for (size_t i = 0; i < size; ++i) {
sum += array[i];
}
return sum;
}
inline
size_t find_in_array_string(const char *element, const char **array, size_t size)
{
for (size_t i = 0; i < size; ++i) {
if (strcmp(element, array[i]) == 0) {
return i;
}
}
return -1;
}
inline
size_t find_in_array_double(double element, double *array, size_t size)
{
for (size_t i = 0; i < size; ++i) {
if (array[i] == element) {
return i;
}
}
return -1;
}
inline
size_t find_in_array_float(float element, float *array, size_t size)
{
for (size_t i = 0; i < size; ++i) {
if (array[i] == element) {
return i;
}
}
return -1;
}
inline
size_t find_in_array_int(int64_t element, int64_t *array, size_t size)
{
for (size_t i = 0; i < size; ++i) {
if (array[i] == element) {
return i;
}
}
return -1;
}
inline
double* merge_arrays_double(double* array1, size_t size1, double* array2, size_t size2)
{
double* merged = (double*) malloc((size1 + size2) * sizeof(double));
if (merged == NULL) {
return NULL;
}
for (size_t i = 0; i < size1; ++i) {
merged[i] = array1[i];
}
for (size_t i = 0; i < size2; ++i) {
merged[size1 + i] = array2[i];
}
return merged;
}
inline
float* merge_arrays_float(float* array1, size_t size1, float* array2, size_t size2)
{
float* merged = (float*) malloc((size1 + size2) * sizeof(float));
if (merged == NULL) {
return NULL;
}
for (size_t i = 0; i < size1; ++i) {
merged[i] = array1[i];
}
for (size_t i = 0; i < size2; ++i) {
merged[size1 + i] = array2[i];
}
return merged;
}
inline
int64_t* merge_arrays_int(int64_t* array1, size_t size1, int64_t* array2, size_t size2)
{
int64_t* merged = (int64_t*) malloc((size1 + size2) * sizeof(int64_t));
if (merged == NULL) {
return NULL;
}
for (size_t i = 0; i < size1; ++i) {
merged[i] = array1[i];
}
for (size_t i = 0; i < size2; ++i) {
merged[size1 + i] = array2[i];
}
return merged;
}
char** merge_arrays_char(const char** array1, size_t size1, const char** array2, size_t size2)
{
char** merged = (char**) malloc((size1 + size2) * sizeof(char*));
if (merged == NULL) {
return NULL;
}
for (size_t i = 0; i < size1; ++i) {
merged[i] = (char*) malloc((strlen(arr1[i]) + 1) * sizeof(char));
strcpy(merged[i], arr1[i]);
}
for (size_t i = 0; i < size2; ++i) {
merged[i] = (char*) malloc((strlen(arr2[i]) + 1) * sizeof(char));
strcpy(merged[i], arr2[i]);
}
return merged;
}
}
}