resolve

for more information, see https://pre-commit.ci

.devcontainer/Dockerfile

@@ -0,0 +1,8 @@
+# https://github.com/microsoft/vscode-dev-containers/blob/main/containers/python-3/README.md
+ARG VARIANT=3.11-bookworm
+FROM mcr.microsoft.com/vscode/devcontainers/python:${VARIANT}
+COPY requirements.txt /tmp/pip-tmp/
+RUN python3 -m pip install --upgrade pip \
+  && python3 -m pip install --no-cache-dir install -r /tmp/pip-tmp/requirements.txt \
+  && pipx install pre-commit ruff \
+  && pre-commit install

.devcontainer/devcontainer.json

@@ -0,0 +1,42 @@
+{
+	"name": "Python 3",
+	"build": {
+		"dockerfile": "Dockerfile",
+		"context": "..",
+		"args": {
+			// Update 'VARIANT' to pick a Python version: 3, 3.10, 3.9, 3.8, 3.7, 3.6
+			// Append -bullseye or -buster to pin to an OS version.
+			// Use -bullseye variants on local on arm64/Apple Silicon.
+			"VARIANT": "3.11-bookworm",
+		}
+	},
+
+	// Configure tool-specific properties.
+	"customizations": {
+		// Configure properties specific to VS Code.
+		"vscode": {
+			// Set *default* container specific settings.json values on container create.
+			"settings": {
+				"python.defaultInterpreterPath": "/usr/local/bin/python",
+				"python.linting.enabled": true,
+				"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
+				"python.linting.mypyPath": "/usr/local/py-utils/bin/mypy"
+			},
+
+			// Add the IDs of extensions you want installed when the container is created.
+			"extensions": [
+				"ms-python.python",
+				"ms-python.vscode-pylance"
+			]
+		}
+	},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "pip3 install --user -r requirements.txt",
+
+	// Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+	"remoteUser": "vscode"
+}

.pre-commit-config.yaml

@@ -16,7 +16,7 @@ repos:
     -   id: auto-walrus
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.0.280
+    rev: v0.0.284
     hooks:
       - id: ruff
 
@@ -33,7 +33,7 @@ repos:
           - tomli
 
   - repo: https://github.com/tox-dev/pyproject-fmt
-    rev: "0.13.0"
+    rev: "0.13.1"
     hooks:
       - id: pyproject-fmt
 
@@ -51,7 +51,7 @@ repos:
       - id: validate-pyproject
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.4.1
+    rev: v1.5.0
     hooks:
       - id: mypy
         args:

DIRECTORY.md

@@ -74,6 +74,7 @@
   * [Game Of Life](cellular_automata/game_of_life.py)
   * [Nagel Schrekenberg](cellular_automata/nagel_schrekenberg.py)
   * [One Dimensional](cellular_automata/one_dimensional.py)
+  * [Wa Tor](cellular_automata/wa_tor.py)
 
 ## Ciphers
   * [A1Z26](ciphers/a1z26.py)
@@ -236,8 +237,8 @@
     * [Double Ended Queue](data_structures/queue/double_ended_queue.py)
     * [Linked Queue](data_structures/queue/linked_queue.py)
     * [Priority Queue Using List](data_structures/queue/priority_queue_using_list.py)
+    * [Queue By List](data_structures/queue/queue_by_list.py)
     * [Queue By Two Stacks](data_structures/queue/queue_by_two_stacks.py)
-    * [Queue On List](data_structures/queue/queue_on_list.py)
     * [Queue On Pseudo Stack](data_structures/queue/queue_on_pseudo_stack.py)
   * Stacks
     * [Balanced Parentheses](data_structures/stacks/balanced_parentheses.py)
@@ -335,9 +336,11 @@
   * [Minimum Tickets Cost](dynamic_programming/minimum_tickets_cost.py)
   * [Optimal Binary Search Tree](dynamic_programming/optimal_binary_search_tree.py)
   * [Palindrome Partitioning](dynamic_programming/palindrome_partitioning.py)
+  * [Regex Match](dynamic_programming/regex_match.py)
   * [Rod Cutting](dynamic_programming/rod_cutting.py)
   * [Subset Generation](dynamic_programming/subset_generation.py)
   * [Sum Of Subset](dynamic_programming/sum_of_subset.py)
+  * [Tribonacci](dynamic_programming/tribonacci.py)
   * [Viterbi](dynamic_programming/viterbi.py)
   * [Word Break](dynamic_programming/word_break.py)
 
@@ -511,7 +514,7 @@
   * Lstm
     * [Lstm Prediction](machine_learning/lstm/lstm_prediction.py)
   * [Multilayer Perceptron Classifier](machine_learning/multilayer_perceptron_classifier.py)
-  * [Polymonial Regression](machine_learning/polymonial_regression.py)
+  * [Polynomial Regression](machine_learning/polynomial_regression.py)
   * [Scoring Functions](machine_learning/scoring_functions.py)
   * [Self Organizing Map](machine_learning/self_organizing_map.py)
   * [Sequential Minimum Optimization](machine_learning/sequential_minimum_optimization.py)
@@ -570,9 +573,7 @@
   * [Fermat Little Theorem](maths/fermat_little_theorem.py)
   * [Fibonacci](maths/fibonacci.py)
   * [Find Max](maths/find_max.py)
-  * [Find Max Recursion](maths/find_max_recursion.py)
   * [Find Min](maths/find_min.py)
-  * [Find Min Recursion](maths/find_min_recursion.py)
   * [Floor](maths/floor.py)
   * [Gamma](maths/gamma.py)
   * [Gamma Recursive](maths/gamma_recursive.py)
@@ -585,6 +586,7 @@
   * [Hardy Ramanujanalgo](maths/hardy_ramanujanalgo.py)
   * [Hexagonal Number](maths/hexagonal_number.py)
   * [Integration By Simpson Approx](maths/integration_by_simpson_approx.py)
+  * [Interquartile Range](maths/interquartile_range.py)
   * [Is Int Palindrome](maths/is_int_palindrome.py)
   * [Is Ip V4 Address Valid](maths/is_ip_v4_address_valid.py)
   * [Is Square Free](maths/is_square_free.py)
@@ -709,7 +711,6 @@
     * [Exponential Linear Unit](neural_network/activation_functions/exponential_linear_unit.py)
   * [Back Propagation Neural Network](neural_network/back_propagation_neural_network.py)
   * [Convolution Neural Network](neural_network/convolution_neural_network.py)
-  * [Input Data](neural_network/input_data.py)
   * [Perceptron](neural_network/perceptron.py)
   * [Simple Neural Network](neural_network/simple_neural_network.py)
 
@@ -740,7 +741,9 @@
   * [Tower Of Hanoi](other/tower_of_hanoi.py)
 
 ## Physics
+  * [Altitude Pressure](physics/altitude_pressure.py)
   * [Archimedes Principle](physics/archimedes_principle.py)
+  * [Basic Orbital Capture](physics/basic_orbital_capture.py)
   * [Casimir Effect](physics/casimir_effect.py)
   * [Centripetal Force](physics/centripetal_force.py)
   * [Grahams Law](physics/grahams_law.py)
@@ -1062,7 +1065,6 @@
   * [Q Fourier Transform](quantum/q_fourier_transform.py)
   * [Q Full Adder](quantum/q_full_adder.py)
   * [Quantum Entanglement](quantum/quantum_entanglement.py)
-  * [Quantum Random](quantum/quantum_random.py)
   * [Quantum Teleportation](quantum/quantum_teleportation.py)
   * [Ripple Adder Classic](quantum/ripple_adder_classic.py)
   * [Single Qubit Measure](quantum/single_qubit_measure.py)
@@ -1168,6 +1170,7 @@
   * [Is Pangram](strings/is_pangram.py)
   * [Is Spain National Id](strings/is_spain_national_id.py)
   * [Is Srilankan Phone Number](strings/is_srilankan_phone_number.py)
+  * [Is Valid Email Address](strings/is_valid_email_address.py)
   * [Jaro Winkler](strings/jaro_winkler.py)
   * [Join](strings/join.py)
   * [Knuth Morris Pratt](strings/knuth_morris_pratt.py)

README.md

@@ -13,7 +13,7 @@
     <img src="https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square" height="20" alt="Contributions Welcome">
   </a>
   <img src="https://img.shields.io/github/repo-size/TheAlgorithms/Python.svg?label=Repo%20size&style=flat-square" height="20">
-  <a href="https://discord.gg/c7MnfGFGa6">
+  <a href="https://the-algorithms.com/discord">
     <img src="https://img.shields.io/discord/808045925556682782.svg?logo=discord&colorB=7289DA&style=flat-square" height="20" alt="Discord chat">
   </a>
   <a href="https://gitter.im/TheAlgorithms/community">
@@ -42,7 +42,7 @@ Read through our [Contribution Guidelines](CONTRIBUTING.md) before you contribut
 
 ## Community Channels
 
