feat: Concatenate algorithms

Author: CaedenPH

maths/double_factorial_iterative.py

@@ -1,4 +1,33 @@
-def double_factorial(n: int) -> int:
+def double_factorial(num: int) -> int:
+    """
+    Compute double factorial using iterative method.
+
+    To learn about the theory behind this algorithm:
+    https://en.wikipedia.org/wiki/Double_factorial
+
+    >>> import math
+    >>> all(double_factorial(i) == math.prod(range(i, 0, -2)) for i in range(20))
+    True
+    >>> double_factorial(0.1)
+    Traceback (most recent call last):
+        ...
+    ValueError: double_factorial() only accepts integral values
+    >>> double_factorial(-1)
+    Traceback (most recent call last):
+        ...
+    ValueError: double_factorial() not defined for negative values
+    """
+    if not isinstance(num, int):
+        raise ValueError("double_factorial() only accepts integral values")
+    if num < 0:
+        raise ValueError("double_factorial() not defined for negative values")
+    value = 1
+    for i in range(num, 0, -2):
+        value *= i
+    return value
+
+
+def double_factorial_recursive(n: int) -> int:
     """
     Compute double factorial using recursive method.
     Recursion can be costly for large numbers.
@@ -22,7 +51,7 @@ def double_factorial(n: int) -> int:
         raise ValueError("double_factorial() only accepts integral values")
     if n < 0:
         raise ValueError("double_factorial() not defined for negative values")
-    return 1 if n <= 1 else n * double_factorial(n - 2)
+    return 1 if n <= 1 else n * double_factorial_recursive(n - 2)
 
 
 if __name__ == "__main__":

maths/double_factorial_recursive.py

@@ -34,7 +34,7 @@ def factorial(number: int) -> int:
     return value
 
 
-def factorial(n: int) -> int:
+def factorial_recursive(n: int) -> int:
     """
     Calculate the factorial of a positive integer
     https://en.wikipedia.org/wiki/Factorial

maths/factorial.py

@@ -59,7 +59,7 @@ def find_max_recursive(nums: list[int | float], left: int, right: int) -> int |
     IndexError: list index out of range
     """
     if len(nums) == 0:
-        raise ValueError("find_max() arg is an empty sequence")
+        raise ValueError("find_max_recursive() arg is an empty sequence")
     if (
         left >= len(nums)
         or left < -len(nums)
@@ -70,8 +70,10 @@ def find_max_recursive(nums: list[int | float], left: int, right: int) -> int |
     if left == right:
         return nums[left]
     mid = (left + right) >> 1  # the middle
-    left_max = find_max(nums, left, mid)  # find max in range[left, mid]
-    right_max = find_max(nums, mid + 1, right)  # find max in range[mid + 1, right]
+    left_max = find_max_recursive(nums, left, mid)  # find max in range[left, mid]
+    right_max = find_max_recursive(
+        nums, mid + 1, right
+    )  # find max in range[mid + 1, right]
 
     return left_max if left_max >= right_max else right_max
 

maths/find_max.py

@@ -29,7 +29,7 @@ def find_min(nums: list[int | float]) -> int | float:
 
 
 # Divide and Conquer algorithm
-def find_min(nums: list[int | float], left: int, right: int) -> int | float:
+def find_min_recursive(nums: list[int | float], left: int, right: int) -> int | float:
     """
     find min value in list
     :param nums: contains elements
@@ -62,7 +62,7 @@ def find_min(nums: list[int | float], left: int, right: int) -> int | float:
     IndexError: list index out of range
     """
     if len(nums) == 0:
-        raise ValueError("find_min() arg is an empty sequence")
+        raise ValueError("find_min_recursive() arg is an empty sequence")
     if (
         left >= len(nums)
         or left < -len(nums)
@@ -73,8 +73,10 @@ def find_min(nums: list[int | float], left: int, right: int) -> int | float:
     if left == right:
         return nums[left]
     mid = (left + right) >> 1  # the middle
-    left_min = find_min(nums, left, mid)  # find min in range[left, mid]
-    right_min = find_min(nums, mid + 1, right)  # find min in range[mid + 1, right]
+    left_min = find_min_recursive(nums, left, mid)  # find min in range[left, mid]
+    right_min = find_min_recursive(
+        nums, mid + 1, right
+    )  # find min in range[mid + 1, right]
 
     return left_min if left_min <= right_min else right_min
 

maths/find_min.py

@@ -5,7 +5,7 @@
 Python's Standard Library gamma() function overflows around gamma(171.624).
 """
 
-from math import pi, sqrt, exp
+from math import exp, pi, sqrt
 
 from numpy import inf
 from scipy.integrate import quad
@@ -106,7 +106,7 @@ def test_gamma() -> None:
     assert gamma(0.5) == sqrt(pi)
     assert gamma(1) == 1.0
     assert gamma(2) == 1.0
-    
+
 
 if __name__ == "__main__":
     from doctest import testmod
@@ -117,4 +117,4 @@ def test_gamma() -> None:
     while num:
         num = float(input("Gamma of: "))
         print(f"gamma({num}) = {gamma(num)}")
-        print("\nEnter 0 to exit...")
+        print("\nEnter 0 to exit...")