[UPDATED] rat_in_maze.py

DIRECTORY.md

@@ -43,6 +43,7 @@
   * [Binary Shifts](bit_manipulation/binary_shifts.py)
   * [Binary Twos Complement](bit_manipulation/binary_twos_complement.py)
   * [Binary Xor Operator](bit_manipulation/binary_xor_operator.py)
+  * [Bitwise Addition Recursive](bit_manipulation/bitwise_addition_recursive.py)
   * [Count 1S Brian Kernighan Method](bit_manipulation/count_1s_brian_kernighan_method.py)
   * [Count Number Of One Bits](bit_manipulation/count_number_of_one_bits.py)
   * [Gray Code Sequence](bit_manipulation/gray_code_sequence.py)
@@ -507,14 +508,14 @@
   * [Gradient Descent](machine_learning/gradient_descent.py)
   * [K Means Clust](machine_learning/k_means_clust.py)
   * [K Nearest Neighbours](machine_learning/k_nearest_neighbours.py)
-  * [Knn Sklearn](machine_learning/knn_sklearn.py)
   * [Linear Discriminant Analysis](machine_learning/linear_discriminant_analysis.py)
   * [Linear Regression](machine_learning/linear_regression.py)
   * Local Weighted Learning
     * [Local Weighted Learning](machine_learning/local_weighted_learning/local_weighted_learning.py)
   * [Logistic Regression](machine_learning/logistic_regression.py)
   * Lstm
     * [Lstm Prediction](machine_learning/lstm/lstm_prediction.py)
+  * [Mfcc](machine_learning/mfcc.py)
   * [Multilayer Perceptron Classifier](machine_learning/multilayer_perceptron_classifier.py)
   * [Polynomial Regression](machine_learning/polynomial_regression.py)
   * [Scoring Functions](machine_learning/scoring_functions.py)
@@ -753,6 +754,7 @@
   * [Basic Orbital Capture](physics/basic_orbital_capture.py)
   * [Casimir Effect](physics/casimir_effect.py)
   * [Centripetal Force](physics/centripetal_force.py)
+  * [Coulombs Law](physics/coulombs_law.py)
   * [Grahams Law](physics/grahams_law.py)
   * [Horizontal Projectile Motion](physics/horizontal_projectile_motion.py)
   * [Hubble Parameter](physics/hubble_parameter.py)

bit_manipulation/bitwise_addition_recursive.py

@@ -0,0 +1,55 @@
+"""
+Calculates the sum of two non-negative integers using bitwise operators
+Wikipedia explanation: https://en.wikipedia.org/wiki/Binary_number
+"""
+
+
+def bitwise_addition_recursive(number: int, other_number: int) -> int:
+    """
+    >>> bitwise_addition_recursive(4, 5)
+    9
+    >>> bitwise_addition_recursive(8, 9)
+    17
+    >>> bitwise_addition_recursive(0, 4)
+    4
+    >>> bitwise_addition_recursive(4.5, 9)
+    Traceback (most recent call last):
+        ...
+    TypeError: Both arguments MUST be integers!
+    >>> bitwise_addition_recursive('4', 9)
+    Traceback (most recent call last):
+        ...
+    TypeError: Both arguments MUST be integers!
+    >>> bitwise_addition_recursive('4.5', 9)
+    Traceback (most recent call last):
+        ...
+    TypeError: Both arguments MUST be integers!
+    >>> bitwise_addition_recursive(-1, 9)
+    Traceback (most recent call last):
+        ...
+    ValueError: Both arguments MUST be non-negative!
+    >>> bitwise_addition_recursive(1, -9)
+    Traceback (most recent call last):
+        ...
+    ValueError: Both arguments MUST be non-negative!
+    """
+
+    if not isinstance(number, int) or not isinstance(other_number, int):
+        raise TypeError("Both arguments MUST be integers!")
+
+    if number < 0 or other_number < 0:
+        raise ValueError("Both arguments MUST be non-negative!")
+
+    bitwise_sum = number ^ other_number
+    carry = number & other_number
+
+    if carry == 0:
+        return bitwise_sum
+
+    return bitwise_addition_recursive(bitwise_sum, carry << 1)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

digital_image_processing/morphological_operations/erosion_operation.py

@@ -1,44 +1,48 @@
+from pathlib import Path
+
 import numpy as np
 from PIL import Image
 
 
-def rgb2gray(rgb: np.array) -> np.array:
+def rgb_to_gray(rgb: np.ndarray) -> np.ndarray:
     """
     Return gray image from rgb image
-    >>> rgb2gray(np.array([[[127, 255, 0]]]))
+
+    >>> rgb_to_gray(np.array([[[127, 255, 0]]]))
     array([[187.6453]])
-    >>> rgb2gray(np.array([[[0, 0, 0]]]))
+    >>> rgb_to_gray(np.array([[[0, 0, 0]]]))
     array([[0.]])
-    >>> rgb2gray(np.array([[[2, 4, 1]]]))
+    >>> rgb_to_gray(np.array([[[2, 4, 1]]]))
     array([[3.0598]])
-    >>> rgb2gray(np.array([[[26, 255, 14], [5, 147, 20], [1, 200, 0]]]))
+    >>> rgb_to_gray(np.array([[[26, 255, 14], [5, 147, 20], [1, 200, 0]]]))
     array([[159.0524,  90.0635, 117.6989]])
     """
     r, g, b = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2]
     return 0.2989 * r + 0.5870 * g + 0.1140 * b
 
 
