feat: add mathematics_max, mathematics_min

Also add `mathematics_max_values` and
`mathematics_min_values` to check in array.

LICENSE

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) Théo LUDWIG
+Copyright (c) Théo LUDWIG <contact@theoludwig.fr>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

lib/mathematics.c

@@ -32,3 +32,39 @@ float mathematics_square_root(float number) {
 unsigned long long mathematics_factorial(unsigned long long number) {
   return number == 0 ? 1 : number * mathematics_factorial(number - 1);
 }
+
+int64_t mathematics_opposite(int64_t number) {
+  return number * -1;
+}
+
+int64_t mathematics_max(int64_t number1, int64_t number2) {
+  return number1 > number2 ? number1 : number2;
+}
+
+int64_t mathematics_max_values(int64_t *values, size_t values_length) {
+  int64_t max = 0;
+  if (values_length <= 0) {
+    return max;
+  }
+  max = values[0];
+  for (size_t index = 1; index < values_length; index++) {
+    max = mathematics_max(max, values[index]);
+  }
+  return max;
+}
+
+int64_t mathematics_min(int64_t number1, int64_t number2) {
+  return number1 > number2 ? number2 : number1;
+}
+
+int64_t mathematics_min_values(int64_t *values, size_t values_length) {
+  int64_t min = 0;
+  if (values_length <= 0) {
+    return min;
+  }
+  min = values[0];
+  for (size_t index = 1; index < values_length; index++) {
+    min = mathematics_min(min, values[index]);
+  }
+  return min;
+}

lib/mathematics.h

@@ -5,6 +5,7 @@
 
 #include <errno.h>
 #include <stdbool.h>
+#include <stdlib.h>
 
 #include "types.h"
 
@@ -66,4 +67,59 @@ float mathematics_square_root(float number);
  */
 unsigned long long mathematics_factorial(unsigned long long number);
 
+/**
+ * @brief Calulcates the opposite number (additive inverse).
+ *
+ * @param number
+ * @return int64_t
+ *
+ * @code
+ * mathematics_opposite(7) // -7
+ *
+ * mathematics_opposite(-7) // 7
+ * @endcode
+ * @since vTODO
+ */
+int64_t mathematics_opposite(int64_t number);
+
+/**
+ * @brief Returns the largest number between 2 numbers.
+ *
+ * @param number1
+ * @param number2
+ * @return int64_t
+ * @since vTODO
+ */
+int64_t mathematics_max(int64_t number1, int64_t number2);
+
+/**
+ * @brief Returns the largest number between multiple numbers. If the array is empty, returns 0.
+ *
+ * @param values
+ * @param values_length
+ * @return int64_t
+ * @since vTODO
+ */
+int64_t mathematics_max_values(int64_t *values, size_t values_length);
+
+/**
+ * @brief Returns the smallest number between 2 numbers.
+ *
+ * @param number1
+ * @param number2
+ * @return int64_t
+ * @since vTODO
+ */
+int64_t mathematics_min(int64_t number1, int64_t number2);
+
+/**
+ * @brief Returns the smallest number between multiple numbers. If the array is empty, returns 0.
+ *
+ * @param values
+ * @param values_length
+ * @return int64_t
+ * @since vTODO
+ */
+int64_t mathematics_min_values(int64_t *values, size_t values_length);
+
 #endif

lib/string.c

@@ -407,3 +407,36 @@ size_t string_last_position_of(const string_t string, const char character) {
   }
   return position_found;
 }
+
+string_t string_pad_start(const string_t string, const string_t pad_string, size_t target_length) {
+  string_t result = malloc(sizeof(char) * (target_length + 1));
+  size_t initial_length = string_get_length(string);
+  size_t left_length = target_length - initial_length;
+  if (target_length <= initial_length) {
+    left_length = 0;
+  }
+  size_t pad_length = string_get_length(pad_string);
+  size_t count_pad_string = 0;
+  size_t index_initial_string = 0;
+  for (size_t index = 0; index < target_length; index++) {
+    if (index < left_length) {
+      size_t index_pad_string = count_pad_string % pad_length;
+      result[index] = pad_string[index_pad_string];
+      count_pad_string += 1;
+    } else {
+      result[index] = string[index_initial_string];
+      index_initial_string += 1;
+    }
+  }
+  result[target_length] = '\0';
+  return result;
+}
+
+string_t string_zero_pad(uint64_t number, size_t places) {
+  string_t number_string = convert_number_to_string((long long)number);
+  string_t pad_string = string_copy("0");
+  string_t result = string_pad_start(number_string, pad_string, places);
+  free(pad_string);
+  free(number_string);
+  return result;
+}

lib/string.h

@@ -224,6 +224,7 @@ bool string_get_is_substring(const string_t string, const string_t substring);
  * @param number
  * @param separator
  * @return string_t
+ *
  * @code
  * string_get_formatted_number(1000, " ") // "1 000"
  * string_get_formatted_number(1000, ",") // "1,000"
@@ -270,7 +271,10 @@ bool string_ends_with(const string_t string, const string_t prefix);
  * @param string
  * @param substring
  * @return size_t
