Fix some numpy tests

Author: cclauss

computer_vision/haralick_descriptors.py

@@ -19,7 +19,7 @@ def root_mean_square_error(original: np.ndarray, reference: np.ndarray) -> float
         >>> root_mean_square_error(np.array([1, 2, 3]), np.array([6, 4, 2]))
         3.1622776601683795
     """
-    return np.sqrt(((original - reference) ** 2).mean())
+    return float(np.sqrt(((original - reference) ** 2).mean()))
 
 
 def normalize_image(
@@ -273,7 +273,7 @@ def haralick_descriptors(matrix: np.ndarray) -> list[float]:
         >>> morphological = opening_filter(binary)
         >>> mask_1 = binary_mask(gray, morphological)[0]
         >>> concurrency = matrix_concurrency(mask_1, (0, 1))
-        >>> haralick_descriptors(concurrency)
+        >>> [float(f) for f in haralick_descriptors(concurrency)]
         [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
     """
     # Function np.indices could be used for bigger input types,
@@ -335,7 +335,7 @@ def get_descriptors(
     return np.concatenate(descriptors, axis=None)
 
 
-def euclidean(point_1: np.ndarray, point_2: np.ndarray) -> np.float32:
+def euclidean(point_1: np.ndarray, point_2: np.ndarray) -> float:
     """
     Simple method for calculating the euclidean distance between two points,
     with type np.ndarray.
@@ -346,7 +346,7 @@ def euclidean(point_1: np.ndarray, point_2: np.ndarray) -> np.float32:
         >>> euclidean(a, b)
         3.3166247903554
     """
-    return np.sqrt(np.sum(np.square(point_1 - point_2)))
+    return float(np.sqrt(np.sum(np.square(point_1 - point_2))))
 
 
 def get_distances(descriptors: np.ndarray, base: int) -> list[tuple[int, float]]:

machine_learning/scoring_functions.py

@@ -20,11 +20,11 @@ def mae(predict, actual):
     """
     Examples(rounded for precision):
     >>> actual = [1,2,3];predict = [1,4,3]
-    >>> np.around(mae(predict,actual),decimals = 2)
+    >>> float(np.around(mae(predict,actual),decimals = 2))
     0.67
 
     >>> actual = [1,1,1];predict = [1,1,1]
-    >>> mae(predict,actual)
+    >>> float(mae(predict,actual))
     0.0
     """
     predict = np.array(predict)
@@ -41,11 +41,11 @@ def mse(predict, actual):
     """
     Examples(rounded for precision):
     >>> actual = [1,2,3];predict = [1,4,3]
-    >>> np.around(mse(predict,actual),decimals = 2)
+    >>> float(np.around(mse(predict,actual),decimals = 2))
     1.33
 
     >>> actual = [1,1,1];predict = [1,1,1]
-    >>> mse(predict,actual)
+    >>> float(mse(predict,actual))
     0.0
     """
     predict = np.array(predict)
@@ -67,7 +67,7 @@ def rmse(predict, actual):
     1.15
 
     >>> actual = [1,1,1];predict = [1,1,1]
-    >>> rmse(predict,actual)
+    >>> float(rmse(predict,actual))
     0.0
     """
     predict = np.array(predict)
@@ -84,12 +84,12 @@ def rmse(predict, actual):
 def rmsle(predict, actual):
     """
     Examples(rounded for precision):
-    >>> actual = [10,10,30];predict = [10,2,30]
-    >>> np.around(rmsle(predict,actual),decimals = 2)
+    >>> actual = [10,10,30];predict = [10,2,30])
+    >>> float(np.around(rmsle(predict,actual),decimals = 2)
     0.75
 
     >>> actual = [1,1,1];predict = [1,1,1]
-    >>> rmsle(predict,actual)
+    >>> float(rmsle(predict,actual))
     0.0
     """
     predict = np.array(predict)

machine_learning/similarity_search.py

@@ -153,7 +153,7 @@ def cosine_similarity(input_a: np.ndarray, input_b: np.ndarray) -> float:
     >>> cosine_similarity(np.array([1, 2]), np.array([6, 32]))
     0.9615239476408232
     """
-    return np.dot(input_a, input_b) / (norm(input_a) * norm(input_b))
+    return float(np.dot(input_a, input_b) / (norm(input_a) * norm(input_b)))
 
 
 if __name__ == "__main__":

machine_learning/support_vector_machines.py

@@ -14,11 +14,11 @@ def norm_squared(vector: ndarray) -> float:
     Returns:
         float: squared second norm of vector
 
-    >>> norm_squared([1, 2])
+    >>> int(norm_squared([1, 2]))
     5
-    >>> norm_squared(np.asarray([1, 2]))
+    >>> int(norm_squared(np.asarray([1, 2])))
     5
-    >>> norm_squared([0, 0])
+    >>> int(norm_squared([0, 0]))
     0
     """
     return np.dot(vector, vector)

maths/euclidean_distance.py

@@ -13,13 +13,13 @@ def euclidean_distance(vector_1: Vector, vector_2: Vector) -> VectorOut:
     """
     Calculate the distance between the two endpoints of two vectors.
     A vector is defined as a list, tuple, or numpy 1D array.
-    >>> euclidean_distance((0, 0), (2, 2))
+    >>> float(euclidean_distance((0, 0), (2, 2)))
     2.8284271247461903
-    >>> euclidean_distance(np.array([0, 0, 0]), np.array([2, 2, 2]))
+    >>> float(euclidean_distance(np.array([0, 0, 0]), np.array([2, 2, 2])))
     3.4641016151377544
-    >>> euclidean_distance(np.array([1, 2, 3, 4]), np.array([5, 6, 7, 8]))
+    >>> float(euclidean_distance(np.array([1, 2, 3, 4]), np.array([5, 6, 7, 8])))
     8.0
-    >>> euclidean_distance([1, 2, 3, 4], [5, 6, 7, 8])
+    >>> float(euclidean_distance([1, 2, 3, 4], [5, 6, 7, 8]))
     8.0
     """
     return np.sqrt(np.sum((np.asarray(vector_1) - np.asarray(vector_2)) ** 2))

maths/euler_method.py

@@ -26,7 +26,7 @@ def explicit_euler(
     ...     return y
     >>> y0 = 1
     >>> y = explicit_euler(f, y0, 0.0, 0.01, 5)
-    >>> y[-1]
+    >>> float(y[-1])
     144.77277243257308
     """
     n = int(np.ceil((x_end - x0) / step_size))

maths/euler_modified.py

@@ -24,13 +24,13 @@ def euler_modified(
     >>> def f1(x, y):
     ...     return -2*x*(y**2)
     >>> y = euler_modified(f1, 1.0, 0.0, 0.2, 1.0)
-    >>> y[-1]
+    >>> float(y[-1])
     0.503338255442106
     >>> import math
     >>> def f2(x, y):
     ...     return -2*y + (x**3)*math.exp(-2*x)
     >>> y = euler_modified(f2, 1.0, 0.0, 0.1, 0.3)
-    >>> y[-1]
+    >>> float(y[-1])
     0.5525976431951775
     """
     n = int(np.ceil((x_end - x0) / step_size))

maths/gaussian.py

@@ -5,7 +5,7 @@
 from numpy import exp, pi, sqrt
 
 
-def gaussian(x, mu: float = 0.0, sigma: float = 1.0) -> int:
+def gaussian(x, mu: float = 0.0, sigma: float = 1.0) -> float:
     """
     >>> gaussian(1)
     0.24197072451914337
@@ -53,7 +53,7 @@ def gaussian(x, mu: float = 0.0, sigma: float = 1.0) -> int:
     >>> gaussian(2523, mu=234234, sigma=3425)
     0.0
     """
-    return 1 / sqrt(2 * pi * sigma**2) * exp(-((x - mu) ** 2) / (2 * sigma**2))
+    return float(1 / sqrt(2 * pi * sigma**2) * exp(-((x - mu) ** 2) / (2 * sigma**2)))
 
 
 if __name__ == "__main__":

maths/minkowski_distance.py

@@ -19,7 +19,7 @@ def minkowski_distance(
     >>> minkowski_distance([1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0], 2)
     8.0
     >>> import numpy as np
-    >>> np.isclose(5.0, minkowski_distance([5.0], [0.0], 3))
+    >>> bool(np.isclose(5.0, minkowski_distance([5.0], [0.0], 3)))
     True
     >>> minkowski_distance([1.0], [2.0], -1)
     Traceback (most recent call last):

maths/numerical_analysis/adams_bashforth.py

@@ -102,7 +102,7 @@ def step_3(self) -> np.ndarray:
         >>> def f(x, y):
         ...     return x + y
         >>> y = AdamsBashforth(f, [0, 0.2, 0.4], [0, 0, 0.04], 0.2, 1).step_3()
-        >>> y[3]
+        >>> float(y[3])
         0.15533333333333332
 
         >>> AdamsBashforth(f, [0, 0.2], [0, 0], 0.2, 1).step_3()
@@ -140,9 +140,9 @@ def step_4(self) -> np.ndarray:
         ...     return x + y
         >>> y = AdamsBashforth(
         ...    f, [0, 0.2, 0.4, 0.6], [0, 0, 0.04, 0.128], 0.2, 1).step_4()
-        >>> y[4]
+        >>> float(y[4])
         0.30699999999999994
-        >>> y[5]
+        >>> float(y[5])
         0.5771083333333333
 
         >>> AdamsBashforth(f, [0, 0.2, 0.4], [0, 0, 0.04], 0.2, 1).step_4()
@@ -185,7 +185,7 @@ def step_5(self) -> np.ndarray:
         >>> y = AdamsBashforth(
         ...     f, [0, 0.2, 0.4, 0.6, 0.8], [0, 0.02140, 0.02140, 0.22211, 0.42536],
         ...     0.2, 1).step_5()
-        >>> y[-1]
+        >>> float(y[-1])
         0.05436839444444452
 
         >>> AdamsBashforth(f, [0, 0.2, 0.4], [0, 0, 0.04], 0.2, 1).step_5()

maths/numerical_analysis/runge_kutta_fehlberg_45.py

@@ -34,12 +34,12 @@ def runge_kutta_fehlberg_45(
     >>> def f(x, y):
     ...     return 1 + y**2
     >>> y = runge_kutta_fehlberg_45(f, 0, 0, 0.2, 1)
-    >>> y[1]
+    >>> float(y[1])
     0.2027100937470787
     >>> def f(x,y):
     ...     return x
     >>> y = runge_kutta_fehlberg_45(f, -1, 0, 0.2, 0)
-    >>> y[1]
+    >>> float(y[1])
     -0.18000000000000002
     >>> y = runge_kutta_fehlberg_45(5, 0, 0, 0.1, 1)
     Traceback (most recent call last):

maths/numerical_analysis/runge_kutta_gills.py

@@ -34,7 +34,7 @@ def runge_kutta_gills(
     >>> def f(x, y):
     ...     return (x-y)/2
     >>> y = runge_kutta_gills(f, 0, 3, 0.2, 5)
-    >>> y[-1]
+    >>> float(y[-1])
     3.4104259225717537
 
     >>> def f(x,y):

maths/softmax.py

@@ -28,7 +28,7 @@ def softmax(vector):
 
     The softmax vector adds up to one. We need to ceil to mitigate for
     precision
-    >>> np.ceil(np.sum(softmax([1,2,3,4])))
+    >>> float(np.ceil(np.sum(softmax([1,2,3,4]))))
     1.0
 
     >>> vec = np.array([5,5])

neural_network/two_hidden_layers_neural_network.py

@@ -64,7 +64,7 @@ def feedforward(self) -> np.ndarray:
         >>> nn = TwoHiddenLayerNeuralNetwork(input_val, output_val)
         >>> res = nn.feedforward()
         >>> array_sum = np.sum(res)
-        >>> np.isnan(array_sum)
+        >>> bool(np.isnan(array_sum))
         False
         """
         # Layer_between_input_and_first_hidden_layer is the layer connecting the
@@ -171,7 +171,7 @@ def train(self, output: np.ndarray, iterations: int, give_loss: bool) -> None:
         >>> first_iteration_weights = nn.feedforward()
         >>> nn.back_propagation()
         >>> updated_weights = nn.second_hidden_layer_and_output_layer_weights
-        >>> (first_iteration_weights == updated_weights).all()
+        >>> bool((first_iteration_weights == updated_weights).all())
         False
         """
         for iteration in range(1, iterations + 1):

other/bankers_algorithm.py

@@ -93,7 +93,7 @@ def __need_index_manager(self) -> dict[int, list[int]]:
         {0: [1, 2, 0, 3], 1: [0, 1, 3, 1], 2: [1, 1, 0, 2], 3: [1, 3, 2, 0],
          4: [2, 0, 0, 3]}
         """
-        return {self.__need().index(i): i for i in self.__need()}
+        return {self.__need().index(i): int(i) for i in self.__need()}
 
     def main(self, **kwargs) -> None:
         """

physics/in_static_equilibrium.py

@@ -53,7 +53,7 @@ def in_static_equilibrium(
     # summation of moments is zero
     moments: NDArray[float64] = cross(location, forces)
     sum_moments: float = sum(moments)
-    return abs(sum_moments) < eps
+    return bool(abs(sum_moments) < eps)
 
 
 if __name__ == "__main__":