-def gray2binary(gray: np.array) -> np.array:
+def gray_to_binary(gray: np.ndarray) -> np.ndarray:
     """
     Return binary image from gray image
 
-    >>> gray2binary(np.array([[127, 255, 0]]))
+    >>> gray_to_binary(np.array([[127, 255, 0]]))
     array([[False,  True, False]])
-    >>> gray2binary(np.array([[0]]))
+    >>> gray_to_binary(np.array([[0]]))
     array([[False]])
-    >>> gray2binary(np.array([[26.2409, 4.9315, 1.4729]]))
+    >>> gray_to_binary(np.array([[26.2409, 4.9315, 1.4729]]))
     array([[False, False, False]])
-    >>> gray2binary(np.array([[26, 255, 14], [5, 147, 20], [1, 200, 0]]))
+    >>> gray_to_binary(np.array([[26, 255, 14], [5, 147, 20], [1, 200, 0]]))
     array([[False,  True, False],
            [False,  True, False],
            [False,  True, False]])
     """
     return (gray > 127) & (gray <= 255)
 
 
-def erosion(image: np.array, kernel: np.array) -> np.array:
+def erosion(image: np.ndarray, kernel: np.ndarray) -> np.ndarray:
     """
     Return eroded image
+
     >>> erosion(np.array([[True, True, False]]), np.array([[0, 1, 0]]))
     array([[False, False, False]])
     >>> erosion(np.array([[True, False, False]]), np.array([[1, 1, 0]]))
@@ -62,14 +66,17 @@ def erosion(image: np.array, kernel: np.array) -> np.array:
     return output
 
 
-# kernel to be applied
-structuring_element = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]])
-
 if __name__ == "__main__":
     # read original image
-    image = np.array(Image.open(r"..\image_data\lena.jpg"))
+    lena_path = Path(__file__).resolve().parent / "image_data" / "lena.jpg"
+    lena = np.array(Image.open(lena_path))
+
+    # kernel to be applied
+    structuring_element = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]])
+
     # Apply erosion operation to a binary image
-    output = erosion(gray2binary(rgb2gray(image)), structuring_element)
+    output = erosion(gray_to_binary(rgb_to_gray(lena)), structuring_element)
+
     # Save the output image
     pil_img = Image.fromarray(output).convert("RGB")
     pil_img.save("result_erosion.png")

machine_learning/k_means_clust.py

@@ -11,10 +11,10 @@
   - initial_centroids , initial centroid values generated by utility function(mentioned
     in usage).
   - maxiter , maximum number of iterations to process.
-  - heterogeneity , empty list that will be filled with hetrogeneity values if passed
+  - heterogeneity , empty list that will be filled with heterogeneity values if passed
     to kmeans func.
 Usage:
-  1. define 'k' value, 'X' features array and 'hetrogeneity' empty list
+  1. define 'k' value, 'X' features array and 'heterogeneity' empty list
   2. create initial_centroids,
         initial_centroids = get_initial_centroids(
             X,
@@ -31,8 +31,8 @@
             record_heterogeneity=heterogeneity,
             verbose=True # whether to print logs in console or not.(default=False)
             )
-  4. Plot the loss function, hetrogeneity values for every iteration saved in
-     hetrogeneity list.
+  4. Plot the loss function and heterogeneity values for every iteration saved in
+     heterogeneity list.
         plot_heterogeneity(
             heterogeneity,
             k
@@ -198,13 +198,10 @@ def report_generator(
     df: pd.DataFrame, clustering_variables: np.ndarray, fill_missing_report=None
 ) -> pd.DataFrame:
     """
-    Function generates easy-erading clustering report. It takes 2 arguments as an input:
-        DataFrame - dataframe with predicted cluester column;
-        FillMissingReport - dictionary of rules how we are going to fill missing
-        values of for final report generate (not included in modeling);
-    in order to run the function following libraries must be imported:
-        import pandas as pd
-        import numpy as np
+    Generates a clustering report. This function takes 2 arguments as input:
+        df - dataframe with predicted cluster column
+        fill_missing_report - dictionary of rules on how we are going to fill in missing
+        values for final generated report (not included in modelling);
     >>> data = pd.DataFrame()
     >>> data['numbers'] = [1, 2, 3]
     >>> data['col1'] = [0.5, 2.5, 4.5]
@@ -306,10 +303,10 @@ def report_generator(
     a.columns = report.columns  # rename columns to match report
     report = report.drop(
         report[report.Type == "count"].index
-    )  # drop count values except cluster size
+    )  # drop count values except for cluster size
     report = pd.concat(
         [report, a, clustersize, clusterproportion], axis=0
-    )  # concat report with clustert size and nan values
+    )  # concat report with cluster size and nan values
     report["Mark"] = report["Features"].isin(clustering_variables)
     cols = report.columns.tolist()
     cols = cols[0:2] + cols[-1:] + cols[2:-1]

