Merge branch 'TheAlgorithms:master' into main

Author: tianyizheng02

Diff for: .github/workflows/directory_writer.yml

@@ -6,7 +6,9 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1  # v1, NOT v2 or v3
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - uses: actions/setup-python@v4
         with:
           python-version: 3.x

Diff for: .github/workflows/project_euler.yml

@@ -14,26 +14,26 @@ jobs:
   project-euler:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
           python-version: 3.x
       - name: Install pytest and pytest-cov
         run: |
           python -m pip install --upgrade pip
-          python -m pip install --upgrade pytest pytest-cov
+          python -m pip install --upgrade numpy pytest pytest-cov
       - run: pytest --doctest-modules --cov-report=term-missing:skip-covered --cov=project_euler/ project_euler/
   validate-solutions:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
           python-version: 3.x
       - name: Install pytest and requests
         run: |
           python -m pip install --upgrade pip
-          python -m pip install --upgrade pytest requests
+          python -m pip install --upgrade numpy pytest requests
       - run: pytest scripts/validate_solutions.py
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Diff for: .pre-commit-config.yaml

@@ -16,12 +16,12 @@ repos:
     -   id: auto-walrus
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.0.287
+    rev: v0.0.288
     hooks:
       - id: ruff
 
   - repo: https://github.com/psf/black
-    rev: 23.7.0
+    rev: 23.9.1
     hooks:
       - id: black
 

Diff for: DIRECTORY.md

@@ -5,6 +5,7 @@
   * [In Static Equilibrium](arithmetic_analysis/in_static_equilibrium.py)
   * [Intersection](arithmetic_analysis/intersection.py)
   * [Jacobi Iteration Method](arithmetic_analysis/jacobi_iteration_method.py)
+  * [Junk](arithmetic_analysis/junk.py)
   * [Lu Decomposition](arithmetic_analysis/lu_decomposition.py)
   * [Newton Forward Interpolation](arithmetic_analysis/newton_forward_interpolation.py)
   * [Newton Method](arithmetic_analysis/newton_method.py)
@@ -628,6 +629,7 @@
   * [Pi Monte Carlo Estimation](maths/pi_monte_carlo_estimation.py)
   * [Points Are Collinear 3D](maths/points_are_collinear_3d.py)
   * [Pollard Rho](maths/pollard_rho.py)
+  * [Polygonal Numbers](maths/polygonal_numbers.py)
   * [Polynomial Evaluation](maths/polynomial_evaluation.py)
   * Polynomials
     * [Single Indeterminate Operations](maths/polynomials/single_indeterminate_operations.py)
@@ -714,6 +716,7 @@
   * Activation Functions
     * [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)
   * [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)

Diff for: arithmetic_analysis/jacobi_iteration_method.py

@@ -12,7 +12,7 @@
 def jacobi_iteration_method(
     coefficient_matrix: NDArray[float64],
     constant_matrix: NDArray[float64],
-    init_val: list[int],
+    init_val: list[float],
     iterations: int,
 ) -> list[float]:
     """
@@ -115,6 +115,7 @@ def jacobi_iteration_method(
 
     strictly_diagonally_dominant(table)
 
+    """
     # Iterates the whole matrix for given number of times
     for _ in range(iterations):
         new_val = []