-We are on [Discord](https://discord.gg/c7MnfGFGa6) and [Gitter](https://gitter.im/TheAlgorithms/community)! Community channels are a great way for you to ask questions and get help. Please join us!
+We are on [Discord](https://the-algorithms.com/discord) and [Gitter](https://gitter.im/TheAlgorithms/community)! Community channels are a great way for you to ask questions and get help. Please join us!
 
 ## List of Algorithms
 

cellular_automata/game_of_life.py

@@ -10,7 +10,7 @@ Python:
   - 3.5
 
 Usage:
-  - $python3 game_o_life <canvas_size:int>
+  - $python3 game_of_life <canvas_size:int>
 
 Game-Of-Life Rules:
 
@@ -52,7 +52,8 @@ def seed(canvas: list[list[bool]]) -> None:
 
 
 def run(canvas: list[list[bool]]) -> list[list[bool]]:
-    """This  function runs the rules of game through all points, and changes their
+    """
+    This function runs the rules of game through all points, and changes their
     status accordingly.(in the same canvas)
     @Args:
     --
@@ -60,7 +61,7 @@ def run(canvas: list[list[bool]]) -> list[list[bool]]:
 
     @returns:
     --
-    None
+    canvas of population after one step
     """
     current_canvas = np.array(canvas)
     next_gen_canvas = np.array(create_canvas(current_canvas.shape[0]))
@@ -70,10 +71,7 @@ def run(canvas: list[list[bool]]) -> list[list[bool]]:
                 pt, current_canvas[r - 1 : r + 2, c - 1 : c + 2]
             )
 
-    current_canvas = next_gen_canvas
-    del next_gen_canvas  # cleaning memory as we move on.
-    return_canvas: list[list[bool]] = current_canvas.tolist()
-    return return_canvas
+    return next_gen_canvas.tolist()
 
 
 def __judge_point(pt: bool, neighbours: list[list[bool]]) -> bool:

cellular_automata/wa_tor.py

@@ -0,0 +1,550 @@
+"""
+Wa-Tor algorithm (1984)
+
+@ https://en.wikipedia.org/wiki/Wa-Tor
+@ https://beltoforion.de/en/wator/
+@ https://beltoforion.de/en/wator/images/wator_medium.webm
+
+This solution aims to completely remove any systematic approach
+to the Wa-Tor planet, and utilise fully random methods.
+
+The constants are a working set that allows the Wa-Tor planet
+to result in one of the three possible results.
+"""
+
+from collections.abc import Callable
+from random import randint, shuffle
+from time import sleep
+from typing import Literal
+
+WIDTH = 50  # Width of the Wa-Tor planet
+HEIGHT = 50  # Height of the Wa-Tor planet
+
+PREY_INITIAL_COUNT = 30  # The initial number of prey entities
+PREY_REPRODUCTION_TIME = 5  # The chronons before reproducing
+
+PREDATOR_INITIAL_COUNT = 50  # The initial number of predator entities
+# The initial energy value of predator entities
+PREDATOR_INITIAL_ENERGY_VALUE = 15
+# The energy value provided when consuming prey
+PREDATOR_FOOD_VALUE = 5
+PREDATOR_REPRODUCTION_TIME = 20  # The chronons before reproducing
+
+MAX_ENTITIES = 500  # The max number of organisms on the board
+# The number of entities to delete from the unbalanced side
+DELETE_UNBALANCED_ENTITIES = 50
+
+
+class Entity:
+    """
+    Represents an entity (either prey or predator).
+
+    >>> e = Entity(True, coords=(0, 0))
+    >>> e.prey
+    True
+    >>> e.coords
+    (0, 0)
+    >>> e.alive
+    True
+    """
+
+    def __init__(self, prey: bool, coords: tuple[int, int]) -> None:
+        self.prey = prey
+        # The (row, col) pos of the entity
+        self.coords = coords
+
+        self.remaining_reproduction_time = (
+            PREY_REPRODUCTION_TIME if prey else PREDATOR_REPRODUCTION_TIME
+        )
+        self.energy_value = None if prey is True else PREDATOR_INITIAL_ENERGY_VALUE
+        self.alive = True
+
+    def reset_reproduction_time(self) -> None:
+        """
+        >>> e = Entity(True, coords=(0, 0))
+        >>> e.reset_reproduction_time()
+        >>> e.remaining_reproduction_time == PREY_REPRODUCTION_TIME
+        True
+        >>> e = Entity(False, coords=(0, 0))
+        >>> e.reset_reproduction_time()
+        >>> e.remaining_reproduction_time == PREDATOR_REPRODUCTION_TIME
+        True
+        """
+        self.remaining_reproduction_time = (
+            PREY_REPRODUCTION_TIME if self.prey is True else PREDATOR_REPRODUCTION_TIME
+        )
+
+    def __repr__(self) -> str:
+        """
+        >>> Entity(prey=True, coords=(1, 1))
+        Entity(prey=True, coords=(1, 1), remaining_reproduction_time=5)
+        >>> Entity(prey=False, coords=(2, 1))  # doctest: +NORMALIZE_WHITESPACE
+        Entity(prey=False, coords=(2, 1),
+        remaining_reproduction_time=20, energy_value=15)
+        """
+        repr_ = (
+            f"Entity(prey={self.prey}, coords={self.coords}, "
+            f"remaining_reproduction_time={self.remaining_reproduction_time}"
+        )
+        if self.energy_value is not None:
+            repr_ += f", energy_value={self.energy_value}"
+        return f"{repr_})"
+
+
+class WaTor:
+    """
+    Represents the main Wa-Tor algorithm.
+
+    :attr time_passed: A function that is called every time
+        time passes (a chronon) in order to visually display
+        the new Wa-Tor planet. The time_passed function can block
+        using time.sleep to slow the algorithm progression.
+
+    >>> wt = WaTor(10, 15)
+    >>> wt.width
+    10
+    >>> wt.height
+    15
+    >>> len(wt.planet)
+    15
+    >>> len(wt.planet[0])
+    10
+    >>> len(wt.get_entities()) == PREDATOR_INITIAL_COUNT + PREY_INITIAL_COUNT
+    True
+    """
+
+    time_passed: Callable[["WaTor", int], None] | None
+
+    def __init__(self, width: int, height: int) -> None:
+        self.width = width
+        self.height = height
+        self.time_passed = None
+
+        self.planet: list[list[Entity | None]] = [[None] * width for _ in range(height)]
+
+        # Populate planet with predators and prey randomly
+        for _ in range(PREY_INITIAL_COUNT):
+            self.add_entity(prey=True)
+        for _ in range(PREDATOR_INITIAL_COUNT):
+            self.add_entity(prey=False)
+        self.set_planet(self.planet)
+
+    def set_planet(self, planet: list[list[Entity | None]]) -> None:
+        """
+        Ease of access for testing
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> planet = [
+        ... [None, None, None],
+        ... [None, Entity(True, coords=(1, 1)), None]
+        ... ]
+        >>> wt.set_planet(planet)
+        >>> wt.planet == planet
+        True
+        >>> wt.width
+        3
+        >>> wt.height
+        2
+        """
+        self.planet = planet
+        self.width = len(planet[0])
+        self.height = len(planet)
+
+    def add_entity(self, prey: bool) -> None:
+        """
+        Adds an entity, making sure the entity does
+        not override another entity
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> wt.set_planet([[None, None], [None, None]])
+        >>> wt.add_entity(True)
+        >>> len(wt.get_entities())
+        1
+        >>> wt.add_entity(False)
+        >>> len(wt.get_entities())
+        2
+        """
+        while True:
+            row, col = randint(0, self.height - 1), randint(0, self.width - 1)
+            if self.planet[row][col] is None:
+                self.planet[row][col] = Entity(prey=prey, coords=(row, col))
+                return
+
+    def get_entities(self) -> list[Entity]:
+        """
+        Returns a list of all the entities within the planet.
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> len(wt.get_entities()) == PREDATOR_INITIAL_COUNT + PREY_INITIAL_COUNT
+        True
+        """
+        return [entity for column in self.planet for entity in column if entity]
+
+    def balance_predators_and_prey(self) -> None:
+        """
+        Balances predators and preys so that prey
+        can not dominate the predators, blocking up
+        space for them to reproduce.
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> for i in range(2000):
+        ...     row, col = i // HEIGHT, i % WIDTH
+        ...     wt.planet[row][col] = Entity(True, coords=(row, col))
+        >>> entities = len(wt.get_entities())
+        >>> wt.balance_predators_and_prey()
+        >>> len(wt.get_entities()) == entities
+        False
+        """
+        entities = self.get_entities()
+        shuffle(entities)
+
+        if len(entities) >= MAX_ENTITIES - MAX_ENTITIES / 10:
+            prey = [entity for entity in entities if entity.prey]
+            predators = [entity for entity in entities if not entity.prey]
+
+            prey_count, predator_count = len(prey), len(predators)
+
+            entities_to_purge = (
+                prey[:DELETE_UNBALANCED_ENTITIES]
+                if prey_count > predator_count
+                else predators[:DELETE_UNBALANCED_ENTITIES]
+            )
+            for entity in entities_to_purge:
+                self.planet[entity.coords[0]][entity.coords[1]] = None
+
+    def get_surrounding_prey(self, entity: Entity) -> list[Entity]:
+        """
+        Returns all the prey entities around (N, S, E, W) a predator entity.
+
+        Subtly different to the try_to_move_to_unoccupied square.
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> wt.set_planet([
+        ... [None, Entity(True, (0, 1)), None],
+        ... [None, Entity(False, (1, 1)), None],
+        ... [None, Entity(True, (2, 1)), None]])
+        >>> wt.get_surrounding_prey(
+        ... Entity(False, (1, 1)))  # doctest: +NORMALIZE_WHITESPACE
+        [Entity(prey=True, coords=(0, 1), remaining_reproduction_time=5),
+        Entity(prey=True, coords=(2, 1), remaining_reproduction_time=5)]
+        >>> wt.set_planet([[Entity(False, (0, 0))]])
+        >>> wt.get_surrounding_prey(Entity(False, (0, 0)))
+        []
+        >>> wt.set_planet([
+        ... [Entity(True, (0, 0)), Entity(False, (1, 0)), Entity(False, (2, 0))],
+        ... [None, Entity(False, (1, 1)), Entity(True, (2, 1))],
+        ... [None, None, None]])
+        >>> wt.get_surrounding_prey(Entity(False, (1, 0)))
+        [Entity(prey=True, coords=(0, 0), remaining_reproduction_time=5)]
+        """
+        row, col = entity.coords
+        adjacent: list[tuple[int, int]] = [
+            (row - 1, col),  # North
+            (row + 1, col),  # South
+            (row, col - 1),  # West
+            (row, col + 1),  # East
+        ]
+
+        return [
+            ent
+            for r, c in adjacent
+            if 0 <= r < self.height
+            and 0 <= c < self.width
+            and (ent := self.planet[r][c]) is not None
+            and ent.prey
+        ]
+
+    def move_and_reproduce(
+        self, entity: Entity, direction_orders: list[Literal["N", "E", "S", "W"]]
+    ) -> None:
+        """
+        Attempts to move to an unoccupied neighbouring square
+        in either of the four directions (North, South, East, West).
+        If the move was successful and the remaining_reproduction time is
+        equal to 0, then a new prey or predator can also be created
+        in the previous square.
+
+        :param direction_orders: Ordered list (like priority queue) depicting
+                            order to attempt to move. Removes any systematic
+                            approach of checking neighbouring squares.
+
+        >>> planet = [
+        ... [None, None, None],
+        ... [None, Entity(True, coords=(1, 1)), None],
+        ... [None, None, None]
+        ... ]
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> wt.set_planet(planet)
+        >>> wt.move_and_reproduce(Entity(True, coords=(1, 1)), direction_orders=["N"])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[None, Entity(prey=True, coords=(0, 1), remaining_reproduction_time=4), None],
+        [None, None, None],
+        [None, None, None]]
+        >>> wt.planet[0][0] = Entity(True, coords=(0, 0))
+        >>> wt.move_and_reproduce(Entity(True, coords=(0, 1)),
+        ... direction_orders=["N", "W", "E", "S"])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[Entity(prey=True, coords=(0, 0), remaining_reproduction_time=5), None,
+        Entity(prey=True, coords=(0, 2), remaining_reproduction_time=4)],
+        [None, None, None],
+        [None, None, None]]
+        >>> wt.planet[0][1] = wt.planet[0][2]
+        >>> wt.planet[0][2] = None
+        >>> wt.move_and_reproduce(Entity(True, coords=(0, 1)),
+        ... direction_orders=["N", "W", "S", "E"])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[Entity(prey=True, coords=(0, 0), remaining_reproduction_time=5), None, None],
+        [None, Entity(prey=True, coords=(1, 1), remaining_reproduction_time=4), None],
+        [None, None, None]]
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> reproducable_entity = Entity(False, coords=(0, 1))
+        >>> reproducable_entity.remaining_reproduction_time = 0
+        >>> wt.planet = [[None, reproducable_entity]]
+        >>> wt.move_and_reproduce(reproducable_entity,
+        ... direction_orders=["N", "W", "S", "E"])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[Entity(prey=False, coords=(0, 0),
+        remaining_reproduction_time=20, energy_value=15),
+        Entity(prey=False, coords=(0, 1), remaining_reproduction_time=20,
+        energy_value=15)]]
+        """
+        row, col = coords = entity.coords
+
+        adjacent_squares: dict[Literal["N", "E", "S", "W"], tuple[int, int]] = {
+            "N": (row - 1, col),  # North
+            "S": (row + 1, col),  # South
+            "W": (row, col - 1),  # West
+            "E": (row, col + 1),  # East
+        }
+        # Weight adjacent locations
+        adjacent: list[tuple[int, int]] = []
+        for order in direction_orders:
+            adjacent.append(adjacent_squares[order])
+
+        for r, c in adjacent:
+            if (
+                0 <= r < self.height
+                and 0 <= c < self.width
+                and self.planet[r][c] is None
+            ):
+                # Move entity to empty adjacent square
+                self.planet[r][c] = entity
+                self.planet[row][col] = None
+                entity.coords = (r, c)
+                break
+
+        # (2.) See if it possible to reproduce in previous square
+        if coords != entity.coords and entity.remaining_reproduction_time <= 0:
+            # Check if the entities on the planet is less than the max limit
+            if len(self.get_entities()) < MAX_ENTITIES:
+                # Reproduce in previous square
+                self.planet[row][col] = Entity(prey=entity.prey, coords=coords)
+                entity.reset_reproduction_time()
+        else:
+            entity.remaining_reproduction_time -= 1
+
+    def perform_prey_actions(
+        self, entity: Entity, direction_orders: list[Literal["N", "E", "S", "W"]]
+    ) -> None:
+        """
+        Performs the actions for a prey entity
+
+        For prey the rules are:
+          1. At each chronon, a prey moves randomly to one of the adjacent unoccupied
+            squares. If there are no free squares, no movement takes place.
+          2. Once a prey has survived a certain number of chronons it may reproduce.
+            This is done as it moves to a neighbouring square,
+            leaving behind a new prey in its old position.
+            Its reproduction time is also reset to zero.
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> reproducable_entity = Entity(True, coords=(0, 1))
+        >>> reproducable_entity.remaining_reproduction_time = 0
+        >>> wt.planet = [[None, reproducable_entity]]
+        >>> wt.perform_prey_actions(reproducable_entity,
+        ... direction_orders=["N", "W", "S", "E"])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[Entity(prey=True, coords=(0, 0), remaining_reproduction_time=5),
+        Entity(prey=True, coords=(0, 1), remaining_reproduction_time=5)]]
+        """
+        self.move_and_reproduce(entity, direction_orders)
+
+    def perform_predator_actions(
+        self,
+        entity: Entity,
+        occupied_by_prey_coords: tuple[int, int] | None,
+        direction_orders: list[Literal["N", "E", "S", "W"]],
+    ) -> None:
+        """
+        Performs the actions for a predator entity
+
+        :param occupied_by_prey_coords: Move to this location if there is prey there
+
+        For predators the rules are:
+          1. At each chronon, a predator moves randomly to an adjacent square occupied
+            by a prey. If there is none, the predator moves to a random adjacent
+            unoccupied square. If there are no free squares, no movement takes place.
+          2. At each chronon, each predator is deprived of a unit of energy.
+          3. Upon reaching zero energy, a predator dies.
+          4. If a predator moves to a square occupied by a prey,
+            it eats the prey and earns a certain amount of energy.
+          5. Once a predator has survived a certain number of chronons
+          it may reproduce in exactly the same way as the prey.
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> wt.set_planet([[Entity(True, coords=(0, 0)), Entity(False, coords=(0, 1))]])
+        >>> wt.perform_predator_actions(Entity(False, coords=(0, 1)), (0, 0), [])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[Entity(prey=False, coords=(0, 0),
+        remaining_reproduction_time=20, energy_value=19), None]]
+        """
+        assert entity.energy_value is not None  # [type checking]
+
+        # (3.) If the entity has 0 energy, it will die
+        if entity.energy_value == 0:
+            self.planet[entity.coords[0]][entity.coords[1]] = None
+            return
+
+        # (1.) Move to entity if possible
+        if occupied_by_prey_coords is not None:
+            # Kill the prey
+            prey = self.planet[occupied_by_prey_coords[0]][occupied_by_prey_coords[1]]
+            assert prey is not None
+            prey.alive = False
+
+            # Move onto prey
+            self.planet[occupied_by_prey_coords[0]][occupied_by_prey_coords[1]] = entity
+            self.planet[entity.coords[0]][entity.coords[1]] = None
+
+            entity.coords = occupied_by_prey_coords
+            # (4.) Eats the prey and earns energy
+            entity.energy_value += PREDATOR_FOOD_VALUE
+        else:
+            # (5.) If it has survived the certain number of chronons it will also
+            # reproduce in this function
+            self.move_and_reproduce(entity, direction_orders)
+
+        # (2.) Each chronon, the predator is deprived of a unit of energy
+        entity.energy_value -= 1
+
+    def run(self, *, iteration_count: int) -> None:
+        """
+        Emulate time passing by looping iteration_count times
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> wt.run(iteration_count=PREDATOR_INITIAL_ENERGY_VALUE - 1)
+        >>> len(list(filter(lambda entity: entity.prey is False,
+        ... wt.get_entities()))) >= PREDATOR_INITIAL_COUNT
+        True
+        """
+        for iter_num in range(iteration_count):
+            # Generate list of all entities in order to randomly
+            # pop an entity at a time to simulate true randomness
+            # This removes the systematic approach of iterating
+            # through each entity width by height
+            all_entities = self.get_entities()
+
+            for __ in range(len(all_entities)):
+                entity = all_entities.pop(randint(0, len(all_entities) - 1))
+                if entity.alive is False:
+                    continue
+
+                directions: list[Literal["N", "E", "S", "W"]] = ["N", "E", "S", "W"]
+                shuffle(directions)  # Randomly shuffle directions
+
+                if entity.prey:
+                    self.perform_prey_actions(entity, directions)
+                else:
+                    # Create list of surrounding prey
+                    surrounding_prey = self.get_surrounding_prey(entity)
+                    surrounding_prey_coords = None
+
+                    if surrounding_prey:
+                        # Again, randomly shuffle directions
+                        shuffle(surrounding_prey)
+                        surrounding_prey_coords = surrounding_prey[0].coords
+
+                    self.perform_predator_actions(
+                        entity, surrounding_prey_coords, directions
+                    )
+
+            # Balance out the predators and prey
+            self.balance_predators_and_prey()
+
+            if self.time_passed is not None:
+                # Call time_passed function for Wa-Tor planet
+                # visualisation in a terminal or a graph.
+                self.time_passed(self, iter_num)
+
+
+def visualise(wt: WaTor, iter_number: int, *, colour: bool = True) -> None:
+    """
+    Visually displays the Wa-Tor planet using
+    an ascii code in terminal to clear and re-print
+    the Wa-Tor planet at intervals.
+
+    Uses ascii colour codes to colourfully display
+    the predators and prey.
+
+    (0x60f197) Prey = #
+    (0xfffff) Predator = x
+
+    >>> wt = WaTor(30, 30)
+    >>> wt.set_planet([
+    ... [Entity(True, coords=(0, 0)), Entity(False, coords=(0, 1)), None],
+    ... [Entity(False, coords=(1, 0)), None, Entity(False, coords=(1, 2))],
+    ... [None, Entity(True, coords=(2, 1)), None]
+    ... ])
+    >>> visualise(wt, 0, colour=False)  # doctest: +NORMALIZE_WHITESPACE
+    #  x  .
+    x  .  x
+    .  #  .
+    <BLANKLINE>
+    Iteration: 0 | Prey count: 2 | Predator count: 3 |
+    """
+    if colour:
+        __import__("os").system("")
+        print("\x1b[0;0H\x1b[2J\x1b[?25l")
+
+    reprint = "\x1b[0;0H" if colour else ""
+    ansi_colour_end = "\x1b[0m " if colour else " "
+
+    planet = wt.planet
+    output = ""
+
+    # Iterate over every entity in the planet
+    for row in planet:
+        for entity in row:
+            if entity is None:
+                output += " . "
+            else:
+                if colour is True:
+                    output += (
+                        "\x1b[38;2;96;241;151m"
+                        if entity.prey
+                        else "\x1b[38;2;255;255;15m"
+                    )
+                output += f" {'#' if entity.prey else 'x'}{ansi_colour_end}"
+
+        output += "\n"
+
+    entities = wt.get_entities()
+    prey_count = sum(entity.prey for entity in entities)
+
+    print(
+        f"{output}\n Iteration: {iter_number} | Prey count: {prey_count} | "
+        f"Predator count: {len(entities) - prey_count} | {reprint}"
+    )
+    # Block the thread to be able to visualise seeing the algorithm
+    sleep(0.05)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+
+    wt = WaTor(WIDTH, HEIGHT)
+    wt.time_passed = visualise
+    wt.run(iteration_count=100_000)

ciphers/diffie_hellman.py

@@ -10,13 +10,13 @@ primes = {
     5: {
         "prime": int(
             "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
-            + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
-            + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
-            + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
-            + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
-            + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
-            + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            + "670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF",
+            "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+            "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+            "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+            "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+            "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+            "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            "670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF",
             base=16,
         ),
         "generator": 2,
@@ -25,16 +25,16 @@ primes = {
     14: {
         "prime": int(
             "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
-            + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
-            + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
-            + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
-            + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
-            + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
-            + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
-            + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
-            + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
-            + "15728E5A8AACAA68FFFFFFFFFFFFFFFF",
+            "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+            "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+            "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+            "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+            "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+            "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+            "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+            "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+            "15728E5A8AACAA68FFFFFFFFFFFFFFFF",
             base=16,
         ),
         "generator": 2,
@@ -43,21 +43,21 @@ primes = {
     15: {
         "prime": int(
             "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
-            + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
-            + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
-            + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
-            + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
-            + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
-            + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
-            + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
-            + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
-            + "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
-            + "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
-            + "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
-            + "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
-            + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
-            + "43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF",
+            "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+            "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+            "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+            "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+            "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+            "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+            "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+            "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+            "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
+            "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
+            "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
+            "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+            "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
+            "43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF",
             base=16,
         ),
         "generator": 2,
@@ -66,27 +66,27 @@ primes = {
     16: {
         "prime": int(
             "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
-            + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
-            + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
-            + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
-            + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
-            + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
-            + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
-            + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
-            + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
-            + "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
-            + "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
-            + "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
-            + "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
-            + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
-            + "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
-            + "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
-            + "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
-            + "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
-            + "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
-            + "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199"
-            + "FFFFFFFFFFFFFFFF",
+            "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+            "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+            "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+            "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+            "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+            "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+            "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+            "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+            "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
+            "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
+            "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
+            "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+            "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
+            "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
+            "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
+            "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
+            "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
+            "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
+            "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199"
+            "FFFFFFFFFFFFFFFF",
             base=16,
         ),
         "generator": 2,
@@ -95,33 +95,33 @@ primes = {
     17: {
         "prime": int(
             "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E08"
-            + "8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B"
-            + "302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9"
-            + "A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6"
-            + "49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8"
-            + "FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C"
-            + "180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
-            + "3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D"
-            + "04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D"
-            + "B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226"
-            + "1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
-            + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC"
-            + "E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26"
-            + "99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB"
-            + "04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2"
-            + "233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127"
-            + "D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
-            + "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406"
-            + "AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918"
-            + "DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B33205151"
-            + "2BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03"
-            + "F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97F"
-            + "BEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
-            + "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58B"
-            + "B7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632"
-            + "387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E"
-            + "6DCC4024FFFFFFFFFFFFFFFF",
+            "8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B"
+            "302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9"
+            "A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6"
+            "49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8"
+            "FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C"
+            "180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
+            "3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D"
+            "04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D"
+            "B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226"
+            "1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+            "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC"
+            "E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26"
+            "99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB"
+            "04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2"
+            "233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127"
+            "D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
+            "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406"
+            "AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918"
+            "DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B33205151"
+            "2BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03"
+            "F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97F"
+            "BEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
+            "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58B"
+            "B7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632"
+            "387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E"
+            "6DCC4024FFFFFFFFFFFFFFFF",
             base=16,
         ),
         "generator": 2,
@@ -130,48 +130,48 @@ primes = {
     18: {
         "prime": int(
             "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
-            + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
-            + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
-            + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
-            + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
-            + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
-            + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
-            + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
-            + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
-            + "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
-            + "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
-            + "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
-            + "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
-            + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
-            + "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
-            + "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
-            + "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
-            + "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
-            + "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
-            + "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
-            + "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BD"
-            + "F8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831"
-            + "179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1B"
-            + "DB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF"
-            + "5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6"
-            + "D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F3"
-            + "23A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
-            + "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE328"
-            + "06A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55C"
-            + "DA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE"
-            + "12BF2D5B0B7474D6E694F91E6DBE115974A3926F12FEE5E4"
-            + "38777CB6A932DF8CD8BEC4D073B931BA3BC832B68D9DD300"
-            + "741FA7BF8AFC47ED2576F6936BA424663AAB639C5AE4F568"
-            + "3423B4742BF1C978238F16CBE39D652DE3FDB8BEFC848AD9"
-            + "22222E04A4037C0713EB57A81A23F0C73473FC646CEA306B"
-            + "4BCBC8862F8385DDFA9D4B7FA2C087E879683303ED5BDD3A"
-            + "062B3CF5B3A278A66D2A13F83F44F82DDF310EE074AB6A36"
-            + "4597E899A0255DC164F31CC50846851DF9AB48195DED7EA1"
-            + "B1D510BD7EE74D73FAF36BC31ECFA268359046F4EB879F92"
-            + "4009438B481C6CD7889A002ED5EE382BC9190DA6FC026E47"
-            + "9558E4475677E9AA9E3050E2765694DFC81F56E880B96E71"
-            + "60C980DD98EDD3DFFFFFFFFFFFFFFFFF",
+            "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+            "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+            "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+            "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+            "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+            "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+            "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+            "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+            "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
+            "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
+            "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
+            "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+            "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
+            "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
+            "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
+            "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
+            "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
+            "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
+            "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
+            "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BD"
+            "F8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831"
+            "179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1B"
+            "DB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF"
+            "5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6"
+            "D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F3"
+            "23A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
+            "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE328"
+            "06A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55C"
+            "DA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE"
+            "12BF2D5B0B7474D6E694F91E6DBE115974A3926F12FEE5E4"
+            "38777CB6A932DF8CD8BEC4D073B931BA3BC832B68D9DD300"
+            "741FA7BF8AFC47ED2576F6936BA424663AAB639C5AE4F568"
+            "3423B4742BF1C978238F16CBE39D652DE3FDB8BEFC848AD9"
+            "22222E04A4037C0713EB57A81A23F0C73473FC646CEA306B"
+            "4BCBC8862F8385DDFA9D4B7FA2C087E879683303ED5BDD3A"
+            "062B3CF5B3A278A66D2A13F83F44F82DDF310EE074AB6A36"
+            "4597E899A0255DC164F31CC50846851DF9AB48195DED7EA1"
+            "B1D510BD7EE74D73FAF36BC31ECFA268359046F4EB879F92"
+            "4009438B481C6CD7889A002ED5EE382BC9190DA6FC026E47"
+            "9558E4475677E9AA9E3050E2765694DFC81F56E880B96E71"
+            "60C980DD98EDD3DFFFFFFFFFFFFFFFFF",
             base=16,
         ),
         "generator": 2,

compression/burrows_wheeler.py

@@ -150,7 +150,7 @@ def reverse_bwt(bwt_string: str, idx_original_string: int) -> str:
         raise ValueError("The parameter idx_original_string must not be lower than 0.")
     if idx_original_string >= len(bwt_string):
         raise ValueError(
-            "The parameter idx_original_string must be lower than" " len(bwt_string)."
+            "The parameter idx_original_string must be lower than len(bwt_string)."
         )
 
     ordered_rotations = [""] * len(bwt_string)

conversions/length_conversion.py

@@ -22,9 +22,13 @@ REFERENCES :
 -> Wikipedia reference: https://en.wikipedia.org/wiki/Millimeter
 """
 
