Reformatted function_optimization.py using black

Author: KelvinPuyam

genetic_algorithm/function_optimization.py

@@ -13,6 +13,7 @@
 MUTATION_PROBABILITY = 0.1
 NUM_GENERATIONS = 50
 
+
 def evaluate(func: Callable, params: List[float]) -> float:
     """
     Evaluate the fitness of an individual based on the provided function.
@@ -25,12 +26,14 @@ def evaluate(func: Callable, params: List[float]) -> float:
     """
     return func(*params)
 
+
 def crossover(parent_1: List[float], parent_2: List[float]) -> List[float]:
     """Perform crossover between two parents."""
     crossover_point = random.randint(1, len(parent_1) - 1)
     child = parent_1[:crossover_point] + parent_2[crossover_point:]
     return child
 
+
 def mutate(individual: List[float], mutation_rate: float) -> List[float]:
     """Mutate an individual with a certain probability."""
     mutated_individual = []
@@ -43,21 +46,37 @@ def mutate(individual: List[float], mutation_rate: float) -> List[float]:
             mutated_individual.append(gene)
     return mutated_individual
 
-def select(population: List[Tuple[List[float], float]], num_selected: int) -> List[List[float]]:
+
+def select(
+    population: List[Tuple[List[float], float]], num_selected: int
+) -> List[List[float]]:
     """Select individuals based on their fitness scores."""
     sorted_population = sorted(population, key=lambda x: x[1])
-    selected_parents = [individual[0] for individual in sorted_population[:num_selected]]
+    selected_parents = [
+        individual[0] for individual in sorted_population[:num_selected]
+    ]
     return selected_parents
 
-def optimize(func: Callable, num_params: int, param_ranges: List[Tuple[float, float]], optimization_goal: str) -> Tuple[List[float], float]:
+
+def optimize(
+    func: Callable,
+    num_params: int,
+    param_ranges: List[Tuple[float, float]],
+    optimization_goal: str,
+) -> Tuple[List[float], float]:
     """Optimize the given function using a genetic algorithm."""
     # Initialize the population
-    population = [[random.uniform(param_range[0], param_range[1]) for param_range in param_ranges] for _ in range(N_POPULATION)]
+    population = [
+        [random.uniform(param_range[0], param_range[1]) for param_range in param_ranges]
+        for _ in range(N_POPULATION)
+    ]
 
     # Main optimization loop
     for generation in range(NUM_GENERATIONS):
         # Evaluate the fitness of each individual in the population
-        population_fitness = [(individual, evaluate(func, individual)) for individual in population]
+        population_fitness = [
+            (individual, evaluate(func, individual)) for individual in population
+        ]
 
         # Select parents for crossover
         selected_parents = select(population_fitness, N_SELECTED)
@@ -79,16 +98,19 @@ def optimize(func: Callable, num_params: int, param_ranges: List[Tuple[float, fl
 
     return best_individual, best_fitness
 
+
 if __name__ == "__main__":
     # Set random seed for reproducibility
     random.seed(123)
 
     # Example usage:
     def quadratic_function(x, y):
         """Example function to optimize."""
-        return x ** 2 + y ** 2
+        return x**2 + y**2
 
     param_ranges = [(-10, 10), (-10, 10)]
-    best_params, best_fitness = optimize(quadratic_function, 2, param_ranges, "minimize")
+    best_params, best_fitness = optimize(
+        quadratic_function, 2, param_ranges, "minimize"
+    )
     print("Best parameters:", best_params)
     print("Best fitness:", best_fitness)