Add functions

Utils/ArraySort.h

@@ -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) {
+            for (size_t low = 0, high = size - 1; low < high; ++low, --high) {
-                int tmp   = arr[low];
+                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;

Utils/ArrayUtils.h

@@ -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;
+        }
     }
 }