machine_learning/k_nearest_neighbours.py

@@ -1,58 +1,88 @@
+"""
+k-Nearest Neighbours (kNN) is a simple non-parametric supervised learning
+algorithm used for classification. Given some labelled training data, a given
+point is classified using its k nearest neighbours according to some distance
+metric. The most commonly occurring label among the neighbours becomes the label
+of the given point. In effect, the label of the given point is decided by a
+majority vote.
+
+This implementation uses the commonly used Euclidean distance metric, but other
+distance metrics can also be used.
+
+Reference: https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm
+"""
+
 from collections import Counter
+from heapq import nsmallest
 
 import numpy as np
 from sklearn import datasets
 from sklearn.model_selection import train_test_split
 
-data = datasets.load_iris()
-
-X = np.array(data["data"])
-y = np.array(data["target"])
-classes = data["target_names"]
-
-X_train, X_test, y_train, y_test = train_test_split(X, y)
-
-
-def euclidean_distance(a, b):
-    """
-    Gives the euclidean distance between two points
-    >>> euclidean_distance([0, 0], [3, 4])
-    5.0
-    >>> euclidean_distance([1, 2, 3], [1, 8, 11])
-    10.0
-    """
-    return np.linalg.norm(np.array(a) - np.array(b))
-
-
-def classifier(train_data, train_target, classes, point, k=5):
-    """
-    Classifies the point using the KNN algorithm
-    k closest points are found (ranked in ascending order of euclidean distance)
-    Params:
-    :train_data: Set of points that are classified into two or more classes
-    :train_target: List of classes in the order of train_data points
-    :classes: Labels of the classes
-    :point: The data point that needs to be classified
-
-    >>> X_train = [[0, 0], [1, 0], [0, 1], [0.5, 0.5], [3, 3], [2, 3], [3, 2]]
-    >>> y_train = [0, 0, 0, 0, 1, 1, 1]
-    >>> classes = ['A','B']; point = [1.2,1.2]
-    >>> classifier(X_train, y_train, classes,point)
-    'A'
-    """
-    data = zip(train_data, train_target)
-    # List of distances of all points from the point to be classified
-    distances = []
-    for data_point in data:
-        distance = euclidean_distance(data_point[0], point)
-        distances.append((distance, data_point[1]))
-    # Choosing 'k' points with the least distances.
-    votes = [i[1] for i in sorted(distances)[:k]]
-    # Most commonly occurring class among them
-    # is the class into which the point is classified
-    result = Counter(votes).most_common(1)[0][0]
-    return classes[result]
+
+class KNN:
+    def __init__(
+        self,
+        train_data: np.ndarray[float],
+        train_target: np.ndarray[int],
+        class_labels: list[str],
+    ) -> None:
+        """
+        Create a kNN classifier using the given training data and class labels
+        """
+        self.data = zip(train_data, train_target)
+        self.labels = class_labels
+
+    @staticmethod
+    def _euclidean_distance(a: np.ndarray[float], b: np.ndarray[float]) -> float:
+        """
+        Calculate the Euclidean distance between two points
+        >>> KNN._euclidean_distance(np.array([0, 0]), np.array([3, 4]))
+        5.0
+        >>> KNN._euclidean_distance(np.array([1, 2, 3]), np.array([1, 8, 11]))
+        10.0
+        """
+        return np.linalg.norm(a - b)
+
+    def classify(self, pred_point: np.ndarray[float], k: int = 5) -> str:
+        """
+        Classify a given point using the kNN algorithm
+        >>> train_X = np.array(
+        ...     [[0, 0], [1, 0], [0, 1], [0.5, 0.5], [3, 3], [2, 3], [3, 2]]
+        ... )
+        >>> train_y = np.array([0, 0, 0, 0, 1, 1, 1])
+        >>> classes = ['A', 'B']
+        >>> knn = KNN(train_X, train_y, classes)
+        >>> point = np.array([1.2, 1.2])
+        >>> knn.classify(point)
+        'A'
+        """
+        # Distances of all points from the point to be classified
+        distances = (
+            (self._euclidean_distance(data_point[0], pred_point), data_point[1])
+            for data_point in self.data
+        )
+
+        # Choosing k points with the shortest distances
+        votes = (i[1] for i in nsmallest(k, distances))
+
+        # Most commonly occurring class is the one into which the point is classified
+        result = Counter(votes).most_common(1)[0][0]
+        return self.labels[result]
 
 
 if __name__ == "__main__":
-    print(classifier(X_train, y_train, classes, [4.4, 3.1, 1.3, 1.4]))
+    import doctest
+
+    doctest.testmod()
+
+    iris = datasets.load_iris()
+
+    X = np.array(iris["data"])
+    y = np.array(iris["target"])
+    iris_classes = iris["target_names"]
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
+    iris_point = np.array([4.4, 3.1, 1.3, 1.4])
+    classifier = KNN(X_train, y_train, iris_classes)
+    print(classifier.classify(iris_point, k=3))