-from collections import namedtuple
+from typing import NamedTuple
+
+
+class FromTo(NamedTuple):
+    from_factor: float
+    to_factor: float
 
-from_to = namedtuple("from_to", "from_ to")
 
 TYPE_CONVERSION = {
     "millimeter": "mm",
@@ -40,14 +44,14 @@ TYPE_CONVERSION = {
 }
 
 METRIC_CONVERSION = {
-    "mm": from_to(0.001, 1000),
-    "cm": from_to(0.01, 100),
-    "m": from_to(1, 1),
-    "km": from_to(1000, 0.001),
-    "in": from_to(0.0254, 39.3701),
-    "ft": from_to(0.3048, 3.28084),
-    "yd": from_to(0.9144, 1.09361),
-    "mi": from_to(1609.34, 0.000621371),
+    "mm": FromTo(0.001, 1000),
+    "cm": FromTo(0.01, 100),
+    "m": FromTo(1, 1),
+    "km": FromTo(1000, 0.001),
+    "in": FromTo(0.0254, 39.3701),
+    "ft": FromTo(0.3048, 3.28084),
+    "yd": FromTo(0.9144, 1.09361),
+    "mi": FromTo(1609.34, 0.000621371),
 }
 
 
@@ -115,7 +119,11 @@ def length_conversion(value: float, from_type: str, to_type: str) -> float:
             f"Conversion abbreviations are: {', '.join(METRIC_CONVERSION)}"
         )
         raise ValueError(msg)
-    return value * METRIC_CONVERSION[new_from].from_ * METRIC_CONVERSION[new_to].to
+    return (
+        value
+        * METRIC_CONVERSION[new_from].from_factor
+        * METRIC_CONVERSION[new_to].to_factor
+    )
 
 
 if __name__ == "__main__":

conversions/pressure_conversions.py

@@ -19,19 +19,23 @@ REFERENCES :
 -> https://www.unitconverters.net/pressure-converter.html
 """
 
-from collections import namedtuple
+from typing import NamedTuple
+
+
+class FromTo(NamedTuple):
+    from_factor: float
+    to_factor: float
 
-from_to = namedtuple("from_to", "from_ to")
 
 PRESSURE_CONVERSION = {
-    "atm": from_to(1, 1),
-    "pascal": from_to(0.0000098, 101325),
-    "bar": from_to(0.986923, 1.01325),
-    "kilopascal": from_to(0.00986923, 101.325),
-    "megapascal": from_to(9.86923, 0.101325),
-    "psi": from_to(0.068046, 14.6959),
-    "inHg": from_to(0.0334211, 29.9213),
-    "torr": from_to(0.00131579, 760),
+    "atm": FromTo(1, 1),
+    "pascal": FromTo(0.0000098, 101325),
+    "bar": FromTo(0.986923, 1.01325),
+    "kilopascal": FromTo(0.00986923, 101.325),
+    "megapascal": FromTo(9.86923, 0.101325),
+    "psi": FromTo(0.068046, 14.6959),
+    "inHg": FromTo(0.0334211, 29.9213),
+    "torr": FromTo(0.00131579, 760),
 }
 
 
@@ -71,7 +75,9 @@ def pressure_conversion(value: float, from_type: str, to_type: str) -> float:
             + ", ".join(PRESSURE_CONVERSION)
         )
     return (
-        value * PRESSURE_CONVERSION[from_type].from_ * PRESSURE_CONVERSION[to_type].to
+        value
+        * PRESSURE_CONVERSION[from_type].from_factor
+        * PRESSURE_CONVERSION[to_type].to_factor
     )
 
 

conversions/volume_conversions.py

@@ -18,18 +18,22 @@ REFERENCES :
 -> Wikipedia reference: https://en.wikipedia.org/wiki/Cup_(unit)
 """
 
-from collections import namedtuple
+from typing import NamedTuple
+
+
+class FromTo(NamedTuple):
+    from_factor: float
+    to_factor: float
 
-from_to = namedtuple("from_to", "from_ to")
 
 METRIC_CONVERSION = {
-    "cubicmeter": from_to(1, 1),
-    "litre": from_to(0.001, 1000),
-    "kilolitre": from_to(1, 1),
-    "gallon": from_to(0.00454, 264.172),
-    "cubicyard": from_to(0.76455, 1.30795),
-    "cubicfoot": from_to(0.028, 35.3147),
-    "cup": from_to(0.000236588, 4226.75),
+    "cubic meter": FromTo(1, 1),
+    "litre": FromTo(0.001, 1000),
+    "kilolitre": FromTo(1, 1),
+    "gallon": FromTo(0.00454, 264.172),
+    "cubic yard": FromTo(0.76455, 1.30795),
+    "cubic foot": FromTo(0.028, 35.3147),
+    "cup": FromTo(0.000236588, 4226.75),
 }
 
 
@@ -66,7 +70,11 @@ def volume_conversion(value: float, from_type: str, to_type: str) -> float:
             f"Invalid 'to_type' value: {to_type!r}.  Supported values are:\n"
             + ", ".join(METRIC_CONVERSION)
         )
-    return value * METRIC_CONVERSION[from_type].from_ * METRIC_CONVERSION[to_type].to
+    return (
+        value
+        * METRIC_CONVERSION[from_type].from_factor
+        * METRIC_CONVERSION[to_type].to_factor
+    )
 
 
 if __name__ == "__main__":

data_structures/binary_tree/binary_tree_traversals.py

@@ -58,6 +58,19 @@ def inorder(root: Node | None) -> list[int]:
     return [*inorder(root.left), root.data, *inorder(root.right)] if root else []
 
 
+def reverse_inorder(root: Node | None) -> list[int]:
+    """
+    Reverse in-order traversal visits right subtree, root node, left subtree.
+    >>> reverse_inorder(make_tree())
+    [3, 1, 5, 2, 4]
+    """
+    return (
+        [*reverse_inorder(root.right), root.data, *reverse_inorder(root.left)]
+        if root
+        else []
+    )
+
+
 def height(root: Node | None) -> int:
     """
     Recursive function for calculating the height of the binary tree.
@@ -161,15 +174,12 @@ def zigzag(root: Node | None) -> Sequence[Node | None] | list[Any]:
 
 
 def main() -> None:  # Main function for testing.
-    """
-    Create binary tree.
-    """
+    # Create binary tree.
     root = make_tree()
-    """
-    All Traversals of the binary are as follows:
-    """
 
+    # All Traversals of the binary are as follows:
     print(f"In-order Traversal: {inorder(root)}")
+    print(f"Reverse In-order Traversal: {reverse_inorder(root)}")
     print(f"Pre-order Traversal: {preorder(root)}")
     print(f"Post-order Traversal: {postorder(root)}", "\n")
 

data_structures/binary_tree/distribute_coins.py

@@ -39,8 +39,8 @@ Space: O(1)
 
 from __future__ import annotations
 
-from collections import namedtuple
 from dataclasses import dataclass
+from typing import NamedTuple
 
 
 @dataclass
@@ -50,7 +50,9 @@ class TreeNode:
     right: TreeNode | None = None
 
 
-CoinsDistribResult = namedtuple("CoinsDistribResult", "moves excess")
+class CoinsDistribResult(NamedTuple):
+    moves: int
+    excess: int
 
 
 def distribute_coins(root: TreeNode | None) -> int:
@@ -79,7 +81,7 @@ def distribute_coins(root: TreeNode | None) -> int:
     # Validation
     def count_nodes(node: TreeNode | None) -> int:
         """
-        >>> count_nodes(None):
+        >>> count_nodes(None)
         0
         """
         if node is None:
@@ -89,7 +91,7 @@ def distribute_coins(root: TreeNode | None) -> int:
 
     def count_coins(node: TreeNode | None) -> int:
         """