@@ -130,8 +131,37 @@ def jacobi_iteration_method(
             temp = (temp + val) / denom
             new_val.append(temp)
         init_val = new_val
+    """
+
+    # denominator - a list of values along the diagonal
+    denominator = np.diag(coefficient_matrix)
+
+    # val_last - values of the last column of the table array
+    val_last = table[:, -1]
+
+    # masks - boolean mask of all strings without diagonal
+    # elements array coefficient_matrix
+    masks = ~np.eye(coefficient_matrix.shape[0], dtype=bool)
+
+    # no_diagonals - coefficient_matrix array values without diagonal elements
+    no_diagonals = coefficient_matrix[masks].reshape(-1, rows - 1)
+
+    # Here we get 'i_col' - these are the column numbers, for each row
+    # without diagonal elements, except for the last column.
+    i_row, i_col = np.where(masks)
+    ind = i_col.reshape(-1, rows - 1)
+
+    #'i_col' is converted to a two-dimensional list 'ind', which will be
+    # used to make selections from 'init_val' ('arr' array see below).
+
+    # Iterates the whole matrix for given number of times
+    for _ in range(iterations):
+        arr = np.take(init_val, ind)
+        sum_product_rows = np.sum((-1) * no_diagonals * arr, axis=1)
+        new_val = (sum_product_rows + val_last) / denominator
+        init_val = new_val
 
-    return [float(i) for i in new_val]
+    return new_val.tolist()
 
 
 # Checks if the given matrix is strictly diagonally dominant

Diff for: arithmetic_analysis/junk.py

@@ -21,8 +21,56 @@ def __init__(self) -> None:
         self.head: Node | None = None
         self.size = 0
 
-    def add(self, item: Any) -> None:
-        self.head = Node(item, self.head)
+    def add(self, item: Any, position: int = 0) -> None:
+        """
+        Add an item to the LinkedList at the specified position.
+        Default position is 0 (the head).
+
+        Args:
+            item (Any): The item to add to the LinkedList.
+            position (int, optional): The position at which to add the item.
+                Defaults to 0.
+
+        Raises:
+            ValueError: If the position is negative or out of bounds.
+
+        >>> linked_list = LinkedList()
+        >>> linked_list.add(1)
+        >>> linked_list.add(2)
+        >>> linked_list.add(3)
+        >>> linked_list.add(4, 2)
+        >>> print(linked_list)
+        3 --> 2 --> 4 --> 1
+
+        # Test adding to a negative position
+        >>> linked_list.add(5, -3)
+        Traceback (most recent call last):
+            ...
+        ValueError: Position must be non-negative
+
+        # Test adding to an out-of-bounds position
+        >>> linked_list.add(5,7)
+        Traceback (most recent call last):
+            ...
+        ValueError: Out of bounds
+        >>> linked_list.add(5, 4)
+        >>> print(linked_list)
+        3 --> 2 --> 4 --> 1 --> 5
+        """
+        if position < 0:
+            raise ValueError("Position must be non-negative")
+
+        if position == 0 or self.head is None:
+            new_node = Node(item, self.head)
+            self.head = new_node
+        else:
+            current = self.head
+            for _ in range(position - 1):
+                current = current.next
+                if current is None:
+                    raise ValueError("Out of bounds")
+            new_node = Node(item, current.next)
+            current.next = new_node
         self.size += 1
 
     def remove(self) -> Any:

Diff for: data_structures/linked_list/__init__.py

@@ -0,0 +1,32 @@
+def polygonal_num(num: int, sides: int) -> int:
+    """
+    Returns the `num`th `sides`-gonal number. It is assumed that `num` >= 0 and
+    `sides` >= 3 (see for reference https://en.wikipedia.org/wiki/Polygonal_number).
+
+    >>> polygonal_num(0, 3)
+    0
+    >>> polygonal_num(3, 3)
+    6
+    >>> polygonal_num(5, 4)
+    25
+    >>> polygonal_num(2, 5)
+    5
+    >>> polygonal_num(-1, 0)
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid input: num must be >= 0 and sides must be >= 3.
+    >>> polygonal_num(0, 2)
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid input: num must be >= 0 and sides must be >= 3.
+    """
+    if num < 0 or sides < 3:
+        raise ValueError("Invalid input: num must be >= 0 and sides must be >= 3.")
+
+    return ((sides - 2) * num**2 - (sides - 4) * num) // 2
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

Diff for: maths/polygonal_numbers.py

@@ -0,0 +1,44 @@
+"""
+Implements the Scaled Exponential Linear Unit or SELU function.
+The function takes a vector of K real numbers and two real numbers
+alpha(default = 1.6732) & lambda (default = 1.0507) as input and
+then applies the SELU function to each element of the vector.
+SELU is a self-normalizing activation function. It is a variant
+of the ELU. The main advantage of SELU is that we can be sure
+that the output will always be standardized due to its
+self-normalizing behavior. That means there is no need to
+include Batch-Normalization layers.
+References :
+https://iq.opengenus.org/scaled-exponential-linear-unit/
+"""
+
+import numpy as np
+
+
+def scaled_exponential_linear_unit(
+    vector: np.ndarray, alpha: float = 1.6732, lambda_: float = 1.0507
+) -> np.ndarray:
+    """
+    Applies the Scaled Exponential Linear Unit function to each element of the vector.
+    Parameters :
+        vector : np.ndarray
+        alpha : float (default = 1.6732)
+        lambda_ : float (default = 1.0507)
+
+    Returns : np.ndarray
+    Formula : f(x) = lambda_ * x if x > 0
+                     lambda_ * alpha * (e**x - 1) if x <= 0
+    Examples :
+    >>> scaled_exponential_linear_unit(vector=np.array([1.3, 3.7, 2.4]))
+    array([1.36591, 3.88759, 2.52168])
+
+    >>> scaled_exponential_linear_unit(vector=np.array([1.3, 4.7, 8.2]))
+    array([1.36591, 4.93829, 8.61574])
+    """
+    return lambda_ * np.where(vector > 0, vector, alpha * (np.exp(vector) - 1))
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

Diff for: neural_network/activation_functions/scaled_exponential_linear_unit.py

@@ -30,6 +30,8 @@
 """
 from __future__ import annotations
 
+import numpy as np
+
 
 def get_totients(max_one: int) -> list[int]:
     """
@@ -42,17 +44,14 @@ def get_totients(max_one: int) -> list[int]:
     >>> get_totients(10)
     [0, 1, 1, 2, 2, 4, 2, 6, 4, 6]
     """
-    totients = [0] * max_one
-
-    for i in range(max_one):
-        totients[i] = i
+    totients = np.arange(max_one)
 
     for i in range(2, max_one):
         if totients[i] == i:
-            for j in range(i, max_one, i):
-                totients[j] -= totients[j] // i
+            x = np.arange(i, max_one, i)  # array of indexes to select
+            totients[x] -= totients[x] // i
 
-    return totients
+    return totients.tolist()
 
 
 def has_same_digits(num1: int, num2: int) -> bool: