chore: improve comments and add tests to trapezoidal rule

DIRECTORY.md

@@ -142,6 +142,7 @@
   * [Haralick Descriptors](computer_vision/haralick_descriptors.py)
   * [Harris Corner](computer_vision/harris_corner.py)
   * [Horn Schunck](computer_vision/horn_schunck.py)
+  * [Intensity Based Segmentation](computer_vision/intensity_based_segmentation.py)
   * [Mean Threshold](computer_vision/mean_threshold.py)
   * [Mosaic Augmentation](computer_vision/mosaic_augmentation.py)
   * [Pooling Functions](computer_vision/pooling_functions.py)
@@ -507,6 +508,7 @@
   * [Kahns Algorithm Long](graphs/kahns_algorithm_long.py)
   * [Kahns Algorithm Topo](graphs/kahns_algorithm_topo.py)
   * [Karger](graphs/karger.py)
+  * [Lanczos Eigenvectors](graphs/lanczos_eigenvectors.py)
   * [Markov Chain](graphs/markov_chain.py)
   * [Matching Min Vertex Cover](graphs/matching_min_vertex_cover.py)
   * [Minimum Path Sum](graphs/minimum_path_sum.py)
@@ -886,6 +888,7 @@
   * [N Body Simulation](physics/n_body_simulation.py)
   * [Newtons Law Of Gravitation](physics/newtons_law_of_gravitation.py)
   * [Newtons Second Law Of Motion](physics/newtons_second_law_of_motion.py)
+  * [Period Of Pendulum](physics/period_of_pendulum.py)
   * [Photoelectric Effect](physics/photoelectric_effect.py)
   * [Potential Energy](physics/potential_energy.py)
   * [Rainfall Intensity](physics/rainfall_intensity.py)

maths/trapezoidal_rule.py

@@ -1,28 +1,25 @@
 """
 Numerical integration or quadrature for a smooth function f with known values at x_i
-
-This method is the classical approach of suming 'Equally Spaced Abscissas'
-
-method 1:
-"extended trapezoidal rule"
-int(f) = dx/2 * (f1 + 2f2 + ... + fn)
-
 """
 
 
-def method_1(boundary, steps):
+def trapezoidal_rule(boundary, steps):
     """
-    Apply the extended trapezoidal rule to approximate the integral of function f(x)
-    over the interval defined by 'boundary' with the number of 'steps'.
-
-    Args:
-        boundary (list of floats): A list containing the start and end values [a, b].
-        steps (int): The number of steps or subintervals.
-    Returns:
-        float: Approximation of the integral of f(x) over [a, b].
-    Examples:
-    >>> method_1([0, 1], 10)
-    0.3349999999999999
+    Implements the extended trapezoidal rule for numerical integration.
+    The function f(x) is provided below.
+
+    :param boundary: List containing the lower and upper bounds of integration [a, b]
+    :param steps: The number of steps (intervals) used in the approximation
+    :return: The numerical approximation of the integral
+
+    >>> abs(trapezoidal_rule([0, 1], 10) - 0.33333) < 0.01
+    True
+    >>> abs(trapezoidal_rule([0, 1], 100) - 0.33333) < 0.01
+    True
+    >>> abs(trapezoidal_rule([0, 2], 1000) - 2.66667) < 0.01
+    True
+    >>> abs(trapezoidal_rule([1, 2], 1000) - 2.33333) < 0.01
+    True
     """
     h = (boundary[1] - boundary[0]) / steps
     a = boundary[0]
@@ -31,57 +28,73 @@ def method_1(boundary, steps):
     y = 0.0
     y += (h / 2.0) * f(a)
     for i in x_i:
-        # print(i)
         y += h * f(i)
     y += (h / 2.0) * f(b)
     return y
 
 
 def make_points(a, b, h):
     """
-    Generates points between 'a' and 'b' with step size 'h', excluding the end points.
-    Args:
-        a (float): Start value
-        b (float): End value
-        h (float): Step size
-    Examples:
+    Generates points between a and b with step size h for trapezoidal integration.
+
+    :param a: The lower bound of integration
+    :param b: The upper bound of integration
+    :param h: The step size
+    :yield: The next x-value in the range (a, b)
+
+    >>> list(make_points(0, 1, 0.1))    # doctest: +NORMALIZE_WHITESPACE
+    [0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6, 0.7, 0.7999999999999999, \
+    0.8999999999999999]
     >>> list(make_points(0, 10, 2.5))
     [2.5, 5.0, 7.5]
-
     >>> list(make_points(0, 10, 2))
     [2, 4, 6, 8]
-
     >>> list(make_points(1, 21, 5))
     [6, 11, 16]
-
     >>> list(make_points(1, 5, 2))
     [3]
-
     >>> list(make_points(1, 4, 3))
     []
     """
     x = a + h
     while x <= (b - h):
         yield x
-        x = x + h
+        x += h
 
 
-def f(x):  # enter your function here
+def f(x):
     """
-    Example:
-    >>> f(2)
-    4
+    This is the function to integrate, f(x) = (x - 0)^2 = x^2.
+
+    :param x: The input value
+    :return: The value of f(x)
+
+    >>> f(0)
+    0
+    >>> f(1)
+    1
+    >>> f(0.5)
+    0.25
     """
-    y = (x - 0) * (x - 0)
-    return y
+    return x**2
 
 
 def main():
-    a = 0.0  # Lower bound of integration
-    b = 1.0  # Upper bound of integration
-    steps = 10.0  # define number of steps or resolution
-    boundary = [a, b]  # define boundary of integration
-    y = method_1(boundary, steps)
+    """
+    Main function to test the trapezoidal rule.
+    :a: Lower bound of integration
+    :b: Upper bound of integration
+    :steps: define number of steps or resolution
+    :boundary: define boundary of integration
+
+    >>> main()
+    y = 0.3349999999999999
+    """
+    a = 0.0
+    b = 1.0
+    steps = 10.0
+    boundary = [a, b]
+    y = trapezoidal_rule(boundary, steps)
     print(f"y = {y}")