-        >>> count_coins(None):
+        >>> count_coins(None)
         0
         """
         if node is None:

data_structures/binary_tree/segment_tree.py

@@ -7,6 +7,7 @@ class SegmentTree:
         self.st = [0] * (
             4 * self.N
         )  # approximate the overall size of segment tree with array N
+        if self.N:
             self.build(1, 0, self.N - 1)
 
     def left(self, idx):

data_structures/queue/queue_by_list.py

@@ -0,0 +1,141 @@
+"""Queue represented by a Python list"""
+
+from collections.abc import Iterable
+from typing import Generic, TypeVar
+
+_T = TypeVar("_T")
+
+
+class QueueByList(Generic[_T]):
+    def __init__(self, iterable: Iterable[_T] | None = None) -> None:
+        """
+        >>> QueueByList()
+        Queue(())
+        >>> QueueByList([10, 20, 30])
+        Queue((10, 20, 30))
+        >>> QueueByList((i**2 for i in range(1, 4)))
+        Queue((1, 4, 9))
+        """
+        self.entries: list[_T] = list(iterable or [])
+
+    def __len__(self) -> int:
+        """
+        >>> len(QueueByList())
+        0
+        >>> from string import ascii_lowercase
+        >>> len(QueueByList(ascii_lowercase))
+        26
+        >>> queue = QueueByList()
+        >>> for i in range(1, 11):
+        ...     queue.put(i)
+        >>> len(queue)
+        10
+        >>> for i in range(2):
+        ...   queue.get()
+        1
+        2
+        >>> len(queue)
+        8
+        """
+
+        return len(self.entries)
+
+    def __repr__(self) -> str:
+        """
+        >>> queue = QueueByList()
+        >>> queue
+        Queue(())
+        >>> str(queue)
+        'Queue(())'
+        >>> queue.put(10)
+        >>> queue
+        Queue((10,))
+        >>> queue.put(20)
+        >>> queue.put(30)
+        >>> queue
+        Queue((10, 20, 30))
+        """
+
+        return f"Queue({tuple(self.entries)})"
+
+    def put(self, item: _T) -> None:
+        """Put `item` to the Queue
+
+        >>> queue = QueueByList()
+        >>> queue.put(10)
+        >>> queue.put(20)
+        >>> len(queue)
+        2
+        >>> queue
+        Queue((10, 20))
+        """
+
+        self.entries.append(item)
+
+    def get(self) -> _T:
+        """
+        Get `item` from the Queue
+
+        >>> queue = QueueByList((10, 20, 30))
+        >>> queue.get()
+        10
+        >>> queue.put(40)
+        >>> queue.get()
+        20
+        >>> queue.get()
+        30
+        >>> len(queue)
+        1
+        >>> queue.get()
+        40
+        >>> queue.get()
+        Traceback (most recent call last):
+            ...
+        IndexError: Queue is empty
+        """
+
+        if not self.entries:
+            raise IndexError("Queue is empty")
+        return self.entries.pop(0)
+
+    def rotate(self, rotation: int) -> None:
+        """Rotate the items of the Queue `rotation` times
+
+        >>> queue = QueueByList([10, 20, 30, 40])
+        >>> queue
+        Queue((10, 20, 30, 40))
+        >>> queue.rotate(1)
+        >>> queue
+        Queue((20, 30, 40, 10))
+        >>> queue.rotate(2)
+        >>> queue
+        Queue((40, 10, 20, 30))
+        """
+
+        put = self.entries.append
+        get = self.entries.pop
+
+        for _ in range(rotation):
+            put(get(0))
+
+    def get_front(self) -> _T:
+        """Get the front item from the Queue
+
+        >>> queue = QueueByList((10, 20, 30))
+        >>> queue.get_front()
+        10
+        >>> queue
+        Queue((10, 20, 30))
+        >>> queue.get()
+        10
+        >>> queue.get_front()
+        20
+        """
+
+        return self.entries[0]
+
+
+if __name__ == "__main__":
+    from doctest import testmod
+
+    testmod()

data_structures/queue/queue_on_list.py

@@ -1,52 +0,0 @@
-"""Queue represented by a Python list"""
-
-
-class Queue:
-    def __init__(self):
-        self.entries = []
-        self.length = 0
-        self.front = 0
-
-    def __str__(self):
-        printed = "<" + str(self.entries)[1:-1] + ">"
-        return printed
-
-    """Enqueues {@code item}
-    @param item
-        item to enqueue"""
-
-    def put(self, item):
-        self.entries.append(item)
-        self.length = self.length + 1
-
-    """Dequeues {@code item}
-    @requirement: |self.length| > 0
-    @return dequeued
-        item that was dequeued"""
-
-    def get(self):
-        self.length = self.length - 1
-        dequeued = self.entries[self.front]
-        # self.front-=1
-        # self.entries = self.entries[self.front:]
-        self.entries = self.entries[1:]
-        return dequeued
-
-    """Rotates the queue {@code rotation} times
-    @param rotation
-        number of times to rotate queue"""
-
-    def rotate(self, rotation):
-        for _ in range(rotation):
-            self.put(self.get())
-
-    """Enqueues {@code item}
-    @return item at front of self.entries"""
-
-    def get_front(self):
-        return self.entries[0]
-
-    """Returns the length of this.entries"""
-
-    def size(self):
-        return self.length

data_structures/stacks/infix_to_postfix_conversion.py

@@ -4,9 +4,26 @@ https://en.wikipedia.org/wiki/Reverse_Polish_notation
 https://en.wikipedia.org/wiki/Shunting-yard_algorithm
 """
 
+from typing import Literal
+
 from .balanced_parentheses import balanced_parentheses
 from .stack import Stack
 
+PRECEDENCES: dict[str, int] = {
+    "+": 1,
+    "-": 1,
+    "*": 2,
+    "/": 2,
+    "^": 3,
+}
+ASSOCIATIVITIES: dict[str, Literal["LR", "RL"]] = {
+    "+": "LR",
+    "-": "LR",
+    "*": "LR",
+    "/": "LR",
+    "^": "RL",
+}
+
 
 def precedence(char: str) -> int:
     """
@@ -14,7 +31,15 @@ def precedence(char: str) -> int:
     order of operation.
     https://en.wikipedia.org/wiki/Order_of_operations
     """
-    return {"+": 1, "-": 1, "*": 2, "/": 2, "^": 3}.get(char, -1)
+    return PRECEDENCES.get(char, -1)
+
+
+def associativity(char: str) -> Literal["LR", "RL"]:
+    """
+    Return the associativity of the operator `char`.
+    https://en.wikipedia.org/wiki/Operator_associativity
+    """
+    return ASSOCIATIVITIES[char]
 
 
 def infix_to_postfix(expression_str: str) -> str:
@@ -35,6 +60,8 @@ def infix_to_postfix(expression_str: str) -> str:
     'a b c * + d e * f + g * +'
     >>> infix_to_postfix("x^y/(5*z)+2")
     'x y ^ 5 z * / 2 +'
+    >>> infix_to_postfix("2^3^2")
+    '2 3 2 ^ ^'
     """
     if not balanced_parentheses(expression_str):
         raise ValueError("Mismatched parentheses")
@@ -50,9 +77,26 @@ def infix_to_postfix(expression_str: str) -> str:
                 postfix.append(stack.pop())
             stack.pop()
         else:
-            while not stack.is_empty() and precedence(char) <= precedence(stack.peek()):
-                postfix.append(stack.pop())
+            while True:
+                if stack.is_empty():
                     stack.push(char)
+                    break
+
+                char_precedence = precedence(char)
+                tos_precedence = precedence(stack.peek())
+
+                if char_precedence > tos_precedence:
+                    stack.push(char)
+                    break
+                if char_precedence < tos_precedence:
+                    postfix.append(stack.pop())
+                    continue
+                # Precedences are equal
+                if associativity(char) == "RL":
+                    stack.push(char)
+                    break
+                postfix.append(stack.pop())
+
     while not stack.is_empty():
         postfix.append(stack.pop())
     return " ".join(postfix)

digital_image_processing/dithering/burkes.py

@@ -39,9 +39,18 @@ class Burkes:
     def get_greyscale(cls, blue: int, green: int, red: int) -> float:
         """
         >>> Burkes.get_greyscale(3, 4, 5)
-        3.753
+        4.185
+        >>> Burkes.get_greyscale(0, 0, 0)
+        0.0
+        >>> Burkes.get_greyscale(255, 255, 255)
+        255.0
         """
-        return 0.114 * blue + 0.587 * green + 0.2126 * red
+        """
+        Formula from https://en.wikipedia.org/wiki/HSL_and_HSV
+        cf Lightness section, and Fig 13c.
+        We use the first of four possible.
+        """
+        return 0.114 * blue + 0.587 * green + 0.299 * red
 
     def process(self) -> None:
         for y in range(self.height):
@@ -49,10 +58,10 @@ class Burkes:
                 greyscale = int(self.get_greyscale(*self.input_img[y][x]))
                 if self.threshold > greyscale + self.error_table[y][x]:
                     self.output_img[y][x] = (0, 0, 0)
-                    current_error = greyscale + self.error_table[x][y]
+                    current_error = greyscale + self.error_table[y][x]
                 else:
                     self.output_img[y][x] = (255, 255, 255)
-                    current_error = greyscale + self.error_table[x][y] - 255
+                    current_error = greyscale + self.error_table[y][x] - 255
                 """
                 Burkes error propagation (`*` is current pixel):
 

dynamic_programming/regex_match.py

@@ -0,0 +1,97 @@
+"""
+Regex matching check if a text matches pattern or not.
+Pattern:
+    '.' Matches any single character.
+    '*' Matches zero or more of the preceding element.
+More info:
+    https://medium.com/trick-the-interviwer/regular-expression-matching-9972eb74c03
+"""
+
+
+def recursive_match(text: str, pattern: str) -> bool:
+    """
+    Recursive matching algorithm.
+
+    Time complexity: O(2 ^ (|text| + |pattern|))
+    Space complexity: Recursion depth is O(|text| + |pattern|).
+
+    :param text: Text to match.
+    :param pattern: Pattern to match.
+    :return: True if text matches pattern, False otherwise.
+
+    >>> recursive_match('abc', 'a.c')
+    True
+    >>> recursive_match('abc', 'af*.c')
+    True
+    >>> recursive_match('abc', 'a.c*')
+    True
+    >>> recursive_match('abc', 'a.c*d')
+    False
+    >>> recursive_match('aa', '.*')
+    True
+    """
+    if not pattern:
+        return not text
+
+    if not text:
+        return pattern[-1] == "*" and recursive_match(text, pattern[:-2])
+
+    if text[-1] == pattern[-1] or pattern[-1] == ".":
+        return recursive_match(text[:-1], pattern[:-1])
+
+    if pattern[-1] == "*":
+        return recursive_match(text[:-1], pattern) or recursive_match(
+            text, pattern[:-2]
+        )
+
+    return False
+
+
+def dp_match(text: str, pattern: str) -> bool:
+    """
+    Dynamic programming matching algorithm.
+
+    Time complexity: O(|text| * |pattern|)
+    Space complexity: O(|text| * |pattern|)
+
+    :param text: Text to match.
+    :param pattern: Pattern to match.
+    :return: True if text matches pattern, False otherwise.
+
+    >>> dp_match('abc', 'a.c')
+    True
+    >>> dp_match('abc', 'af*.c')
+    True
+    >>> dp_match('abc', 'a.c*')
+    True
+    >>> dp_match('abc', 'a.c*d')
+    False
+    >>> dp_match('aa', '.*')
+    True
+    """
+    m = len(text)
+    n = len(pattern)
+    dp = [[False for _ in range(n + 1)] for _ in range(m + 1)]
+    dp[0][0] = True
+
+    for j in range(1, n + 1):
+        dp[0][j] = pattern[j - 1] == "*" and dp[0][j - 2]
+
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if pattern[j - 1] in {".", text[i - 1]}:
+                dp[i][j] = dp[i - 1][j - 1]
+            elif pattern[j - 1] == "*":
+                dp[i][j] = dp[i][j - 2]
+                if pattern[j - 2] in {".", text[i - 1]}:
+                    dp[i][j] |= dp[i - 1][j]
+            else:
+                dp[i][j] = False
+
+    return dp[m][n]
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

dynamic_programming/tribonacci.py

@@ -0,0 +1,24 @@
+# Tribonacci sequence using Dynamic Programming
+
+
+def tribonacci(num: int) -> list[int]:
+    """
+    Given a number, return first n Tribonacci Numbers.
+    >>> tribonacci(5)
+    [0, 0, 1, 1, 2]
+    >>> tribonacci(8)
+    [0, 0, 1, 1, 2, 4, 7, 13]
+    """
+    dp = [0] * num
+    dp[2] = 1
+
+    for i in range(3, num):
+        dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3]
+
+    return dp
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

electronics/electric_power.py

@@ -1,7 +1,12 @@
 # https://en.m.wikipedia.org/wiki/Electric_power
 from __future__ import annotations
 
-from collections import namedtuple
+from typing import NamedTuple
+
+
+class Result(NamedTuple):
+    name: str
+    value: float
 
 
 def electric_power(voltage: float, current: float, power: float) -> tuple:
@@ -10,11 +15,11 @@ def electric_power(voltage: float, current: float, power: float) -> tuple:
     fundamental value of electrical system.
     examples are below:
     >>> electric_power(voltage=0, current=2, power=5)
-    result(name='voltage', value=2.5)
+    Result(name='voltage', value=2.5)
     >>> electric_power(voltage=2, current=2, power=0)
-    result(name='power', value=4.0)
+    Result(name='power', value=4.0)
     >>> electric_power(voltage=-2, current=3, power=0)
-    result(name='power', value=6.0)
+    Result(name='power', value=6.0)
     >>> electric_power(voltage=2, current=4, power=2)
     Traceback (most recent call last):
         ...
@@ -28,9 +33,8 @@ def electric_power(voltage: float, current: float, power: float) -> tuple:
         ...
     ValueError: Power cannot be negative in any electrical/electronics system
     >>> electric_power(voltage=2.2, current=2.2, power=0)
