Fix: Issue TheAlgorithms#9588

Author: haxkd

DIRECTORY.md

@@ -639,7 +639,6 @@
   * [Quadratic Equations Complex Numbers](maths/quadratic_equations_complex_numbers.py)
   * [Radians](maths/radians.py)
   * [Radix2 Fft](maths/radix2_fft.py)
-  * [Relu](maths/relu.py)
   * [Remove Digit](maths/remove_digit.py)
   * [Runge Kutta](maths/runge_kutta.py)
   * [Segmented Sieve](maths/segmented_sieve.py)
@@ -710,6 +709,7 @@
     * [Exponential Linear Unit](neural_network/activation_functions/exponential_linear_unit.py)
     * [Leaky Rectified Linear Unit](neural_network/activation_functions/leaky_rectified_linear_unit.py)
     * [Scaled Exponential Linear Unit](neural_network/activation_functions/scaled_exponential_linear_unit.py)
+    * [Rectified Linear Unit](neural_network/activation_functions/rectified_linear_unit.py)
   * [Back Propagation Neural Network](neural_network/back_propagation_neural_network.py)
   * [Convolution Neural Network](neural_network/convolution_neural_network.py)
   * [Perceptron](neural_network/perceptron.py)

dynamic_programming/longest_palindromic_subsequence.py

@@ -0,0 +1,44 @@
+"""
+author: Sanket Kittad
+Given a string s, find the longest palindromic subsequence's length in s.
+Input: s = "bbbab"
+Output: 4
+Explanation: One possible longest palindromic subsequence is "bbbb".
+Leetcode link: https://leetcode.com/problems/longest-palindromic-subsequence/description/
+"""
+
+
+def longest_palindromic_subsequence(input_string: str) -> int:
+    """
+    This function returns the longest palindromic subsequence in a string
+    >>> longest_palindromic_subsequence("bbbab")
+    4
+    >>> longest_palindromic_subsequence("bbabcbcab")
+    7
+    """
+    n = len(input_string)
+    rev = input_string[::-1]
+    m = len(rev)
+    dp = [[-1] * (m + 1) for i in range(n + 1)]
+    for i in range(n + 1):
+        dp[i][0] = 0
+    for i in range(m + 1):
+        dp[0][i] = 0
+
+    # create and initialise dp array
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            # If characters at i and j are the same
+            # include them in the palindromic subsequence
+            if input_string[i - 1] == rev[j - 1]:
+                dp[i][j] = 1 + dp[i - 1][j - 1]
+            else:
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
+
+    return dp[n][m]
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

maths/bell_numbers.py

@@ -0,0 +1,78 @@
+"""
+Bell numbers represent the number of ways to partition a set into non-empty
+subsets. This module provides functions to calculate Bell numbers for sets of
+integers. In other words, the first (n + 1) Bell numbers.
+
+For more information about Bell numbers, refer to:
+https://en.wikipedia.org/wiki/Bell_number
+"""
+
+
+def bell_numbers(max_set_length: int) -> list[int]:
+    """
+    Calculate Bell numbers for the sets of lengths from 0 to max_set_length.
+    In other words, calculate first (max_set_length + 1) Bell numbers.
+
+    Args:
+        max_set_length (int): The maximum length of the sets for which
+        Bell numbers are calculated.
+
+    Returns:
+        list: A list of Bell numbers for sets of lengths from 0 to max_set_length.
+
+    Examples:
+    >>> bell_numbers(0)
+    [1]
+    >>> bell_numbers(1)
+    [1, 1]
+    >>> bell_numbers(5)
+    [1, 1, 2, 5, 15, 52]
+    """
+    if max_set_length < 0:
+        raise ValueError("max_set_length must be non-negative")
+
+    bell = [0] * (max_set_length + 1)
+    bell[0] = 1
+
+    for i in range(1, max_set_length + 1):
+        for j in range(i):
+            bell[i] += _binomial_coefficient(i - 1, j) * bell[j]
+
+    return bell
+
+
+def _binomial_coefficient(total_elements: int, elements_to_choose: int) -> int:
+    """
+    Calculate the binomial coefficient C(total_elements, elements_to_choose)
+
+    Args:
+        total_elements (int): The total number of elements.
+        elements_to_choose (int): The number of elements to choose.
+
+    Returns:
+        int: The binomial coefficient C(total_elements, elements_to_choose).
+
+    Examples:
+    >>> _binomial_coefficient(5, 2)
+    10
+    >>> _binomial_coefficient(6, 3)
+    20
+    """
+    if elements_to_choose in {0, total_elements}:
+        return 1
+
+    if elements_to_choose > total_elements - elements_to_choose:
+        elements_to_choose = total_elements - elements_to_choose
+
+    coefficient = 1
+    for i in range(elements_to_choose):
+        coefficient *= total_elements - i
+        coefficient //= i + 1
+
+    return coefficient
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

maths/relu.py neural_network/activation_functions/rectified_linear_unit.py

@@ -0,0 +1,67 @@
+"""
+The photoelectric effect is the emission of electrons when electromagnetic radiation ,
+such as light, hits a material. Electrons emitted in this manner are called
+photoelectrons.
+
+In 1905, Einstein proposed a theory of the photoelectric effect using a concept that
+light consists of tiny packets of energy known as photons or light quanta. Each packet
+carries energy hv that is proportional to the frequency v of the corresponding
+electromagnetic wave. The proportionality constant h has become known as the
+Planck constant. In the range of kinetic energies of the electrons that are removed from
+their varying atomic bindings by the absorption of a photon of energy hv, the highest
+kinetic energy K_max is :
+
+K_max = hv-W
+
+Here, W is the minimum energy required to remove an electron from the surface of the
+material. It is called the work function of the surface
+
+Reference: https://en.wikipedia.org/wiki/Photoelectric_effect
+
+"""
+
+PLANCK_CONSTANT_JS = 6.6261 * pow(10, -34)  # in SI (Js)
+PLANCK_CONSTANT_EVS = 4.1357 * pow(10, -15)  # in eVs
+
+
+def maximum_kinetic_energy(
+    frequency: float, work_function: float, in_ev: bool = False
+) -> float:
+    """
+    Calculates the maximum kinetic energy of emitted electron from the surface.
+    if the maximum kinetic energy is zero then no electron will be emitted
+    or given electromagnetic wave frequency is small.
+
+    frequency (float): Frequency of electromagnetic wave.
+    work_function (float): Work function of the surface.
+    in_ev (optional)(bool): Pass True if values are in eV.
+
+    Usage example:
+    >>> maximum_kinetic_energy(1000000,2)
+    0
+    >>> maximum_kinetic_energy(1000000,2,True)
+    0
+    >>> maximum_kinetic_energy(10000000000000000,2,True)
+    39.357000000000006
+    >>> maximum_kinetic_energy(-9,20)
+    Traceback (most recent call last):
+        ...
+    ValueError: Frequency can't be negative.
+
+    >>> maximum_kinetic_energy(1000,"a")
+    Traceback (most recent call last):
+        ...
+    TypeError: unsupported operand type(s) for -: 'float' and 'str'
+
+    """
+    if frequency < 0:
+        raise ValueError("Frequency can't be negative.")
+    if in_ev:
+        return max(PLANCK_CONSTANT_EVS * frequency - work_function, 0)
+    return max(PLANCK_CONSTANT_JS * frequency - work_function, 0)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()