Merge branch 'TheAlgorithms:master' into master

Author: akshaybsh

maths/gamma.py

@@ -1,35 +1,43 @@
+"""
+Gamma function is a very useful tool in math and physics.
+It helps calculating complex integral in a convenient way.
+for more info: https://en.wikipedia.org/wiki/Gamma_function
+In mathematics, the gamma function is one commonly
+used extension of the factorial function to complex numbers.
+The gamma function is defined for all complex numbers except
+the non-positive integers
+Python's Standard Library math.gamma() function overflows around gamma(171.624).
+"""
 import math
 
 from numpy import inf
 from scipy.integrate import quad
 
 
-def gamma(num: float) -> float:
+def gamma_iterative(num: float) -> float:
     """
-    https://en.wikipedia.org/wiki/Gamma_function
-    In mathematics, the gamma function is one commonly
-    used extension of the factorial function to complex numbers.
-    The gamma function is defined for all complex numbers except the non-positive
-    integers
-    >>> gamma(-1)
+    Calculates the value of Gamma function of num
+    where num is either an integer (1, 2, 3..) or a half-integer (0.5, 1.5, 2.5 ...).
+
+    >>> gamma_iterative(-1)
     Traceback (most recent call last):
         ...
     ValueError: math domain error
-    >>> gamma(0)
+    >>> gamma_iterative(0)
     Traceback (most recent call last):
         ...
     ValueError: math domain error
-    >>> gamma(9)
+    >>> gamma_iterative(9)
     40320.0
     >>> from math import gamma as math_gamma
-    >>> all(.99999999 < gamma(i) / math_gamma(i) <= 1.000000001
+    >>> all(.99999999 < gamma_iterative(i) / math_gamma(i) <= 1.000000001
     ...     for i in range(1, 50))
     True
-    >>> gamma(-1)/math_gamma(-1) <= 1.000000001
+    >>> gamma_iterative(-1)/math_gamma(-1) <= 1.000000001
     Traceback (most recent call last):
         ...
     ValueError: math domain error
-    >>> gamma(3.3) - math_gamma(3.3) <= 0.00000001
+    >>> gamma_iterative(3.3) - math_gamma(3.3) <= 0.00000001
     True
     """
     if num <= 0:
@@ -42,7 +50,66 @@ def integrand(x: float, z: float) -> float:
     return math.pow(x, z - 1) * math.exp(-x)
 
 
+def gamma_recursive(num: float) -> float:
+    """
+    Calculates the value of Gamma function of num
+    where num is either an integer (1, 2, 3..) or a half-integer (0.5, 1.5, 2.5 ...).
+    Implemented using recursion
+    Examples:
+    >>> from math import isclose, gamma as math_gamma
+    >>> gamma_recursive(0.5)
+    1.7724538509055159
+    >>> gamma_recursive(1)
+    1.0
+    >>> gamma_recursive(2)
+    1.0
+    >>> gamma_recursive(3.5)
+    3.3233509704478426
+    >>> gamma_recursive(171.5)
+    9.483367566824795e+307
+    >>> all(isclose(gamma_recursive(num), math_gamma(num))
+    ...     for num in (0.5, 2, 3.5, 171.5))
+    True
+    >>> gamma_recursive(0)
+    Traceback (most recent call last):
+        ...
+    ValueError: math domain error
+    >>> gamma_recursive(-1.1)
+    Traceback (most recent call last):
+        ...
+    ValueError: math domain error
+    >>> gamma_recursive(-4)
+    Traceback (most recent call last):
+        ...
+    ValueError: math domain error
+    >>> gamma_recursive(172)
+    Traceback (most recent call last):
+        ...
+    OverflowError: math range error
+    >>> gamma_recursive(1.1)
+    Traceback (most recent call last):
+        ...
+    NotImplementedError: num must be an integer or a half-integer
+    """
+    if num <= 0:
+        raise ValueError("math domain error")
+    if num > 171.5:
+        raise OverflowError("math range error")
+    elif num - int(num) not in (0, 0.5):
+        raise NotImplementedError("num must be an integer or a half-integer")
+    elif num == 0.5:
+        return math.sqrt(math.pi)
+    else:
+        return 1.0 if num == 1 else (num - 1) * gamma_recursive(num - 1)
+
+
 if __name__ == "__main__":
     from doctest import testmod
 
     testmod()
+    num = 1.0
+    while num:
+        num = float(input("Gamma of: "))
+        print(f"gamma_iterative({num}) = {gamma_iterative(num)}")
+        print(f"gamma_recursive({num}) = {gamma_recursive(num)}")
+        print("\nEnter 0 to exit...")

maths/gamma_recursive.py

@@ -0,0 +1,39 @@
+"""
+Mish Activation Function
+
+Use Case: Improved version of the ReLU activation function used in Computer Vision.
+For more detailed information, you can refer to the following link:
+https://en.wikipedia.org/wiki/Rectifier_(neural_networks)#Mish
+"""
+
+import numpy as np
+
+
+def mish(vector: np.ndarray) -> np.ndarray:
+    """
+        Implements the Mish activation function.
+
+        Parameters:
+            vector (np.ndarray): The input array for Mish activation.
+
+        Returns:
+            np.ndarray: The input array after applying the Mish activation.
+
+        Formula:
+            f(x) = x * tanh(softplus(x)) = x * tanh(ln(1 + e^x))
+
+    Examples:
+    >>> mish(vector=np.array([2.3,0.6,-2,-3.8]))
+    array([ 2.26211893,  0.46613649, -0.25250148, -0.08405831])
+
+    >>> mish(np.array([-9.2, -0.3, 0.45, -4.56]))
+    array([-0.00092952, -0.15113318,  0.33152014, -0.04745745])
+
+    """
+    return vector * np.tanh(np.log(1 + np.exp(vector)))
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

neural_network/activation_functions/mish.py

@@ -0,0 +1,37 @@
+"""
+Softplus Activation Function
+
+Use Case: The Softplus function is a smooth approximation of the ReLU function.
+For more detailed information, you can refer to the following link:
+https://en.wikipedia.org/wiki/Rectifier_(neural_networks)#Softplus
+"""
+
+import numpy as np
+
+
+def softplus(vector: np.ndarray) -> np.ndarray:
+    """
+    Implements the Softplus activation function.
+
+    Parameters:
+        vector (np.ndarray): The input array for the Softplus activation.
+
+    Returns:
+        np.ndarray: The input array after applying the Softplus activation.
+
+    Formula: f(x) = ln(1 + e^x)
+
+    Examples:
+    >>> softplus(np.array([2.3, 0.6, -2, -3.8]))
+    array([2.39554546, 1.03748795, 0.12692801, 0.02212422])
+
+    >>> softplus(np.array([-9.2, -0.3, 0.45, -4.56]))
+    array([1.01034298e-04, 5.54355244e-01, 9.43248946e-01, 1.04077103e-02])
+    """
+    return np.log(1 + np.exp(vector))
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

neural_network/activation_functions/softplus.py

@@ -0,0 +1,37 @@
+"""
+This is Booyer-Moore Majority Vote Algorithm. The problem statement goes like this:
+Given an integer array of size n, find all elements that appear more than ⌊ n/k ⌋ times.
+We have to solve in O(n) time and O(1) Space.
+URL : https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_majority_vote_algorithm
+"""
+from collections import Counter
+
+
+def majority_vote(votes: list[int], votes_needed_to_win: int) -> list[int]:
+    """
+    >>> majority_vote([1, 2, 2, 3, 1, 3, 2], 3)
+    [2]
+    >>> majority_vote([1, 2, 2, 3, 1, 3, 2], 2)
+    []
+    >>> majority_vote([1, 2, 2, 3, 1, 3, 2], 4)
+    [1, 2, 3]
+    """
+    majority_candidate_counter: Counter[int] = Counter()
+    for vote in votes:
+        majority_candidate_counter[vote] += 1
+        if len(majority_candidate_counter) == votes_needed_to_win:
+            majority_candidate_counter -= Counter(set(majority_candidate_counter))
+    majority_candidate_counter = Counter(
+        vote for vote in votes if vote in majority_candidate_counter
+    )
+    return [
+        vote
+        for vote in majority_candidate_counter
+        if majority_candidate_counter[vote] > len(votes) / votes_needed_to_win
+    ]
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()