-    result(name='power', value=4.84)
+    Result(name='power', value=4.84)
     """
-    result = namedtuple("result", "name value")
     if (voltage, current, power).count(0) != 1:
         raise ValueError("Only one argument must be 0")
     elif power < 0:
@@ -38,11 +42,11 @@ def electric_power(voltage: float, current: float, power: float) -> tuple:
             "Power cannot be negative in any electrical/electronics system"
         )
     elif voltage == 0:
-        return result("voltage", power / current)
+        return Result("voltage", power / current)
     elif current == 0:
-        return result("current", power / voltage)
+        return Result("current", power / voltage)
     elif power == 0:
-        return result("power", float(round(abs(voltage * current), 2)))
+        return Result("power", float(round(abs(voltage * current), 2)))
     else:
         raise ValueError("Exactly one argument must be 0")
 

fractals/sierpinski_triangle.py

@@ -82,3 +82,4 @@ if __name__ == "__main__":
 
     vertices = [(-175, -125), (0, 175), (175, -125)]  # vertices of triangle
     triangle(vertices[0], vertices[1], vertices[2], int(sys.argv[1]))
+    turtle.Screen().exitonclick()

graphs/bi_directional_dijkstra.py

@@ -26,8 +26,8 @@ def pass_and_relaxation(
     cst_bwd: dict,
     queue: PriorityQueue,
     parent: dict,
-    shortest_distance: float | int,
-) -> float | int:
+    shortest_distance: float,
+) -> float:
     for nxt, d in graph[v]:
         if nxt in visited_forward:
             continue

graphs/eulerian_path_and_circuit_for_undirected_graph.py

@@ -20,7 +20,7 @@ def check_circuit_or_path(graph, max_node):
     odd_degree_nodes = 0
     odd_node = -1
     for i in range(max_node):
-        if i not in graph.keys():
+        if i not in graph:
             continue
         if len(graph[i]) % 2 == 1:
             odd_degree_nodes += 1

linear_algebra/src/polynom_for_points.py

@@ -43,62 +43,43 @@ def points_to_polynomial(coordinates: list[list[int]]) -> str:
 
     x = len(coordinates)
 
-    count_of_line = 0
-    matrix: list[list[float]] = []
     # put the x and x to the power values in a matrix
-    while count_of_line < x:
-        count_in_line = 0
-        a = coordinates[count_of_line][0]
-        count_line: list[float] = []
-        while count_in_line < x:
-            count_line.append(a ** (x - (count_in_line + 1)))
-            count_in_line += 1
-        matrix.append(count_line)
-        count_of_line += 1
+    matrix: list[list[float]] = [
+        [
+            coordinates[count_of_line][0] ** (x - (count_in_line + 1))
+            for count_in_line in range(x)
+        ]
+        for count_of_line in range(x)
+    ]
 
-    count_of_line = 0
     # put the y values into a vector
-    vector: list[float] = []
-    while count_of_line < x:
-        vector.append(coordinates[count_of_line][1])
-        count_of_line += 1
+    vector: list[float] = [coordinates[count_of_line][1] for count_of_line in range(x)]
 
-    count = 0
-
-    while count < x:
-        zahlen = 0
-        while zahlen < x:
-            if count == zahlen:
-                zahlen += 1
-            if zahlen == x:
-                break
-            bruch = matrix[zahlen][count] / matrix[count][count]
+    for count in range(x):
+        for number in range(x):
+            if count == number:
+                continue
+            fraction = matrix[number][count] / matrix[count][count]
             for counting_columns, item in enumerate(matrix[count]):
                 # manipulating all the values in the matrix
-                matrix[zahlen][counting_columns] -= item * bruch
+                matrix[number][counting_columns] -= item * fraction
             # manipulating the values in the vector
-            vector[zahlen] -= vector[count] * bruch
-            zahlen += 1
-        count += 1
+            vector[number] -= vector[count] * fraction
 
-    count = 0
     # make solutions
-    solution: list[str] = []
-    while count < x:
-        solution.append(str(vector[count] / matrix[count][count]))
-        count += 1
+    solution: list[str] = [
+        str(vector[count] / matrix[count][count]) for count in range(x)
+    ]
 
-    count = 0
     solved = "f(x)="
 
-    while count < x:
+    for count in range(x):
         remove_e: list[str] = solution[count].split("E")
         if len(remove_e) > 1:
             solution[count] = f"{remove_e[0]}*10^{remove_e[1]}"
         solved += f"x^{x - (count + 1)}*{solution[count]}"
         if count + 1 != x:
             solved += "+"
-        count += 1
 
     return solved
 

linear_programming/simplex.py

@@ -20,6 +20,11 @@ import numpy as np
 class Tableau:
     """Operate on simplex tableaus
 
+    >>> Tableau(np.array([[-1,-1,0,0,1],[1,3,1,0,4],[3,1,0,1,4]]), 2, 2)
+    Traceback (most recent call last):
+    ...
+    TypeError: Tableau must have type float64
+
     >>> Tableau(np.array([[-1,-1,0,0,-1],[1,3,1,0,4],[3,1,0,1,4.]]), 2, 2)
     Traceback (most recent call last):
     ...
@@ -31,12 +36,15 @@ class Tableau:
     ValueError: number of (artificial) variables must be a natural number
     """
 
-    # Maximum number of iterations to prevent cycling
+    # Max iteration number to prevent cycling
     maxiter = 100
 
     def __init__(
         self, tableau: np.ndarray, n_vars: int, n_artificial_vars: int
     ) -> None:
+        if tableau.dtype != "float64":
+            raise TypeError("Tableau must have type float64")
+
         # Check if RHS is negative
         if not (tableau[:, -1] >= 0).all():
             raise ValueError("RHS must be > 0")
@@ -80,6 +88,10 @@ class Tableau:
         >>> Tableau(np.array([[-1,-1,0,0,1],[1,3,1,0,4],[3,1,0,1,4.]]),
         ... 2, 0).generate_col_titles()
         ['x1', 'x2', 's1', 's2', 'RHS']
+
+        >>> Tableau(np.array([[-1,-1,0,0,1],[1,3,1,0,4],[3,1,0,1,4.]]),
+        ... 2, 2).generate_col_titles()
+        ['x1', 'x2', 'RHS']
         """
         args = (self.n_vars, self.n_slack)
 
@@ -206,6 +218,20 @@ class Tableau:
         ... 2, 0).run_simplex()
         {'P': 2.0, 'x1': 1.0, 'x2': 1.0}
 