- * @example string_position_of("hello world", 'e') // 2
+ *
+ * @code
+ * string_position_of("hello world", 'e') // 2
+ * @endcode
  * @since v4.2.0
  */
 size_t string_position_of(const string_t string, const char character);
@@ -281,9 +285,43 @@ size_t string_position_of(const string_t string, const char character);
  * @param string
  * @param character
  * @return size_t
- * @example string_last_position_of("hello world", 'o') // 8
+ *
+ * @code
+ * string_last_position_of("hello world", 'o') // 8
+ * @endcode
  * @since v4.2.0
  */
 size_t string_last_position_of(const string_t string, const char character);
 
+/**
+ * @brief Pads a `string` with another `pad_string` (multiple times, if needed) until the resulting string reaches the `target_length`. The padding is applied from the start (left) of the string.
+ *
+ * @param string The string to pad.
+ * @param pad_string The string to pad the current string with, to the left.
+ * @param target_length
+ * @return string_t
+ *
+ * @code
+ * string_pad_start("hello", " ", 10) // "     hello"
+ * @endcode
+ * @since vTODO
+ */
+string_t string_pad_start(const string_t string, const string_t pad_string, size_t target_length);
+
+/**
+ * @brief Pad a number with zeros.
+ *
+ * @param number
+ * @param places
+ * @return string_t
+ *
+ * @code
+ * string_zero_pad(1, 2) // "01"
+ *
+ * string_zero_pad(10, 2) // "10"
+ * @endcode
+ * @since vTODO
+ */
+string_t string_zero_pad(uint64_t number, size_t places);
+
 #endif

test/mathematics_test.c

@@ -6,6 +6,11 @@ void mathematics_test() {
   mathematics_root_test();
   mathematics_square_root_test();
   mathematics_factorial_test();
+  mathematics_opposite_test();
+  mathematics_max_test();
+  mathematics_max_values_test();
+  mathematics_min_test();
+  mathematics_min_values_test();
 }
 
 void mathematics_absolute_value_test() {
@@ -56,3 +61,38 @@ void mathematics_factorial_test() {
   assert(mathematics_factorial(9) == 362880);
   assert(mathematics_factorial(10) == 3628800);
 }
+
+void mathematics_opposite_test() {
+  assert(mathematics_opposite(-7) == 7);
+  assert(mathematics_opposite(7) == -7);
+}
+
+void mathematics_max_test() {
+  assert(mathematics_max(0, 0) == 0);
+  assert(mathematics_max(0, 1) == 1);
+  assert(mathematics_max(2, 0) == 2);
+  assert(mathematics_max(54, 37) == 54);
+}
+
+void mathematics_max_values_test() {
+  int64_t values[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  assert(mathematics_max_values(values, 10) == 9);
+
+  int64_t values2[] = {8, 6, 4, 7};
+  assert(mathematics_max_values(values2, 4) == 8);
+}
+
+void mathematics_min_test() {
+  assert(mathematics_min(0, 0) == 0);
+  assert(mathematics_min(3, 5) == 3);
+  assert(mathematics_min(2, 1) == 1);
+  assert(mathematics_min(54, 37) == 37);
+}
+
+void mathematics_min_values_test() {
+  int64_t values[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  assert(mathematics_min_values(values, 10) == 0);
+
+  int64_t values2[] = {9, 6, 8, 7};
+  assert(mathematics_min_values(values2, 4) == 6);
+}

test/mathematics_test.h

@@ -17,4 +17,14 @@ void mathematics_square_root_test();
 
 void mathematics_factorial_test();
 
+void mathematics_opposite_test();
+
+void mathematics_max_test();
+
+void mathematics_max_values_test();
+
+void mathematics_min_test();
+
+void mathematics_min_values_test();
+
 #endif

test/string_test.c

@@ -27,6 +27,8 @@ void string_test() {
   string_ends_with_test();
   string_position_of_test();
   string_last_position_of_test();
+  string_pad_start_test();
+  string_zero_pad_test();
 }
 
 void string_get_length_test() {
@@ -303,3 +305,31 @@ void string_last_position_of_test() {
   assert(string_last_position_of("abcdef", 'f') == 6);
   assert(string_last_position_of("abcdef", 'g') == 0);
 }
+
+void string_pad_start_test() {
+  string_t result = string_pad_start("hello", "ab", 10);
+  assert(assert_string_equal(result, "ababahello"));
+  free(result);
+
+  result = string_pad_start("hello", "ab", 4);
+  assert(assert_string_equal(result, "hell"));
+  free(result);
+
+  result = string_pad_start("hello", "ab", 5);
+  assert(assert_string_equal(result, "hello"));
+  free(result);
+
+  result = string_pad_start("hello", "ab", 6);
+  assert(assert_string_equal(result, "ahello"));
+  free(result);
+}
+
+void string_zero_pad_test() {
+  string_t result = string_zero_pad(1, 2);
+  assert(assert_string_equal(result, "01"));
+  free(result);
+
+  result = string_zero_pad(10, 2);
+  assert(assert_string_equal(result, "10"));
+  free(result);
+}

test/string_test.h

@@ -62,4 +62,8 @@ void string_position_of_test();
 
 void string_last_position_of_test();
 
+void string_pad_start_test();
+
+void string_zero_pad_test();
+
 #endif