Added Clamping Tests (#60)

* Starting my testing

* Generated first test

* Added another test

* Added yet more tests

* Automated function list

* Reworked test bench to automate function collection

* Cleaned up code

* Reworked all solutions to use simplified test bench

* Added comments

* Added a large numbers test

Author: jrg94

testing/__init__.py

@@ -2,5 +2,7 @@
 from os.path import dirname, basename, isfile, join
 
 modules = glob.glob(join(dirname(__file__), "*.py"))
-__all__ = [basename(f)[:-3] for f in modules if
-           isfile(f) and not f.endswith('__init__.py') and not f.endswith("test_bench.py")]
+__all__ = [
+    basename(f)[:-3] for f in modules 
+    if isfile(f) and not f.endswith('__init__.py') and not f.endswith("test_bench.py")
+]

testing/how_to_capitalize_a_string.py

@@ -73,25 +73,11 @@ def capitalize(string: str) -> str:
     return string.capitalize()
 
 
-def main() -> None:
-    """
-    Tests the performance of all the functions defined in this file.
-    """
+if __name__ == '__main__':
     test_bench(
-        [
-            control,
-            capitalize_by_hand,
-            capitalize_by_mapping,
-            capitalize_with_upper,
-            capitalize
-        ],
         {
             "One Letter String": ["a"],
             "Small String": ["how now brown cow"],
             "Large String": ["One Punch Man" * 100]
         }
     )
-
-
-if __name__ == '__main__':
-    main()

testing/how_to_clamp_a_float.py

@@ -0,0 +1,81 @@
+"""
+Tests the performance of all of the solutions listed in the following article:
+https://therenegadecoder.com/code/how-to-clamp-a-floating-point-number-in-python/
+"""
+
+from test_bench import test_bench
+
+
+def control(*_) -> None:
+    """
+    Provides a control scenario for testing. In this case, none of the functions
+    share any overhead, so this function is empty.
+
+    :param _: a placeholder for the string input
+    :return: None
+    """
+    pass
+
+
+def clamp_float_with_branching_nested(num: float, minimum: float, maximum: float) -> float:
+    """
+    Clamps a float between two bounds using a series of if statements.
+
+    :param num: the value to clamp
+    :param minimum: the lower bound
+    :param maximum: the upper bound
+    :return: a value in the range of minimum and maximum
+    """
+    if num < minimum:
+        return minimum
+    elif num > maximum:
+        return maximum
+    else:
+        return num
+
+
+def clamp_float_with_branching_flat(num: float, minimum: float, maximum: float) -> float:
+    """
+    Clamps a float between two bounds using a series of ternary statements.
+
+    :param num: the value to clamp
+    :param minimum: the lower bound
+    :param maximum: the upper bound
+    :return: a value in the range of minimum and maximum
+    """
+    return minimum if num < minimum else maximum if num > maximum else num
+
+
+def clamp_float_with_min_and_max(num: float, minimum: float, maximum: float) -> float:
+    """
+    Clamps a float between two bounds using a mix of min and max functions.
+
+    :param num: the value to clamp
+    :param minimum: the lower bound
+    :param maximum: the upper bound
+    :return: a value in the range of minimum and maximum
+    """
+    return max(min(num, maximum), minimum)
+
+
+def clamp_float_with_sorting(num: float, minimum: float, maximum: float) -> float:
+    """
+    Clamps a float between two bounds using a sorting technique.
+
+    :param num: the value to clamp
+    :param minimum: the lower bound
+    :param maximum: the upper bound
+    :return: a value in the range of minimum and maximum
+    """
+    sorted([num, minimum, maximum])[1]
+
+
+if __name__ == "__main__":
+    test_bench(
+        {
+            "Lower Bound": [-.002, 0, .40],
+            "Upper Bound": [.402, 0, .40],
+            "Between Bounds": [.14, 0, .4],
+            "Large Numbers": [123456789, -432512317, 5487131463]
+        }
+    )

testing/how_to_convert_an_integer_to_a_string.py

@@ -47,25 +47,12 @@ def convert_by_interpolation(integer: int) -> str:
     return "%s" % integer
 
 
-def main() -> None:
-    """
-    Tests the performance of all the functions defined in this file.
-    """
+if __name__ == '__main__':
     test_bench(
-        [
-            control,
-            convert_by_type_casting,
-            convert_by_f_string,
-            convert_by_interpolation
-        ],
         {
             "Zero": [0],
             "Single Digit": [5],
             "Small Number": [1107321],
             "Massive Number": [2 ** 64]
         }
     )
-
-
-if __name__ == '__main__':
-    main()

testing/how_to_empty_a_list.py

@@ -10,7 +10,7 @@ def control(anime: list[str]) -> None:
     """
     Provides a control scenario for testing. In this case, all of the solutions
     rely on copying the input list, so the control function accounts for that.
-    
+
     :param anime: a list of anime 
     """
     anime = anime.copy()
@@ -19,7 +19,7 @@ def control(anime: list[str]) -> None:
 def empty_list_by_hand(anime: list[str]) -> None:
     """
     Empties a list by repeatedly removing elements from a list.  
-    
+
     :param anime: a list of anime
     """
     anime = anime.copy()
@@ -30,7 +30,7 @@ def empty_list_by_hand(anime: list[str]) -> None:
 def empty_list_by_assignment(anime: list[str]) -> None:
     """
     Empties a list by reassigning the reference.
-    
+
     :param anime: a list of anime
     """
     anime = anime.copy()
@@ -40,7 +40,7 @@ def empty_list_by_assignment(anime: list[str]) -> None:
 def empty_list_by_clear(anime: list[str]) -> None:
     """
     Empties a list by calling the clear method.
-    
+
     :param anime: a list of anime
     """
     anime = anime.copy()
@@ -50,7 +50,7 @@ def empty_list_by_clear(anime: list[str]) -> None:
 def empty_list_by_del(anime: list[str]) -> None:
     """
     Empties a list by deleting a slice of the list.
-    
+
     :param anime: a list of anime
     """
     anime = anime.copy()
@@ -60,7 +60,7 @@ def empty_list_by_del(anime: list[str]) -> None:
 def empty_list_by_slice_assignment(anime: list[str]) -> None:
     """
     Empties a list by replacing a slice of the list with an empty list.
-    
+
     :param anime: a list of anime
     """
     anime = anime.copy()
@@ -70,35 +70,19 @@ def empty_list_by_slice_assignment(anime: list[str]) -> None:
 def empty_list_by_multiplication(anime: list[str]) -> None:
     """
     Empties a list by multiplication.
-    
+
     :param anime: a list of anime
     """
     anime = anime.copy()
     anime *= 0  # Also, would not work as a function
 
 
-def main() -> None:
-    """
-    Tests the performance of all the functions defined in this file. 
-    """
+if __name__ == "__main__":
     test_bench(
-        [
-            control,
-            empty_list_by_hand,
-            empty_list_by_assignment,
-            empty_list_by_clear,
-            empty_list_by_del,
-            empty_list_by_slice_assignment,
-            empty_list_by_multiplication
-        ],
         {
             "Empty List": [[]],
             "One Item List": [["Your Lie in April"]],
             "Small List": [["My Hero Academia", "Attack on Titan", "Steins;Gate"]],
             "Large List": [["One Punch Man"] * 100]
         }
     )
-
-
-if __name__ == "__main__":
-    main()

testing/test_bench.py

@@ -1,28 +1,14 @@
-import importlib
 import inspect
 import os
 import timeit
+from inspect import getmembers, isfunction
 
 import matplotlib.pyplot as plt
 import pandas as pd
 import seaborn as sns
 
-import testing
 
-
-def run_suite() -> None:
-    """
-    An experimental function which allows us to run the main function of
-    all of our test files.
-
-    :return: None
-    """
-    for module_name in testing.__all__:
-        module = importlib.import_module(module_name)
-        module.main()
-
-
-def test_bench(funcs: list, test_data: dict):
+def test_bench(test_data: dict):
     """
     Given a list of functions and a list of dictionary of test data,
     this function will execute performance testing using all of the items
@@ -35,6 +21,12 @@ def test_bench(funcs: list, test_data: dict):
     :param funcs: a list of functions
     :param test_data: a dictionary of test data
     """
+    frame = inspect.stack()[1]
+    module = inspect.getmodule(frame[0])
+    funcs = [
+        member[1] for member in getmembers(module, isfunction)
+        if not "test_bench" in member[0]
+    ]
     results = _test_performance(funcs, test_data)
     _show_results(results)
 
@@ -86,11 +78,15 @@ def _show_results(results: pd.DataFrame):
             aspect=2
         )
     plt.title("How to Python: Function Performance Comparison", fontsize=16)
-    plt.legend(bbox_to_anchor=(1.05, 1), loc=2, title="Functions", fontsize='12', title_fontsize='12')
+    plt.legend(
+        bbox_to_anchor=(1.05, 1),
+        loc=2,
+        title="Functions",
+        fontsize='12',
+        title_fontsize='12'
+    )
     plt.tight_layout()
-    filename = os.path.splitext(os.path.basename(inspect.stack()[2].filename))[0]
-    plt.savefig(f"{os.path.join('visualizations', filename)}.png")
-
-
-if __name__ == '__main__':
-    run_suite()
+    filename = os.path.splitext(
+        os.path.basename(inspect.stack()[2].filename)
+    )[0]
+    plt.savefig(f"{os.path.join('testing', 'visualizations', filename)}.png")