+        # Standard linear program with 3 variables:
+        Max: 3x1 +  x2 + 3x3
+        ST:  2x1 +  x2 +  x3 ≤ 2
+              x1 + 2x2 + 3x3 ≤ 5
+             2x1 + 2x2 +  x3 ≤ 6
+        >>> Tableau(np.array([
+        ... [-3,-1,-3,0,0,0,0],
+        ... [2,1,1,1,0,0,2],
+        ... [1,2,3,0,1,0,5],
+        ... [2,2,1,0,0,1,6.]
+        ... ]),3,0).run_simplex() # doctest: +ELLIPSIS
+        {'P': 5.4, 'x1': 0.199..., 'x3': 1.6}
+
+
         # Optimal tableau input:
         >>> Tableau(np.array([
         ... [0, 0, 0.25, 0.25, 2],

machine_learning/forecasting/ex_data.csv

@@ -1,4 +1,4 @@
-total_user,total_events,days
+total_users,total_events,days
 18231,0.0,1
 22621,1.0,2
 15675,0.0,3

machine_learning/forecasting/run.py

@@ -1,6 +1,6 @@
 """
 this is code for forecasting
-but i modified it and used it for safety checker of data
+but I modified it and used it for safety checker of data
 for ex: you have an online shop and for some reason some data are
 missing (the amount of data that u expected are not supposed to be)
         then we can use it
@@ -11,6 +11,8 @@ missing (the amount of data that u expected are not supposed to be)
          u can just adjust it for ur own purpose
 """
 
+from warnings import simplefilter
+
 import numpy as np
 import pandas as pd
 from sklearn.preprocessing import Normalizer
@@ -45,8 +47,10 @@ def sarimax_predictor(train_user: list, train_match: list, test_match: list) ->
     >>> sarimax_predictor([4,2,6,8], [3,1,2,4], [2])
     6.6666671111109626
     """
+    # Suppress the User Warning raised by SARIMAX due to insufficient observations
+    simplefilter("ignore", UserWarning)
     order = (1, 2, 1)
-    seasonal_order = (1, 1, 0, 7)
+    seasonal_order = (1, 1, 1, 7)
     model = SARIMAX(
         train_user, exog=train_match, order=order, seasonal_order=seasonal_order
     )
@@ -102,6 +106,10 @@ def data_safety_checker(list_vote: list, actual_result: float) -> bool:
     """
     safe = 0
     not_safe = 0
+
+    if not isinstance(actual_result, float):
+        raise TypeError("Actual result should be float. Value passed is a list")
+
     for i in list_vote:
         if i > actual_result:
             safe = not_safe + 1
@@ -114,16 +122,11 @@ def data_safety_checker(list_vote: list, actual_result: float) -> bool:
 
 
 if __name__ == "__main__":
-    # data_input_df = pd.read_csv("ex_data.csv", header=None)
-    data_input = [[18231, 0.0, 1], [22621, 1.0, 2], [15675, 0.0, 3], [23583, 1.0, 4]]
-    data_input_df = pd.DataFrame(
-        data_input, columns=["total_user", "total_even", "days"]
-    )
-
     """
     data column = total user in a day, how much online event held in one day,
     what day is that(sunday-saturday)
     """
+    data_input_df = pd.read_csv("ex_data.csv")
 
     # start normalization
     normalize_df = Normalizer().fit_transform(data_input_df.values)
@@ -138,23 +141,23 @@ if __name__ == "__main__":
     x_test = x[len(x) - 1 :]
 
     # for linear regression & sarimax
-    trn_date = total_date[: len(total_date) - 1]
-    trn_user = total_user[: len(total_user) - 1]
-    trn_match = total_match[: len(total_match) - 1]
+    train_date = total_date[: len(total_date) - 1]
+    train_user = total_user[: len(total_user) - 1]
+    train_match = total_match[: len(total_match) - 1]
 
-    tst_date = total_date[len(total_date) - 1 :]
-    tst_user = total_user[len(total_user) - 1 :]
-    tst_match = total_match[len(total_match) - 1 :]
+    test_date = total_date[len(total_date) - 1 :]
+    test_user = total_user[len(total_user) - 1 :]
+    test_match = total_match[len(total_match) - 1 :]
 
     # voting system with forecasting
     res_vote = [
         linear_regression_prediction(
-            trn_date, trn_user, trn_match, tst_date, tst_match
+            train_date, train_user, train_match, test_date, test_match
         ),
-        sarimax_predictor(trn_user, trn_match, tst_match),
-        support_vector_regressor(x_train, x_test, trn_user),
+        sarimax_predictor(train_user, train_match, test_match),
+        support_vector_regressor(x_train, x_test, train_user),
     ]
 
     # check the safety of today's data
-    not_str = "" if data_safety_checker(res_vote, tst_user) else "not "
-    print("Today's data is {not_str}safe.")
+    not_str = "" if data_safety_checker(res_vote, test_user[0]) else "not "
+    print(f"Today's data is {not_str}safe.")

machine_learning/polymonial_regression.py

@@ -1,44 +0,0 @@
-import pandas as pd
-from matplotlib import pyplot as plt
-from sklearn.linear_model import LinearRegression
-
-# Splitting the dataset into the Training set and Test set
-from sklearn.model_selection import train_test_split
-
-# Fitting Polynomial Regression to the dataset
-from sklearn.preprocessing import PolynomialFeatures
-
-# Importing the dataset
-dataset = pd.read_csv(
-    "https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/"
-    "position_salaries.csv"
-)
-X = dataset.iloc[:, 1:2].values
-y = dataset.iloc[:, 2].values
-
-
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
-
-
-poly_reg = PolynomialFeatures(degree=4)
-X_poly = poly_reg.fit_transform(X)
-pol_reg = LinearRegression()
-pol_reg.fit(X_poly, y)
-
-
-# Visualizing the Polymonial Regression results
-def viz_polymonial():
-    plt.scatter(X, y, color="red")
-    plt.plot(X, pol_reg.predict(poly_reg.fit_transform(X)), color="blue")
-    plt.title("Truth or Bluff (Linear Regression)")
-    plt.xlabel("Position level")
-    plt.ylabel("Salary")
-    plt.show()
-
-
-if __name__ == "__main__":
-    viz_polymonial()
-
-    # Predicting a new result with Polymonial Regression
-    pol_reg.predict(poly_reg.fit_transform([[5.5]]))
-    # output should be 132148.43750003

machine_learning/polynomial_regression.py

@@ -0,0 +1,213 @@
+"""
+Polynomial regression is a type of regression analysis that models the relationship
+between a predictor x and the response y as an mth-degree polynomial:
+
+y = β₀ + β₁x + β₂x² + ... + βₘxᵐ + ε
+
+By treating x, x², ..., xᵐ as distinct variables, we see that polynomial regression is a
+special case of multiple linear regression. Therefore, we can use ordinary least squares
+(OLS) estimation to estimate the vector of model parameters β = (β₀, β₁, β₂, ..., βₘ)
+for polynomial regression:
+
+β = (XᵀX)⁻¹Xᵀy = X⁺y
+
+where X is the design matrix, y is the response vector, and X⁺ denotes the Moore–Penrose
+pseudoinverse of X. In the case of polynomial regression, the design matrix is
+
+    |1  x₁  x₁² ⋯ x₁ᵐ|
+X = |1  x₂  x₂² ⋯ x₂ᵐ|
+    |⋮  ⋮   ⋮   ⋱ ⋮  |
+    |1  xₙ  xₙ² ⋯  xₙᵐ|
+
+In OLS estimation, inverting XᵀX to compute X⁺ can be very numerically unstable. This
+implementation sidesteps this need to invert XᵀX by computing X⁺ using singular value
+decomposition (SVD):
+
+β = VΣ⁺Uᵀy
+
+where UΣVᵀ is an SVD of X.
+
+References:
+    - https://en.wikipedia.org/wiki/Polynomial_regression
+    - https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse
+    - https://en.wikipedia.org/wiki/Numerical_methods_for_linear_least_squares
+    - https://en.wikipedia.org/wiki/Singular_value_decomposition
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class PolynomialRegression:
+    __slots__ = "degree", "params"
+
+    def __init__(self, degree: int) -> None:
+        """
+        @raises ValueError: if the polynomial degree is negative
+        """
+        if degree < 0:
+            raise ValueError("Polynomial degree must be non-negative")
+
+        self.degree = degree
+        self.params = None
+
+    @staticmethod
+    def _design_matrix(data: np.ndarray, degree: int) -> np.ndarray:
+        """
+        Constructs a polynomial regression design matrix for the given input data. For
+        input data x = (x₁, x₂, ..., xₙ) and polynomial degree m, the design matrix is
+        the Vandermonde matrix
+
+            |1  x₁  x₁² ⋯ x₁ᵐ|
+        X = |1  x₂  x₂² ⋯ x₂ᵐ|
+            |⋮  ⋮   ⋮   ⋱ ⋮  |
+            |1  xₙ  xₙ² ⋯  xₙᵐ|
+
+        Reference: https://en.wikipedia.org/wiki/Vandermonde_matrix
+
+        @param data:    the input predictor values x, either for model fitting or for
+                        prediction
+        @param degree:  the polynomial degree m
+        @returns:       the Vandermonde matrix X (see above)
+        @raises ValueError: if input data is not N x 1
+
+        >>> x = np.array([0, 1, 2])
+        >>> PolynomialRegression._design_matrix(x, degree=0)
+        array([[1],
+               [1],
+               [1]])
+        >>> PolynomialRegression._design_matrix(x, degree=1)
+        array([[1, 0],
+               [1, 1],
+               [1, 2]])
+        >>> PolynomialRegression._design_matrix(x, degree=2)
+        array([[1, 0, 0],
+               [1, 1, 1],
+               [1, 2, 4]])
+        >>> PolynomialRegression._design_matrix(x, degree=3)
+        array([[1, 0, 0, 0],
+               [1, 1, 1, 1],
+               [1, 2, 4, 8]])
+        >>> PolynomialRegression._design_matrix(np.array([[0, 0], [0 , 0]]), degree=3)
+        Traceback (most recent call last):
+        ...
+        ValueError: Data must have dimensions N x 1
+        """
+        rows, *remaining = data.shape
+        if remaining:
+            raise ValueError("Data must have dimensions N x 1")
+
+        return np.vander(data, N=degree + 1, increasing=True)
+
+    def fit(self, x_train: np.ndarray, y_train: np.ndarray) -> None:
+        """
+        Computes the polynomial regression model parameters using ordinary least squares
+        (OLS) estimation:
+
+        β = (XᵀX)⁻¹Xᵀy = X⁺y
+
+        where X⁺ denotes the Moore–Penrose pseudoinverse of the design matrix X. This
+        function computes X⁺ using singular value decomposition (SVD).
+
+        References:
+            - https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse
+            - https://en.wikipedia.org/wiki/Singular_value_decomposition
+            - https://en.wikipedia.org/wiki/Multicollinearity
+
+        @param x_train: the predictor values x for model fitting
+        @param y_train: the response values y for model fitting
+        @raises ArithmeticError:    if X isn't full rank, then XᵀX is singular and β
+                                    doesn't exist
+
+        >>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+        >>> y = x**3 - 2 * x**2 + 3 * x - 5
+        >>> poly_reg = PolynomialRegression(degree=3)
+        >>> poly_reg.fit(x, y)
+        >>> poly_reg.params
+        array([-5.,  3., -2.,  1.])
+        >>> poly_reg = PolynomialRegression(degree=20)
+        >>> poly_reg.fit(x, y)
+        Traceback (most recent call last):
+        ...
+        ArithmeticError: Design matrix is not full rank, can't compute coefficients
+
+        Make sure errors don't grow too large:
+        >>> coefs = np.array([-250, 50, -2, 36, 20, -12, 10, 2, -1, -15, 1])
+        >>> y = PolynomialRegression._design_matrix(x, len(coefs) - 1) @ coefs
+        >>> poly_reg = PolynomialRegression(degree=len(coefs) - 1)
+        >>> poly_reg.fit(x, y)
+        >>> np.allclose(poly_reg.params, coefs, atol=10e-3)
+        True
+        """
+        X = PolynomialRegression._design_matrix(x_train, self.degree)  # noqa: N806
+        _, cols = X.shape
+        if np.linalg.matrix_rank(X) < cols:
+            raise ArithmeticError(
+                "Design matrix is not full rank, can't compute coefficients"
+            )
+
+        # np.linalg.pinv() computes the Moore–Penrose pseudoinverse using SVD
+        self.params = np.linalg.pinv(X) @ y_train
+
+    def predict(self, data: np.ndarray) -> np.ndarray:
+        """
+        Computes the predicted response values y for the given input data by
+        constructing the design matrix X and evaluating y = Xβ.
+
+        @param data:    the predictor values x for prediction
+        @returns:       the predicted response values y = Xβ
+        @raises ArithmeticError:    if this function is called before the model
+                                    parameters are fit
+
+        >>> x = np.array([0, 1, 2, 3, 4])
+        >>> y = x**3 - 2 * x**2 + 3 * x - 5
+        >>> poly_reg = PolynomialRegression(degree=3)
+        >>> poly_reg.fit(x, y)
+        >>> poly_reg.predict(np.array([-1]))
+        array([-11.])
+        >>> poly_reg.predict(np.array([-2]))
+        array([-27.])
+        >>> poly_reg.predict(np.array([6]))
+        array([157.])
+        >>> PolynomialRegression(degree=3).predict(x)
+        Traceback (most recent call last):
+        ...
+        ArithmeticError: Predictor hasn't been fit yet
+        """
+        if self.params is None:
+            raise ArithmeticError("Predictor hasn't been fit yet")
+
+        return PolynomialRegression._design_matrix(data, self.degree) @ self.params
+
+
+def main() -> None:
+    """
+    Fit a polynomial regression model to predict fuel efficiency using seaborn's mpg
+    dataset
+
+    >>> pass    # Placeholder, function is only for demo purposes
+    """
+    import seaborn as sns
+
+    mpg_data = sns.load_dataset("mpg")
+
+    poly_reg = PolynomialRegression(degree=2)
+    poly_reg.fit(mpg_data.weight, mpg_data.mpg)
+
+    weight_sorted = np.sort(mpg_data.weight)
+    predictions = poly_reg.predict(weight_sorted)
+
+    plt.scatter(mpg_data.weight, mpg_data.mpg, color="gray", alpha=0.5)
+    plt.plot(weight_sorted, predictions, color="red", linewidth=3)
+    plt.title("Predicting Fuel Efficiency Using Polynomial Regression")
+    plt.xlabel("Weight (lbs)")
+    plt.ylabel("Fuel Efficiency (mpg)")
+    plt.show()
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+
+    main()

maths/area_under_curve.py

@@ -7,9 +7,9 @@ from collections.abc import Callable
 
 
 def trapezoidal_area(
-    fnc: Callable[[int | float], int | float],
-    x_start: int | float,
-    x_end: int | float,
+    fnc: Callable[[float], float],
+    x_start: float,
+    x_end: float,
     steps: int = 100,
 ) -> float:
     """

maths/collatz_sequence.py

@@ -57,7 +57,7 @@ def collatz_sequence(n: int) -> Generator[int, None, None]:
 
 
 def main():
-    n = 43
+    n = int(input("Your number: "))
     sequence = tuple(collatz_sequence(n))
     print(sequence)
     print(f"Collatz sequence from {n} took {len(sequence)} steps.")

maths/decimal_to_fraction.py

@@ -1,4 +1,4 @@
-def decimal_to_fraction(decimal: int | float | str) -> tuple[int, int]:
+def decimal_to_fraction(decimal: float | str) -> tuple[int, int]:
     """
     Return a decimal number in its simplest fraction form
     >>> decimal_to_fraction(2)

maths/find_max.py

@@ -1,23 +1,23 @@
 from __future__ import annotations
 
 
-def find_max(nums: list[int | float]) -> int | float:
+def find_max_iterative(nums: list[int | float]) -> int | float:
     """
     >>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
-    ...     find_max(nums) == max(nums)
+    ...     find_max_iterative(nums) == max(nums)
     True
     True
     True
     True
-    >>> find_max([2, 4, 9, 7, 19, 94, 5])
+    >>> find_max_iterative([2, 4, 9, 7, 19, 94, 5])
     94
-    >>> find_max([])
+    >>> find_max_iterative([])
     Traceback (most recent call last):
         ...
-    ValueError: find_max() arg is an empty sequence
+    ValueError: find_max_iterative() arg is an empty sequence
     """
     if len(nums) == 0:
-        raise ValueError("find_max() arg is an empty sequence")
+        raise ValueError("find_max_iterative() arg is an empty sequence")
     max_num = nums[0]
     for x in nums:
         if x > max_num:
@@ -25,6 +25,59 @@ def find_max(nums: list[int | float]) -> int | float:
     return max_num
 
 
+# Divide and Conquer algorithm
+def find_max_recursive(nums: list[int | float], left: int, right: int) -> int | float:
+    """
+    find max value in list
+    :param nums: contains elements
+    :param left: index of first element
+    :param right: index of last element
+    :return: max in nums
+
+    >>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
+    ...     find_max_recursive(nums, 0, len(nums) - 1) == max(nums)
+    True
+    True
+    True
+    True
+    >>> nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
+    >>> find_max_recursive(nums, 0, len(nums) - 1) == max(nums)
+    True
+    >>> find_max_recursive([], 0, 0)
+    Traceback (most recent call last):
+        ...
+    ValueError: find_max_recursive() arg is an empty sequence
+    >>> find_max_recursive(nums, 0, len(nums)) == max(nums)
+    Traceback (most recent call last):
+        ...
+    IndexError: list index out of range
+    >>> find_max_recursive(nums, -len(nums), -1) == max(nums)
+    True
+    >>> find_max_recursive(nums, -len(nums) - 1, -1) == max(nums)
+    Traceback (most recent call last):
+        ...
+    IndexError: list index out of range
+    """
+    if len(nums) == 0:
+        raise ValueError("find_max_recursive() arg is an empty sequence")
+    if (
+        left >= len(nums)
+        or left < -len(nums)
+        or right >= len(nums)
+        or right < -len(nums)
+    ):
+        raise IndexError("list index out of range")
+    if left == right:
+        return nums[left]
+    mid = (left + right) >> 1  # the middle
+    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
+
+
 if __name__ == "__main__":
     import doctest
 

maths/find_max_recursion.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-
-# Divide and Conquer algorithm
-def find_max(nums: list[int | float], left: int, right: int) -> int | float:
-    """
-    find max value in list
-    :param nums: contains elements
-    :param left: index of first element
-    :param right: index of last element
-    :return: max in nums
-
-    >>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
-    ...     find_max(nums, 0, len(nums) - 1) == max(nums)
-    True
-    True
-    True
-    True
-    >>> nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
-    >>> find_max(nums, 0, len(nums) - 1) == max(nums)
-    True
-    >>> find_max([], 0, 0)
-    Traceback (most recent call last):
-        ...
-    ValueError: find_max() arg is an empty sequence
-    >>> find_max(nums, 0, len(nums)) == max(nums)
-    Traceback (most recent call last):
-        ...
-    IndexError: list index out of range
-    >>> find_max(nums, -len(nums), -1) == max(nums)
-    True
-    >>> find_max(nums, -len(nums) - 1, -1) == max(nums)
-    Traceback (most recent call last):
-        ...
-    IndexError: list index out of range
-    """
-    if len(nums) == 0:
-        raise ValueError("find_max() arg is an empty sequence")
-    if (
-        left >= len(nums)
-        or left < -len(nums)
-        or right >= len(nums)
-        or right < -len(nums)
-    ):
-        raise IndexError("list index out of range")
-    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]
-
-    return left_max if left_max >= right_max else right_max
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(verbose=True)

maths/find_min.py

@@ -1,33 +1,86 @@
 from __future__ import annotations
 
 
-def find_min(nums: list[int | float]) -> int | float:
+def find_min_iterative(nums: list[int | float]) -> int | float:
     """
     Find Minimum Number in a List
     :param nums: contains elements
     :return: min number in list
 
     >>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
-    ...     find_min(nums) == min(nums)
+    ...     find_min_iterative(nums) == min(nums)
     True
     True
     True
     True
-    >>> find_min([0, 1, 2, 3, 4, 5, -3, 24, -56])
+    >>> find_min_iterative([0, 1, 2, 3, 4, 5, -3, 24, -56])
     -56
-    >>> find_min([])
+    >>> find_min_iterative([])
     Traceback (most recent call last):
         ...
-    ValueError: find_min() arg is an empty sequence
+    ValueError: find_min_iterative() arg is an empty sequence
     """
     if len(nums) == 0:
-        raise ValueError("find_min() arg is an empty sequence")
+        raise ValueError("find_min_iterative() arg is an empty sequence")
     min_num = nums[0]
     for num in nums:
         min_num = min(min_num, num)
     return min_num
 
 
+# Divide and Conquer algorithm
+def find_min_recursive(nums: list[int | float], left: int, right: int) -> int | float:
+    """
+    find min value in list
+    :param nums: contains elements
+    :param left: index of first element
+    :param right: index of last element
+    :return: min in nums
+
+    >>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
+    ...     find_min_recursive(nums, 0, len(nums) - 1) == min(nums)
+    True
+    True
+    True
+    True
+    >>> nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
+    >>> find_min_recursive(nums, 0, len(nums) - 1) == min(nums)
+    True
+    >>> find_min_recursive([], 0, 0)
+    Traceback (most recent call last):
+        ...
+    ValueError: find_min_recursive() arg is an empty sequence
+    >>> find_min_recursive(nums, 0, len(nums)) == min(nums)
+    Traceback (most recent call last):
+        ...
+    IndexError: list index out of range
+    >>> find_min_recursive(nums, -len(nums), -1) == min(nums)
+    True
+    >>> find_min_recursive(nums, -len(nums) - 1, -1) == min(nums)
+    Traceback (most recent call last):
+        ...
+    IndexError: list index out of range
+    """
+    if len(nums) == 0:
+        raise ValueError("find_min_recursive() arg is an empty sequence")
+    if (
+        left >= len(nums)
+        or left < -len(nums)
+        or right >= len(nums)
+        or right < -len(nums)
+    ):
+        raise IndexError("list index out of range")
+    if left == right:
+        return nums[left]
+    mid = (left + right) >> 1  # the middle
+    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
+
+
 if __name__ == "__main__":
     import doctest
 

maths/find_min_recursion.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-
-# Divide and Conquer algorithm
-def find_min(nums: list[int | float], left: int, right: int) -> int | float:
-    """
-    find min value in list
-    :param nums: contains elements
-    :param left: index of first element
-    :param right: index of last element
-    :return: min in nums
-
-    >>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
-    ...     find_min(nums, 0, len(nums) - 1) == min(nums)
-    True
-    True
-    True
-    True
-    >>> nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
-    >>> find_min(nums, 0, len(nums) - 1) == min(nums)
-    True
-    >>> find_min([], 0, 0)
-    Traceback (most recent call last):
-        ...
-    ValueError: find_min() arg is an empty sequence
-    >>> find_min(nums, 0, len(nums)) == min(nums)
-    Traceback (most recent call last):
-        ...
-    IndexError: list index out of range
-    >>> find_min(nums, -len(nums), -1) == min(nums)
-    True
-    >>> find_min(nums, -len(nums) - 1, -1) == min(nums)
-    Traceback (most recent call last):
-        ...
-    IndexError: list index out of range
-    """
-    if len(nums) == 0:
-        raise ValueError("find_min() arg is an empty sequence")
-    if (
-        left >= len(nums)
-        or left < -len(nums)
-        or right >= len(nums)
-        or right < -len(nums)
-    ):
-        raise IndexError("list index out of range")
-    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]
-
-    return left_min if left_min <= right_min else right_min
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(verbose=True)

maths/interquartile_range.py

@@ -0,0 +1,66 @@
+"""
+An implementation of interquartile range (IQR) which is a measure of statistical
+dispersion, which is the spread of the data.
+
+The function takes the list of numeric values as input and returns the IQR.
+
+Script inspired by this Wikipedia article:
+https://en.wikipedia.org/wiki/Interquartile_range
+"""
+from __future__ import annotations
+
+
+def find_median(nums: list[int | float]) -> float:
+    """
+    This is the implementation of the median.
+    :param nums: The list of numeric nums
+    :return: Median of the list
+    >>> find_median(nums=([1, 2, 2, 3, 4]))
+    2
+    >>> find_median(nums=([1, 2, 2, 3, 4, 4]))
+    2.5
+    >>> find_median(nums=([-1, 2, 0, 3, 4, -4]))
+    1.5
+    >>> find_median(nums=([1.1, 2.2, 2, 3.3, 4.4, 4]))
+    2.65
+    """
+    div, mod = divmod(len(nums), 2)
+    if mod:
+        return nums[div]
+    return (nums[div] + nums[(div) - 1]) / 2
+
+
+def interquartile_range(nums: list[int | float]) -> float:
+    """
+    Return the interquartile range for a list of numeric values.
+    :param nums: The list of numeric values.
+    :return: interquartile range
+
+    >>> interquartile_range(nums=[4, 1, 2, 3, 2])
+    2.0
+    >>> interquartile_range(nums = [-2, -7, -10, 9, 8, 4, -67, 45])
+    17.0
+    >>> interquartile_range(nums = [-2.1, -7.1, -10.1, 9.1, 8.1, 4.1, -67.1, 45.1])
+    17.2
+    >>> interquartile_range(nums = [0, 0, 0, 0, 0])
+    0.0
+    >>> interquartile_range(nums=[])
+    Traceback (most recent call last):
+    ...
+    ValueError: The list is empty. Provide a non-empty list.
+    """
+    if not nums:
+        raise ValueError("The list is empty. Provide a non-empty list.")
+    nums.sort()
+    length = len(nums)
+    div, mod = divmod(length, 2)
+    q1 = find_median(nums[:div])
+    half_length = sum((div, mod))
+    q3 = find_median(nums[half_length:length])
+    return q3 - q1
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

maths/line_length.py

@@ -5,9 +5,9 @@ from collections.abc import Callable
 
 
 def line_length(
-    fnc: Callable[[int | float], int | float],
-    x_start: int | float,
-    x_end: int | float,
+    fnc: Callable[[float], float],
+    x_start: float,
+    x_end: float,
     steps: int = 100,
 ) -> float:
     """

maths/numerical_integration.py

@@ -7,9 +7,9 @@ from collections.abc import Callable
 
 
 def trapezoidal_area(
-    fnc: Callable[[int | float], int | float],
-    x_start: int | float,
-    x_end: int | float,
+    fnc: Callable[[float], float],
+    x_start: float,
+    x_end: float,
     steps: int = 100,
 ) -> float:
     """

maths/polynomials/single_indeterminate_operations.py

@@ -87,7 +87,7 @@ class Polynomial:
 
         return Polynomial(self.degree + polynomial_2.degree, coefficients)
 
-    def evaluate(self, substitution: int | float) -> int | float:
+    def evaluate(self, substitution: float) -> float:
         """
         Evaluates the polynomial at x.
         >>> p = Polynomial(2, [1, 2, 3])
@@ -144,7 +144,7 @@ class Polynomial:
             coefficients[i] = self.coefficients[i + 1] * (i + 1)
         return Polynomial(self.degree - 1, coefficients)
 
-    def integral(self, constant: int | float = 0) -> Polynomial:
+    def integral(self, constant: float = 0) -> Polynomial:
         """
         Returns the integral of the polynomial.
         >>> p = Polynomial(2, [1, 2, 3])

maths/series/geometric_series.py

@@ -14,10 +14,10 @@ from __future__ import annotations
 
 
 def geometric_series(
-    nth_term: float | int,
-    start_term_a: float | int,
-    common_ratio_r: float | int,
-) -> list[float | int]:
+    nth_term: float,
+    start_term_a: float,
+    common_ratio_r: float,
+) -> list[float]:
     """
     Pure Python implementation of Geometric Series algorithm
 
@@ -48,7 +48,7 @@ def geometric_series(
     """
     if not all((nth_term, start_term_a, common_ratio_r)):
         return []
-    series: list[float | int] = []
+    series: list[float] = []
     power = 1
     multiple = common_ratio_r
     for _ in range(int(nth_term)):

maths/series/p_series.py

@@ -13,7 +13,7 @@ python3 p_series.py
 from __future__ import annotations
 
 
-def p_series(nth_term: int | float | str, power: int | float | str) -> list[str]:
+def p_series(nth_term: float | str, power: float | str) -> list[str]:
     """
     Pure Python implementation of P-Series algorithm
     :return: The P-Series starting from 1 to last (nth) term

maths/volume.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 from math import pi, pow
 
 
-def vol_cube(side_length: int | float) -> float:
+def vol_cube(side_length: float) -> float:
     """
     Calculate the Volume of a Cube.
     >>> vol_cube(1)

matrix/matrix_class.py

@@ -141,7 +141,7 @@ class Matrix:
 
     @property
     def order(self) -> tuple[int, int]:
-        return (self.num_rows, self.num_columns)
+        return self.num_rows, self.num_columns
 
     @property
     def is_square(self) -> bool:
@@ -315,7 +315,7 @@ class Matrix:
             ]
         )
 
-    def __mul__(self, other: Matrix | int | float) -> Matrix:
+    def __mul__(self, other: Matrix | float) -> Matrix:
         if isinstance(other, (int, float)):
             return Matrix(
                 [[int(element * other) for element in row] for row in self.rows]

matrix/matrix_operation.py

@@ -47,7 +47,7 @@ def subtract(matrix_a: list[list[int]], matrix_b: list[list[int]]) -> list[list[
     raise TypeError("Expected a matrix, got int/list instead")
 
 
-def scalar_multiply(matrix: list[list[int]], n: int | float) -> list[list[float]]:
+def scalar_multiply(matrix: list[list[int]], n: float) -> list[list[float]]:
     """
     >>> scalar_multiply([[1,2],[3,4]],5)
     [[5, 10], [15, 20]]
@@ -189,9 +189,7 @@ def main() -> None:
     matrix_c = [[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34], [41, 42, 43, 44]]
     matrix_d = [[3, 0, 2], [2, 0, -2], [0, 1, 1]]
     print(f"Add Operation, {add(matrix_a, matrix_b) = } \n")
-    print(
-        f"Multiply Operation, {multiply(matrix_a, matrix_b) = } \n",
-    )
+    print(f"Multiply Operation, {multiply(matrix_a, matrix_b) = } \n")
     print(f"Identity: {identity(5)}\n")
     print(f"Minor of {matrix_c} = {minor(matrix_c, 1, 2)} \n")
     print(f"Determinant of {matrix_b} = {determinant(matrix_b)} \n")

matrix/searching_in_sorted_matrix.py

@@ -1,9 +1,7 @@
 from __future__ import annotations
 
 
-def search_in_a_sorted_matrix(
-    mat: list[list[int]], m: int, n: int, key: int | float
-) -> None:
+def search_in_a_sorted_matrix(mat: list[list[int]], m: int, n: int, key: float) -> None:
     """
     >>> search_in_a_sorted_matrix(
     ...     [[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]], 3, 3, 5)

matrix/sherman_morrison.py

@@ -22,7 +22,7 @@ class Matrix:
         """
 
         self.row, self.column = row, column
-        self.array = [[default_value for c in range(column)] for r in range(row)]
+        self.array = [[default_value for _ in range(column)] for _ in range(row)]
 
     def __str__(self) -> str:
         """
@@ -54,15 +54,15 @@ class Matrix:
     def __repr__(self) -> str:
         return str(self)
 
-    def validate_indicies(self, loc: tuple[int, int]) -> bool:
+    def validate_indices(self, loc: tuple[int, int]) -> bool:
         """
         <method Matrix.validate_indicies>
         Check if given indices are valid to pick element from matrix.
         Example:
         >>> a = Matrix(2, 6, 0)
-        >>> a.validate_indicies((2, 7))
+        >>> a.validate_indices((2, 7))
         False
-        >>> a.validate_indicies((0, 0))
+        >>> a.validate_indices((0, 0))
         True
         """
         if not (isinstance(loc, (list, tuple)) and len(loc) == 2):
@@ -81,7 +81,7 @@ class Matrix:
         >>> a[1, 0]
         7
         """
-        assert self.validate_indicies(loc)
+        assert self.validate_indices(loc)
         return self.array[loc[0]][loc[1]]
 
     def __setitem__(self, loc: tuple[int, int], value: float) -> None:
@@ -96,7 +96,7 @@ class Matrix:
         [ 1,  1,  1]
         [ 1,  1, 51]
         """
-        assert self.validate_indicies(loc)
+        assert self.validate_indices(loc)
         self.array[loc[0]][loc[1]] = value
 
     def __add__(self, another: Matrix) -> Matrix:
@@ -145,7 +145,7 @@ class Matrix:
     def __sub__(self, another: Matrix) -> Matrix:
         return self + (-another)
 
-    def __mul__(self, another: int | float | Matrix) -> Matrix:
+    def __mul__(self, another: float | Matrix) -> Matrix:
         """
         <method Matrix.__mul__>
         Return self * another.
@@ -233,7 +233,7 @@ class Matrix:
         v_t = v.transpose()
         numerator_factor = (v_t * self * u)[0, 0] + 1
         if numerator_factor == 0:
-            return None  # It's not invertable
+            return None  # It's not invertible
         return self - ((self * u) * (v_t * self) * (1.0 / numerator_factor))
 
 

neural_network/input_data.py.DEPRECATED.txt

@@ -263,9 +263,7 @@ def _maybe_download(filename, work_directory, source_url):
     return filepath
 
 
-@deprecated(
-    None, "Please use alternatives such as:" " tensorflow_datasets.load('mnist')"
-)
+@deprecated(None, "Please use alternatives such as: tensorflow_datasets.load('mnist')")
 def read_data_sets(
     train_dir,
     fake_data=False,

physics/altitude_pressure.py

@@ -0,0 +1,52 @@
+"""
+Title : Calculate altitude using Pressure
+
+Description :
+    The below algorithm approximates the altitude using Barometric formula
+
+
+"""
+
+
+def get_altitude_at_pressure(pressure: float) -> float:
+    """
+    This method calculates the altitude from Pressure wrt to
+    Sea level pressure as reference .Pressure is in Pascals
+    https://en.wikipedia.org/wiki/Pressure_altitude
+    https://community.bosch-sensortec.com/t5/Question-and-answers/How-to-calculate-the-altitude-from-the-pressure-sensor-data/qaq-p/5702
+
+    H = 44330 * [1 - (P/p0)^(1/5.255) ]
+
+    Where :
+    H = altitude (m)
+    P = measured pressure
+    p0 = reference pressure at sea level 101325 Pa
+
+    Examples:
+    >>> get_altitude_at_pressure(pressure=100_000)
+    105.47836610778828
+    >>> get_altitude_at_pressure(pressure=101_325)
+    0.0
+    >>> get_altitude_at_pressure(pressure=80_000)
+    1855.873388064995
+    >>> get_altitude_at_pressure(pressure=201_325)
+    Traceback (most recent call last):
+      ...
+    ValueError: Value Higher than Pressure at Sea Level !
+    >>> get_altitude_at_pressure(pressure=-80_000)
+    Traceback (most recent call last):
+      ...
+    ValueError: Atmospheric Pressure can not be negative !
+    """
+
+    if pressure > 101325:
+        raise ValueError("Value Higher than Pressure at Sea Level !")
+    if pressure < 0:
+        raise ValueError("Atmospheric Pressure can not be negative !")
+    return 44_330 * (1 - (pressure / 101_325) ** (1 / 5.5255))
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

physics/basic_orbital_capture.py

@@ -0,0 +1,178 @@
+from math import pow, sqrt
+
+from scipy.constants import G, c, pi
+
+"""
+These two functions will return the radii of impact for a target object
+of mass M and radius R as well as it's effective cross sectional area σ(sigma).
+That is to say any projectile with velocity v passing within σ, will impact the
+target object with mass M. The derivation of which is given at the bottom
+of this file.
+
+The derivation shows that a projectile does not need to aim directly at the target
+body in order to hit it, as  R_capture>R_target. Astronomers refer to the effective
+cross section for capture as σ=π*R_capture**2.
+
+This algorithm does not account for an N-body problem.
+
+"""
+
+
+def capture_radii(
+    target_body_radius: float, target_body_mass: float, projectile_velocity: float
+) -> float:
+    """
+    Input Params:
+    -------------
+    target_body_radius: Radius of the central body SI units: meters | m
+    target_body_mass: Mass of the central body SI units: kilograms | kg
+    projectile_velocity: Velocity of object moving toward central body
+        SI units: meters/second | m/s
+    Returns:
+    --------
+    >>> capture_radii(6.957e8, 1.99e30, 25000.0)
+    17209590691.0
+    >>> capture_radii(-6.957e8, 1.99e30, 25000.0)
+    Traceback (most recent call last):
+        ...
+    ValueError: Radius cannot be less than 0
+    >>> capture_radii(6.957e8, -1.99e30, 25000.0)
+    Traceback (most recent call last):
+        ...
+    ValueError: Mass cannot be less than 0
+    >>> capture_radii(6.957e8, 1.99e30, c+1)
+    Traceback (most recent call last):
+        ...
+    ValueError: Cannot go beyond speed of light
+
+    Returned SI units:
+    ------------------
+    meters | m
+    """
+
+    if target_body_mass < 0:
+        raise ValueError("Mass cannot be less than 0")
+    if target_body_radius < 0:
+        raise ValueError("Radius cannot be less than 0")
+    if projectile_velocity > c:
+        raise ValueError("Cannot go beyond speed of light")
+
+    escape_velocity_squared = (2 * G * target_body_mass) / target_body_radius
+    capture_radius = target_body_radius * sqrt(
+        1 + escape_velocity_squared / pow(projectile_velocity, 2)
+    )
+    return round(capture_radius, 0)
+
+
+def capture_area(capture_radius: float) -> float:
+    """
+    Input Param:
+    ------------
+    capture_radius: The radius of orbital capture and impact for a central body of
+    mass M and a projectile moving towards it with velocity v
+        SI units: meters | m
+    Returns:
+    --------
+    >>> capture_area(17209590691)
+    9.304455331329126e+20
+    >>> capture_area(-1)
+    Traceback (most recent call last):
+        ...
+    ValueError: Cannot have a capture radius less than 0
+
+    Returned SI units:
+    ------------------
+    meters*meters | m**2
+    """
+
+    if capture_radius < 0:
+        raise ValueError("Cannot have a capture radius less than 0")
+    sigma = pi * pow(capture_radius, 2)
+    return round(sigma, 0)
+
+
+if __name__ == "__main__":
+    from doctest import testmod
+
+    testmod()
+
+"""
+Derivation:
+
+Let: Mt=target mass, Rt=target radius, v=projectile_velocity,
+     r_0=radius of projectile at instant 0 to CM of target
+     v_p=v at closest approach,
+     r_p=radius from projectile to target CM at closest approach,
+     R_capture= radius of impact for projectile with velocity v
+
+(1)At time=0  the projectile's energy falling from infinity| E=K+U=0.5*m*(v**2)+0
+
+    E_initial=0.5*m*(v**2)
+
+(2)at time=0 the angular momentum of the projectile relative to CM target|
+    L_initial=m*r_0*v*sin(Θ)->m*r_0*v*(R_capture/r_0)->m*v*R_capture
+
+    L_i=m*v*R_capture
+
+(3)The energy of the projectile at closest approach will be its kinetic energy
+   at closest approach plus gravitational potential energy(-(GMm)/R)|
+    E_p=K_p+U_p->E_p=0.5*m*(v_p**2)-(G*Mt*m)/r_p
+
+    E_p=0.0.5*m*(v_p**2)-(G*Mt*m)/r_p
+
+(4)The angular momentum of the projectile relative to the target at closest
+   approach will be L_p=m*r_p*v_p*sin(Θ), however relative to the target Θ=90°
+   sin(90°)=1|
+
+    L_p=m*r_p*v_p
+(5)Using conservation of angular momentum and energy, we can write a quadratic
+   equation that solves for r_p|
+
+   (a)
+    Ei=Ep-> 0.5*m*(v**2)=0.5*m*(v_p**2)-(G*Mt*m)/r_p-> v**2=v_p**2-(2*G*Mt)/r_p
+
+   (b)
+    Li=Lp-> m*v*R_capture=m*r_p*v_p-> v*R_capture=r_p*v_p-> v_p=(v*R_capture)/r_p
+
+   (c) b plugs int a|
+    v**2=((v*R_capture)/r_p)**2-(2*G*Mt)/r_p->
+
+    v**2-(v**2)*(R_c**2)/(r_p**2)+(2*G*Mt)/r_p=0->
+
+    (v**2)*(r_p**2)+2*G*Mt*r_p-(v**2)*(R_c**2)=0
+
+   (d) Using the quadratic formula, we'll solve for r_p then rearrange to solve to
+       R_capture
+
+    r_p=(-2*G*Mt ± sqrt(4*G^2*Mt^2+ 4(v^4*R_c^2)))/(2*v^2)->
+
+    r_p=(-G*Mt ± sqrt(G^2*Mt+v^4*R_c^2))/v^2->
+
+    r_p<0 is something we can ignore, as it has no physical meaning for our purposes.->
+
+    r_p=(-G*Mt)/v^2 + sqrt(G^2*Mt^2/v^4 + R_c^2)
+
+   (e)We are trying to solve for R_c. We are looking for impact, so we want r_p=Rt
+
+    Rt + G*Mt/v^2 = sqrt(G^2*Mt^2/v^4 + R_c^2)->
+
+    (Rt + G*Mt/v^2)^2 = G^2*Mt^2/v^4 + R_c^2->
+
+    Rt^2 + 2*G*Mt*Rt/v^2 + G^2*Mt^2/v^4 = G^2*Mt^2/v^4 + R_c^2->
+
+    Rt**2 + 2*G*Mt*Rt/v**2 = R_c**2->
+
+    Rt**2 * (1 + 2*G*Mt/Rt *1/v**2) = R_c**2->
+
+    escape velocity = sqrt(2GM/R)= v_escape**2=2GM/R->
+
+    Rt**2 * (1 + v_esc**2/v**2) = R_c**2->
+
+(6)
+    R_capture = Rt * sqrt(1 + v_esc**2/v**2)
+
+Source: Problem Set 3 #8 c.Fall_2017|Honors Astronomy|Professor Rachel Bezanson
+
+Source #2: http://www.nssc.ac.cn/wxzygx/weixin/201607/P020160718380095698873.pdf
+           8.8 Planetary Rendezvous: Pg.368
+"""

physics/ideal_gas_law.py

@@ -53,6 +53,40 @@ def volume_of_gas_system(moles: float, kelvin: float, pressure: float) -> float:
     return moles * kelvin * UNIVERSAL_GAS_CONSTANT / pressure
 
 
+def temperature_of_gas_system(moles: float, volume: float, pressure: float) -> float:
+    """
+    >>> temperature_of_gas_system(2, 100, 5)
+    30.068090996146232
+    >>> temperature_of_gas_system(11, 5009, 1000)
+    54767.66101807144
+    >>> temperature_of_gas_system(3, -0.46, 23.5)
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid inputs. Enter positive value.
+    """
+    if moles < 0 or volume < 0 or pressure < 0:
+        raise ValueError("Invalid inputs. Enter positive value.")
+
+    return pressure * volume / (moles * UNIVERSAL_GAS_CONSTANT)
+
+
+def moles_of_gas_system(kelvin: float, volume: float, pressure: float) -> float:
+    """
+    >>> moles_of_gas_system(100, 5, 10)
+    0.06013618199229246
+    >>> moles_of_gas_system(110, 5009, 1000)
+    5476.766101807144
+    >>> moles_of_gas_system(3, -0.46, 23.5)
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid inputs. Enter positive value.
+    """
+    if kelvin < 0 or volume < 0 or pressure < 0:
+        raise ValueError("Invalid inputs. Enter positive value.")
+
+    return pressure * volume / (kelvin * UNIVERSAL_GAS_CONSTANT)
+
+
 if __name__ == "__main__":
     from doctest import testmod
 

physics/newtons_second_law_of_motion.py

@@ -60,7 +60,7 @@ def newtons_second_law_of_motion(mass: float, acceleration: float) -> float:
     >>> newtons_second_law_of_motion(2.0, 1)
     2.0
     """
-    force = float()
+    force = 0.0
     try:
         force = mass * acceleration
     except Exception:

pyproject.toml

@@ -49,6 +49,7 @@ select = [  # https://beta.ruff.rs/docs/rules
   "ICN",    # flake8-import-conventions
   "INP",    # flake8-no-pep420
   "INT",    # flake8-gettext
+  "ISC",  # flake8-implicit-str-concat
   "N",      # pep8-naming
   "NPY",    # NumPy-specific rules
   "PGH",    # pygrep-hooks
@@ -72,7 +73,6 @@ select = [  # https://beta.ruff.rs/docs/rules
   # "DJ",   # flake8-django
   # "ERA",  # eradicate -- DO NOT FIX
   # "FBT",  # flake8-boolean-trap  # FIX ME
-  # "ISC",  # flake8-implicit-str-concat  # FIX ME
   # "PD",   # pandas-vet
   # "PT",   # flake8-pytest-style
   # "PTH",  # flake8-use-pathlib  # FIX ME

requirements.txt

@@ -9,6 +9,7 @@ pandas
 pillow
 projectq
 qiskit
+qiskit-aer
 requests
 rich
 scikit-fuzzy

searches/jump_search.py

@@ -4,14 +4,28 @@ This algorithm iterates through a sorted collection with a step of n^(1/2),
 until the element compared is bigger than the one searched.
 It will then perform a linear search until it matches the wanted number.
 If not found, it returns -1.
+
+https://en.wikipedia.org/wiki/Jump_search
 """
 
 import math
+from collections.abc import Sequence
+from typing import Any, Protocol, TypeVar
 
 
-def jump_search(arr: list, x: int) -> int:
+class Comparable(Protocol):
+    def __lt__(self, other: Any, /) -> bool:
+        ...
+
+
+T = TypeVar("T", bound=Comparable)
+
+
+def jump_search(arr: Sequence[T], item: T) -> int:
     """
-    Pure Python implementation of the jump search algorithm.
+    Python implementation of the jump search algorithm.
+    Return the index if the `item` is found, otherwise return -1.
+
     Examples:
     >>> jump_search([0, 1, 2, 3, 4, 5], 3)
     3
@@ -21,31 +35,36 @@ def jump_search(arr: list, x: int) -> int:
     -1
     >>> jump_search([0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610], 55)
     10
+    >>> jump_search(["aa", "bb", "cc", "dd", "ee", "ff"], "ee")
+    4
     """
 
-    n = len(arr)
-    step = int(math.floor(math.sqrt(n)))
+    arr_size = len(arr)
+    block_size = int(math.sqrt(arr_size))
+
     prev = 0
-    while arr[min(step, n) - 1] < x:
+    step = block_size
+    while arr[min(step, arr_size) - 1] < item:
         prev = step
-        step += int(math.floor(math.sqrt(n)))
-        if prev >= n:
+        step += block_size
+        if prev >= arr_size:
             return -1
 
-    while arr[prev] < x:
-        prev = prev + 1
-        if prev == min(step, n):
+    while arr[prev] < item:
+        prev += 1
+        if prev == min(step, arr_size):
             return -1
-    if arr[prev] == x:
+    if arr[prev] == item:
         return prev
     return -1
 
 
 if __name__ == "__main__":
     user_input = input("Enter numbers separated by a comma:\n").strip()
-    arr = [int(item) for item in user_input.split(",")]
+    array = [int(item) for item in user_input.split(",")]
     x = int(input("Enter the number to be searched:\n"))
-    res = jump_search(arr, x)
+
+    res = jump_search(array, x)
     if res == -1:
         print("Number not found!")
     else:

searches/linear_search.py

@@ -15,7 +15,7 @@ def linear_search(sequence: list, target: int) -> int:
     :param sequence: a collection with comparable items (as sorted items not required
         in Linear Search)
     :param target: item value to search
-    :return: index of found item or None if item is not found
+    :return: index of found item or -1 if item is not found
 
     Examples:
     >>> linear_search([0, 5, 7, 10, 15], 0)

sorts/bubble_sort.py

@@ -1,4 +1,7 @@
-def bubble_sort(collection):
+from typing import Any
+
+
+def bubble_sort(collection: list[Any]) -> list[Any]:
     """Pure implementation of bubble sort algorithm in Python
 
     :param collection: some mutable ordered collection with heterogeneous
@@ -28,9 +31,9 @@ def bubble_sort(collection):
     True
     """
     length = len(collection)
-    for i in range(length - 1):
+    for i in reversed(range(length)):
         swapped = False
-        for j in range(length - 1 - i):
+        for j in range(i):
             if collection[j] > collection[j + 1]:
                 swapped = True
                 collection[j], collection[j + 1] = collection[j + 1], collection[j]

strings/is_srilankan_phone_number.py

@@ -22,9 +22,7 @@ def is_sri_lankan_phone_number(phone: str) -> bool:
     False
     """
 
-    pattern = re.compile(
-        r"^(?:0|94|\+94|0{2}94)" r"7(0|1|2|4|5|6|7|8)" r"(-| |)" r"\d{7}$"
-    )
+    pattern = re.compile(r"^(?:0|94|\+94|0{2}94)7(0|1|2|4|5|6|7|8)(-| |)\d{7}$")
 
     return bool(re.search(pattern, phone))
 

strings/is_valid_email_address.py

@@ -0,0 +1,117 @@
+"""
+Implements an is valid email address algorithm
+
+@ https://en.wikipedia.org/wiki/Email_address
+"""
+
+import string
+
+email_tests: tuple[tuple[str, bool], ...] = (
+    ("simple@example.com", True),
+    ("very.common@example.com", True),
+    ("disposable.style.email.with+symbol@example.com", True),
+    ("other-email-with-hyphen@and.subdomains.example.com", True),
+    ("fully-qualified-domain@example.com", True),
+    ("user.name+tag+sorting@example.com", True),
+    ("x@example.com", True),
+    ("example-indeed@strange-example.com", True),
+    ("test/test@test.com", True),
+    (
+        "123456789012345678901234567890123456789012345678901234567890123@example.com",
+        True,
+    ),
+    ("admin@mailserver1", True),
+    ("example@s.example", True),
+    ("Abc.example.com", False),
+    ("A@b@c@example.com", False),
+    ("abc@example..com", False),
+    ("a(c)d,e:f;g<h>i[j\\k]l@example.com", False),
+    (
+        "12345678901234567890123456789012345678901234567890123456789012345@example.com",
+        False,
+    ),
+    ("i.like.underscores@but_its_not_allowed_in_this_part", False),
+    ("", False),
+)
+
+# The maximum octets (one character as a standard unicode character is one byte)
+# that the local part and the domain part can have
+MAX_LOCAL_PART_OCTETS = 64
+MAX_DOMAIN_OCTETS = 255
+
+
+def is_valid_email_address(email: str) -> bool:
+    """
+    Returns True if the passed email address is valid.
+
+    The local part of the email precedes the singular @ symbol and
+    is associated with a display-name. For example, "john.smith"
+    The domain is stricter than the local part and follows the @ symbol.
+
+    Global email checks:
+     1. There can only be one @ symbol in the email address. Technically if the
+        @ symbol is quoted in the local-part, then it is valid, however this
+        implementation ignores "" for now.
+        (See https://en.wikipedia.org/wiki/Email_address#:~:text=If%20quoted,)
+     2. The local-part and the domain are limited to a certain number of octets. With
+        unicode storing a single character in one byte, each octet is equivalent to
+        a character. Hence, we can just check the length of the string.
+    Checks for the local-part:
+     3. The local-part may contain: upper and lowercase latin letters, digits 0 to 9,
+        and printable characters (!#$%&'*+-/=?^_`{|}~)
+     4. The local-part may also contain a "." in any place that is not the first or
+        last character, and may not have more than one "." consecutively.
+
+    Checks for the domain:
+     5. The domain may contain: upper and lowercase latin letters and digits 0 to 9
+     6. Hyphen "-", provided that it is not the first or last character
+     7. The domain may also contain a "." in any place that is not the first or
+        last character, and may not have more than one "." consecutively.
+
+    >>> for email, valid in email_tests:
+    ...     assert is_valid_email_address(email) == valid
+    """
+
+    # (1.) Make sure that there is only one @ symbol in the email address
+    if email.count("@") != 1:
+        return False
+
+    local_part, domain = email.split("@")
+    # (2.) Check octet length of the local part and domain
+    if len(local_part) > MAX_LOCAL_PART_OCTETS or len(domain) > MAX_DOMAIN_OCTETS:
+        return False
+
+    # (3.) Validate the characters in the local-part
+    if any(
+        char not in string.ascii_letters + string.digits + ".(!#$%&'*+-/=?^_`{|}~)"
+        for char in local_part
+    ):
+        return False
+
+    # (4.) Validate the placement of "." characters in the local-part
+    if local_part.startswith(".") or local_part.endswith(".") or ".." in local_part:
+        return False
+
+    # (5.) Validate the characters in the domain
+    if any(char not in string.ascii_letters + string.digits + ".-" for char in domain):
+        return False
+
+    # (6.) Validate the placement of "-" characters
+    if domain.startswith("-") or domain.endswith("."):
+        return False
+
+    # (7.) Validate the placement of "." characters
+    if domain.startswith(".") or domain.endswith(".") or ".." in domain:
+        return False
+    return True
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+
+    for email, valid in email_tests:
+        is_valid = is_valid_email_address(email)
+        assert is_valid == valid, f"{email} is {is_valid}"
+        print(f"Email address {email} is {'not ' if not is_valid else ''}valid")

web_programming/covid_stats_via_xpath.py

@@ -4,17 +4,21 @@ This is to show simple COVID19 info fetching from worldometers site using lxml
 more convenient to use in Python web projects (e.g. Django or Flask-based)
 """
 
-from collections import namedtuple
+from typing import NamedTuple
 
 import requests
 from lxml import html  # type: ignore
 
-covid_data = namedtuple("covid_data", "cases deaths recovered")
+
+class CovidData(NamedTuple):
+    cases: int
+    deaths: int
+    recovered: int
 
 
-def covid_stats(url: str = "https://www.worldometers.info/coronavirus/") -> covid_data:
+def covid_stats(url: str = "https://www.worldometers.info/coronavirus/") -> CovidData:
     xpath_str = '//div[@class = "maincounter-number"]/span/text()'
-    return covid_data(*html.fromstring(requests.get(url).content).xpath(xpath_str))
+    return CovidData(*html.fromstring(requests.get(url).content).xpath(xpath_str))
 
 
 fmt = """Total COVID-19 cases in the world: {}

web_programming/current_stock_price.py

@@ -3,12 +3,18 @@ from bs4 import BeautifulSoup
 
 
 def stock_price(symbol: str = "AAPL") -> str:
-    url = f"https://in.finance.yahoo.com/quote/{symbol}?s={symbol}"
-    soup = BeautifulSoup(requests.get(url).text, "html.parser")
-    class_ = "My(6px) Pos(r) smartphone_Mt(6px)"
-    return soup.find("div", class_=class_).find("span").text
+    url = f"https://finance.yahoo.com/quote/{symbol}?p={symbol}"
+    yahoo_finance_source = requests.get(url, headers={"USER-AGENT": "Mozilla/5.0"}).text
+    soup = BeautifulSoup(yahoo_finance_source, "html.parser")
+    specific_fin_streamer_tag = soup.find("fin-streamer", {"data-test": "qsp-price"})
+
+    if specific_fin_streamer_tag:
+        text = specific_fin_streamer_tag.get_text()
+        return text
+    return "No <fin-streamer> tag with the specified data-test attribute found."
 
 
+# Search for the symbol at https://finance.yahoo.com/lookup
 if __name__ == "__main__":
     for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
         print(f"Current {symbol:<4} stock price is {stock_price(symbol):>8}")

web_programming/world_covid19_stats.py

@@ -22,6 +22,5 @@ def world_covid19_stats(url: str = "https://www.worldometers.info/coronavirus")
 
 
 if __name__ == "__main__":
-    print("\033[1m" + "COVID-19 Status of the World" + "\033[0m\n")
-    for key, value in world_covid19_stats().items():
-        print(f"{key}\n{value}\n")
+    print("\033[1m COVID-19 Status of the World \033[0m\n")
+    print("\n".join(f"{key}\n{value}" for key, value in world_covid19_stats().items()))