evobench-lib 1.0.0__py3-none-any.whl

evobench/__init__.py

@@ -0,0 +1,80 @@
+"""
+evobench: Comprehensive Benchmarking Suite for Evolutionary Algorithms
+
+A Python framework for testing, comparing, and analyzing evolutionary algorithms
+and metaheuristics. Includes three baseline implementations (PSO, EDA, ABC),
+benchmark functions (Sphere, Rosenbrock, Ackley, Schwefel, Trid), and built-in
+statistical analysis tools.
+
+Basic Usage:
+    >>> from evobench import PSO, sphere
+    >>> bounds = [(-5, 5)] * 10
+    >>> optimizer = PSO(sphere, bounds, max_iterations=100)
+    >>> best_solution, best_fitness = optimizer.run()
+    >>> print(f"Best fitness: {best_fitness:.6e}")
+
+For advanced usage, reproducibility, and statistical comparison, see:
+    - docs/getting-started/SETUP_CONFIG.md
+    - docs/guide/PERFORMANCE_AND_REPRODUCIBILITY.md
+    - docs/reference/index.md
+"""
+
+__version__ = "1.0.0"
+__author__ = "Enrique Gómez Linares, Victoria Galván Delgadillo"
+__license__ = "GPL-3"
+
+
+# ALGORITHM EXPORTS
+
+from evobench.algorithms import PSO, EDA, ABC
+
+from evobench.base import EvolutionaryAlgorithm
+
+
+# BENCHMARK FUNCTION EXPORTS
+
+from evobench.benchmarks import (
+    sphere,
+    rosenbrock,
+    ackley,
+    schwefel,
+    trid,
+    get_benchmark,
+    BENCHMARK_REGISTRY,
+)
+
+
+# STATISTICAL ANALYSIS EXPORTS
+
+from .stats import analyze, stat_report
+
+
+# UTILITIES EXPORTS
+
+from .tools import run as run_automated_experiment
+
+
+# PUBLIC API DEFINITION
+
+__all__ = [
+    # Core algorithms
+    "PSO",
+    "EDA",
+    "ABC",
+    "EvolutionaryAlgorithm",
+    # Benchmark functions (individual)
+    "sphere",
+    "rosenbrock",
+    "ackley",
+    "schwefel",
+    "trid",
+    # Benchmark utilities
+    "get_benchmark",
+    "BENCHMARK_REGISTRY",
+    # Statistical analysis
+    "analyze",
+    "stat_report",
+    # Experiment tools
+    "run_automated_experiment",
+
+]

evobench/algorithms/__init__.py

@@ -0,0 +1,19 @@
+"""
+Optimization Algorithms Module.
+
+This module provides implementations of various evolutionary and swarm-based
+metaheuristics. The algorithms are exported with their standard acronyms 
+for ease of use.
+"""
+
+# Importamos las clases con sus nombres completos y les asignamos el alias oficial
+from .eda import EstimationOfDistributionAlgorithm as EDA
+from .pso import ParticleSwarmOptimization as PSO
+from .bee import ArtificialBeeColony as ABC
+
+# Definimos exactamente qué se expone cuando alguien importa este módulo
+__all__ = [
+    "EDA", 
+    "PSO", 
+    "ABC"
+]

evobench/algorithms/bee.py

@@ -0,0 +1,155 @@
+import numpy as np
+from typing import Callable, Tuple
+from evobench.base import EvolutionaryAlgorithm
+import evobench.tools.operators as ops
+
+class ArtificialBeeColony(EvolutionaryAlgorithm):
+    """
+    Artificial Bee Colony (ABC) metaheuristic for continuous optimization.
+
+    This algorithm mimics the intelligent foraging behavior of a honey bee swarm. 
+    The population is divided into three groups: Employed Bees, Onlooker Bees, 
+    and Scout Bees. It utilizes a trial-counter mechanism to manage food source 
+    exhaustion, ensuring the swarm escapes local optima through a structured 
+    stagnation-replacement strategy.
+    """
+
+    def __init__(
+        self, 
+        objective_function: Callable[[np.ndarray], float], 
+        bounds: np.ndarray, 
+        population_size: int = 50, 
+        max_iterations: int = 100, 
+        limit: int = 20
+    ) -> None:
+        """
+        Initializes the ABC hyperparameters and structural attributes.
+
+        Args:
+            objective_function (Callable): The mathematical function to minimize.
+            bounds (np.ndarray): Spatial boundaries [min, max] for each dimension.
+            population_size (int): Total number of bees. Half will be employed.
+            max_iterations (int): Maximum number of search cycles.
+            limit (int): Trials allowed before a food source is abandoned.
+        """
+        super().__init__(objective_function, bounds, population_size, max_iterations)
+        
+        # In ABC, the number of food sources is equal to half of the population
+        self.food_sources_count = population_size // 2
+        
+        # Maximum trials allowed for a food source to improve before being discarded
+        self.limit = limit
+        
+        # Array to track the number of failed attempts at improving each food source
+        self.trial_counters = np.zeros(self.food_sources_count)
+
+    def _apply_boundary_constraints(self, individual: np.ndarray) -> np.ndarray:
+        """
+        Clips the coordinates of a candidate solution to the defined search space.
+
+        Args:
+            individual (np.ndarray): The continuous vector to be constrained.
+
+        Returns:
+            np.ndarray: The bounded candidate solution.
+        """
+        lower_bounds = self.bounds[:, 0]
+        upper_bounds = self.bounds[:, 1]
+        
+        return np.clip(individual, lower_bounds, upper_bounds)
+
+    def run(self) -> Tuple[np.ndarray, float]:
+        """
+        Executes the three-phase artificial foraging cycle.
+
+        Returns:
+            Tuple[np.ndarray, float]: The global best solution and its fitness.
+        """
+        # Initial food sources are sampled uniformly from the search domain
+        # In this algorithm, population size reflects the number of active food sources
+        food_sources = self._initialize_population()[:self.food_sources_count]
+        
+        # Initial evaluation of the food source fitness
+        fitness_values = np.apply_along_axis(self.objective_function, 1, food_sources)
+        
+        for iteration in range(self.max_iterations):
+            
+            # --- EMPLOYED BEES PHASE ---
+            # Each employed bee explores a neighbor of its assigned food source
+            for i in range(self.food_sources_count):
+                
+                # Select a random neighbor index different from current source
+                neighbor_idx = np.random.choice([idx for idx in range(self.food_sources_count) if idx != i])
+                
+                # Select a random dimension to perturb
+                dimension_idx = np.random.randint(self.dimension)
+                
+                # Calculate the neighbor solution using the ABC search formula
+                # Phi is a random scaling factor in the range [-1, 1]
+                phi = np.random.uniform(-1, 1)
+                candidate_solution = np.copy(food_sources[i])
+                candidate_solution[dimension_idx] += phi * (food_sources[i][dimension_idx] - food_sources[neighbor_idx][dimension_idx])
+                
+                # Enforce space boundaries and evaluate
+                candidate_solution = self._apply_boundary_constraints(candidate_solution)
+                candidate_fitness = self.objective_function(candidate_solution)
+                
+                # Greedy selection: update source if the new candidate is better
+                if candidate_fitness < fitness_values[i]:
+                    food_sources[i] = candidate_solution
+                    fitness_values[i] = candidate_fitness
+                    self.trial_counters[i] = 0
+                else:
+                    self.trial_counters[i] += 1
+
+            # --- ONLOOKER BEES PHASE ---
+            # Bees in the hive choose food sources to exploit based on probability (Roulette)
+            for _ in range(self.food_sources_count):
+                
+                # Use the roulette selection from operators.py to favor better sources
+                # We pass the full matrix and fitness values to pick a winning source index
+                # Note: We simulate the selection of a source for additional local search
+                selected_idx = ops.roulette_wheel_selection_index(food_sources, fitness_values)
+                
+                # Repeat the local search logic for the chosen source
+                neighbor_idx = np.random.choice([idx for idx in range(self.food_sources_count) if idx != selected_idx])
+                dimension_idx = np.random.randint(self.dimension)
+                phi = np.random.uniform(-1, 1)
+                
+                candidate_solution = np.copy(food_sources[selected_idx])
+                candidate_solution[dimension_idx] += phi * (food_sources[selected_idx][dimension_idx] - food_sources[neighbor_idx][dimension_idx])
+                
+                candidate_solution = self._apply_boundary_constraints(candidate_solution)
+                candidate_fitness = self.objective_function(candidate_solution)
+                
+                # Greedy selection for the onlooker bee's target
+                if candidate_fitness < fitness_values[selected_idx]:
+                    food_sources[selected_idx] = candidate_solution
+                    fitness_values[selected_idx] = candidate_fitness
+                    self.trial_counters[selected_idx] = 0
+                else:
+                    self.trial_counters[selected_idx] += 1
+
+            # --- SCOUT BEES PHASE ---
+            # Identify food sources that have exceeded the trial limit without improvement
+            for i in range(self.food_sources_count):
+                if self.trial_counters[i] > self.limit:
+                    
+                    # Abandon the exhausted source and re-initialize it randomly
+                    # This step prevents premature convergence to local optima
+                    lower_bounds = self.bounds[:, 0]
+                    upper_bounds = self.bounds[:, 1]
+                    food_sources[i] = np.random.uniform(lower_bounds, upper_bounds, self.dimension)
+                    fitness_values[i] = self.objective_function(food_sources[i])
+                    self.trial_counters[i] = 0
+
+            # Update the global optimum record
+            best_idx = np.argmin(fitness_values)
+            if fitness_values[best_idx] < self.best_fitness:
+                self.best_fitness = fitness_values[best_idx]
+                self.best_individual = np.copy(food_sources[best_idx])
+            
+            # Store best fitness for convergence history tracking
+            self.fitness_history.append(self.best_fitness)
+
+        return self.best_individual, self.best_fitness

evobench/algorithms/eda.py

@@ -0,0 +1,122 @@
+import numpy as np
+from typing import Callable, Tuple
+from evobench.base import EvolutionaryAlgorithm
+import evobench.tools.operators as ops
+
+class EstimationOfDistributionAlgorithm(EvolutionaryAlgorithm):
+    """
+    Continuous Estimation of Distribution Algorithm (EDA) with static typing.
+
+    This metaheuristic models the search space using a probabilistic approach. 
+    Instead of applying classical genetic operators like crossover or mutation, 
+    it selects a subset of the best-performing individuals to estimate the 
+    parameters of a Gaussian distribution (mean and standard deviation). 
+    The subsequent generation is then entirely sampled from this updated 
+    probability model, effectively guiding the search towards promising regions.
+    """
+
+    def __init__(
+        self, 
+        objective_function: Callable[[np.ndarray], float], 
+        bounds: np.ndarray, 
+        population_size: int = 50, 
+        max_iterations: int = 100, 
+        selection_ratio: float = 0.5
+    ) -> None:
+        """
+        Initializes the EDA-specific hyperparameters alongside the standard 
+        evolutionary algorithm attributes.
+
+        Args:
+            objective_function (Callable[[np.ndarray], float]): The mathematical 
+                                                                function to minimize.
+            bounds (np.ndarray): The spatial boundaries for the search domain.
+            population_size (int): Total number of candidate solutions per generation.
+            max_iterations (int): The termination criterion.
+            selection_ratio (float): The fraction of the population selected to 
+                                     estimate the probability distribution.
+        """
+        super().__init__(objective_function, bounds, population_size, max_iterations)
+        
+        # Determine the exact number of individuals that will form the elite pool
+        self.selection_size = int(self.population_size * selection_ratio)
+
+    def _apply_boundary_constraints(self, population: np.ndarray) -> np.ndarray:
+        """
+        Enforces spatial boundaries on a newly sampled population.
+
+        Since the Gaussian distribution spans infinitely, sampled individuals 
+        might fall outside the mathematical domain of the objective function.
+        This method clips the values strictly within the permitted limits.
+
+        Args:
+            population (np.ndarray): The unbounded matrix of candidate solutions.
+
+        Returns:
+            np.ndarray: The spatially bounded population matrix.
+        """
+        lower_bounds = self.bounds[:, 0]
+        upper_bounds = self.bounds[:, 1]
+        
+        # Apply strict clipping across all dimensions simultaneously
+        bounded_population: np.ndarray = np.clip(population, lower_bounds, upper_bounds)
+        return bounded_population
+
+    def run(self) -> Tuple[np.ndarray, float]:
+        """
+        Executes the main probabilistic evolutionary loop.
+
+        The process iteratively evaluates the population, selects the elite 
+        subset using tournament selection, calculates the mean and standard 
+        deviation vectors, and samples the new candidate solutions.
+
+        Returns:
+            Tuple[np.ndarray, float]: The global best candidate vector and 
+                                      its corresponding fitness.
+        """
+        # Generate the initial uniform random population
+        population = self._initialize_population()
+        
+        for _ in range(self.max_iterations):
+            # Evaluate the objective function for every individual in the matrix
+            fitness_values = np.apply_along_axis(self.objective_function, 1, population)
+            
+            # Track the best individual found in the current generation
+            current_best_index = np.argmin(fitness_values)
+            current_best_fitness = float(fitness_values[current_best_index])
+            
+            if current_best_fitness < self.best_fitness:
+                self.best_fitness = current_best_fitness
+                self.best_individual = np.copy(population[current_best_index])
+            
+            # Record the convergence history for later statistical analysis
+            self.fitness_history.append(self.best_fitness)
+            
+            # Construct the elite pool using the previously defined selection operator
+            # The tournament selection provides selection pressure while maintaining diversity
+            elite_pool = np.empty((self.selection_size, self.dimension))
+            for i in range(self.selection_size):
+                elite_pool[i] = ops.tournament_selection(population, fitness_values, tournament_size=3)
+            
+            # Estimate the probability distribution parameters from the elite pool
+            # The mean acts as the center of mass for the promising region
+            mean_vector = np.mean(elite_pool, axis=0)
+            
+            # The standard deviation acts as the search radius or exploration threshold
+            # A tiny constant is added to prevent mathematical errors if variance collapses to zero
+            standard_deviation_vector = np.std(elite_pool, axis=0) + 1e-8
+            
+            # Sample the completely new population from the estimated Gaussian model
+            # Elitism: Preserve the global best individual to guarantee monotonic improvement
+            population = np.random.normal(
+                loc=mean_vector, 
+                scale=standard_deviation_vector, 
+                size=(self.population_size, self.dimension)
+            )
+            
+            population[0] = self.best_individual
+            
+            # Ensure the newly sampled coordinates do not violate the problem domain
+            population = self._apply_boundary_constraints(population)
+            
+        return self.best_individual, self.best_fitness

evobench/algorithms/pso.py

@@ -0,0 +1,115 @@
+import numpy as np
+from typing import Callable, Tuple
+from evobench.base import EvolutionaryAlgorithm
+
+class ParticleSwarmOptimization(EvolutionaryAlgorithm):
+    """
+    Standard Particle Swarm Optimization (PSO) for continuous spaces.
+
+    This algorithm simulates a swarm of particles moving through a multi-dimensional 
+    search space. Each particle maintains a velocity and a memory of its personal 
+    best position. The movement is guided by an inertia weight, a cognitive 
+    component (personal experience), and a social component (global best), 
+    effectively balancing exploration and exploitation.
+    """
+
+    def __init__(
+        self, 
+        objective_function: Callable[[np.ndarray], float], 
+        bounds: np.ndarray, 
+        population_size: int = 50, 
+        max_iterations: int = 100, 
+        inertia_weight: float = 0.7, 
+        cognitive_constant: float = 1.5, 
+        social_constant: float = 1.5
+    ) -> None:
+        """
+        Initializes the PSO hyperparameters and the base evolutionary attributes.
+
+        Args:
+            objective_function (Callable): The mathematical function to minimize.
+            bounds (np.ndarray): Spatial boundaries [min, max] for each dimension.
+            population_size (int): Number of particles in the swarm.
+            max_iterations (int): Maximum number of iterations for the loop.
+            inertia_weight (float): Factor that controls the impact of previous velocity.
+            cognitive_constant (float): Acceleration coefficient for personal best.
+            social_constant (float): Acceleration coefficient for global best.
+        """
+        super().__init__(objective_function, bounds, population_size, max_iterations)
+        
+        # Hyperparameters for the velocity update equation
+        self.w = inertia_weight
+        self.c1 = cognitive_constant
+        self.c2 = social_constant
+
+    def _apply_boundary_constraints(self, population: np.ndarray) -> np.ndarray:
+        """
+        Keeps particles within the search space and handles velocity reflections.
+
+        Args:
+            population (np.ndarray): The current positions of the swarm.
+
+        Returns:
+            np.ndarray: The bounded population matrix.
+        """
+        lower_bounds = self.bounds[:, 0]
+        upper_bounds = self.bounds[:, 1]
+        
+        # Clip positions that exceed the established search domain
+        return np.clip(population, lower_bounds, upper_bounds)
+
+    def run(self) -> Tuple[np.ndarray, float]:
+        """
+        Executes the main PSO swarm intelligence loop.
+
+        Returns:
+            Tuple[np.ndarray, float]: The global best position and its fitness.
+        """
+        # Initializing swarm positions using the base uniform sampling method
+        current_positions = self._initialize_population()
+        
+        # Velocities are initialized to zero for all particles and dimensions
+        velocities = np.zeros((self.population_size, self.dimension))
+        
+        # Personal best positions (p_best) are initialized to the starting positions
+        personal_best_positions = np.copy(current_positions)
+        
+        # Personal best fitness values initialized to infinity for minimization
+        personal_best_fitness = np.full(self.population_size, float('inf'))
+        
+        for iteration in range(self.max_iterations):
+            # Evaluate objective function for every particle in the swarm
+            fitness_values = np.apply_along_axis(self.objective_function, 1, current_positions)
+            
+            # Update personal and global bests based on current evaluations
+            for i in range(self.population_size):
+                if fitness_values[i] < personal_best_fitness[i]:
+                    personal_best_fitness[i] = fitness_values[i]
+                    personal_best_positions[i] = np.copy(current_positions[i])
+                    
+                # Update the global optimum if a better solution is found
+                if fitness_values[i] < self.best_fitness:
+                    self.best_fitness = fitness_values[i]
+                    self.best_individual = np.copy(current_positions[i])
+            
+            # Store the best fitness of the iteration for convergence tracking
+            self.fitness_history.append(self.best_fitness)
+            
+            # Generate random coefficients for the stochastic components of the velocity
+            r1 = np.random.rand(self.population_size, self.dimension)
+            r2 = np.random.rand(self.population_size, self.dimension)
+            
+            # Calculate the cognitive and social attraction vectors
+            cognitive_acceleration = self.c1 * r1 * (personal_best_positions - current_positions)
+            social_acceleration = self.c2 * r2 * (self.best_individual - current_positions)
+            
+            # Update velocity applying inertia and acceleration components
+            velocities = (self.w * velocities) + cognitive_acceleration + social_acceleration
+            
+            # Update particle positions based on the new velocity vectors
+            current_positions += velocities
+            
+            # Enforce boundary constraints to keep the swarm within the domain
+            current_positions = self._apply_boundary_constraints(current_positions)
+            
+        return self.best_individual, self.best_fitness

evobench/base.py

@@ -0,0 +1,87 @@
+from typing import Callable, List, Tuple
+import numpy as np
+from abc import ABC, abstractmethod
+
+class EvolutionaryAlgorithm(ABC):
+    """
+    Abstract base class defining the standard architecture for population-based 
+    evolutionary algorithms and metaheuristics.
+
+    This class enforces a uniform interface across different optimization strategies,
+    ensuring that all derived algorithms share common initialization protocols,
+    state tracking, and execution signatures. This standardization is critical 
+    for executing rigorous statistical benchmarking over continuous search spaces.
+    """
+
+    def __init__(self, objective_function: Callable, bounds: List, population_size: int = 50, max_iterations: int = 100) -> None:
+        """
+        Initializes the fundamental hyperparameters and state variables required 
+        for the optimization process.
+
+        Args:
+            objective_function (callable): The mathematical function to be minimized.
+            bounds (list of tuples or numpy.ndarray): The continuous search domain 
+                                                      defined as [lower_bound, upper_bound] 
+                                                      for each dimension.
+            population_size (int): The number of candidate solutions evaluated per generation.
+            max_iterations (int): The termination criterion defining the maximum 
+                                  number of evolutionary cycles.
+        """
+        self.objective_function = objective_function
+        
+        # Array conversion ensures vectorized operations can be applied efficiently 
+        # during mutation or boundary handling
+        self.bounds = np.array(bounds)
+        self.population_size = population_size
+        self.max_iterations = max_iterations
+        
+        # The dimensionality of the problem is implicitly derived from the bounds matrix
+        self.dimension = len(self.bounds)
+        
+        # State trackers required to store the global optimum throughout the execution
+        self.best_individual = None
+        self.best_fitness = float('inf')
+        
+        # Convergence tracker used to store the best fitness value of each generation,
+        # which is later utilized to generate convergence plots and statistical analysis
+        self.fitness_history = []
+
+    def _initialize_population(self) -> np.ndarray:
+        """
+        Generates the initial set of candidate solutions.
+
+        The initial population is generated by sampling from a uniform probability 
+        distribution bounded by the defined search space. This ensures an unbiased 
+        exploration of the domain during the first generation.
+
+        Returns:
+            numpy.ndarray: A matrix of shape (population_size, dimension) containing 
+                           the initial candidate vectors.
+        """
+        # Vectorized extraction of the lower and upper limits for the search space
+        lower_bounds = self.bounds[:, 0]
+        upper_bounds = self.bounds[:, 1]
+        
+        # Matrix generation using uniform sampling across all dimensions simultaneously
+        initial_population = np.random.uniform(
+            low=lower_bounds, 
+            high=upper_bounds, 
+            size=(self.population_size, self.dimension)
+        )
+        
+        return initial_population
+
+    @abstractmethod
+    def run(self) -> Tuple[np.ndarray, float]:
+        """
+        Executes the core evolutionary loop.
+
+        This method acts as the main algorithmic contract. Every subclass must implement 
+        its own stochastic search mechanisms, position updates, or probabilistic models 
+        within this function. 
+
+        Returns:
+            tuple: A pair containing the best candidate vector (numpy.ndarray) and 
+                   its corresponding fitness value (float).
+        """
+        pass

evobench/benchmarks/__init__.py

@@ -0,0 +1,56 @@
+"""
+Evolutionary Benchmarking Registry Module
+
+This module acts as a central hub for all optimization test functions. 
+It utilizes a registry pattern to map string identifiers directly to 
+their corresponding mathematical implementations.
+"""
+
+# We use relative imports (with the dot) to tell Python: 
+# "Look inside the current folder"
+from .unimodal import (
+    rosenbrock_function as rosenbrock,
+    sphere_function as sphere,
+    schwefel_1_2_function as schwefel,
+    trid_function as trid
+)
+from .multimodal import ackley_function as ackley
+
+# Central dictionary mapping string names to function references
+# Note: Using lowercase keys is a good practice for robustness
+BENCHMARK_REGISTRY = {
+    "sphere": sphere,
+    "rosenbrock": rosenbrock,
+    "ackley": ackley,
+    "schwefel 1.2": schwefel,
+    "trid": trid
+}
+
+def get_benchmark(name: str):
+    """
+    Retrieves the callable mathematical function based on its registry name.
+
+    Args:
+        name: The string identifier of the benchmark function.
+
+    Returns:
+        callable: The requested benchmarking function.
+    """
+    # Normalize the input name to lowercase to match the registry keys
+    search_name = name.lower()
+    
+    if search_name not in BENCHMARK_REGISTRY:
+        raise ValueError(f"Benchmark '{name}' is not implemented in the registry.")
+        
+    return BENCHMARK_REGISTRY[search_name]
+
+# List of publicly available objects when using 'from evobench.benchmarks import *'
+# Fixed the typos and ensured names match the aliases defined above
+__all__ = [
+    "rosenbrock", 
+    "sphere", 
+    "schwefel", 
+    "trid", 
+    "ackley", 
+    "get_benchmark"
+]

evobench/benchmarks/multimodal.py

@@ -0,0 +1,38 @@
+import numpy as np
+
+def ackley_function(x: np.ndarray) -> float:
+    """
+    Evaluates the Ackley function for a given continuous vector.
+
+    The Ackley function is characterized by a nearly flat outer region and 
+    a large hole at the center. It poses a risk for optimization algorithms 
+    to be trapped in one of its many local minima.
+
+    Search space bounds: [-10, 10]
+    Global optimum: F(0) = 0
+
+    Args:
+        x: The candidate solution vector representing coordinates.
+
+    Returns:
+        The evaluated fitness value (objective to minimize).
+    """
+    # Extract the dimensionality of the search space directly from the vector length
+    dimension = len(x)
+    
+    # Calculate the sum of squared elements for the first exponential term
+    sum_of_squares = float(np.sum(x**2))
+    
+    # Calculate the sum of cosine evaluations for the second exponential term
+    sum_of_cosines = float(np.sum(np.cos(2.0 * np.pi * x)))
+    
+    # Compute the first component of the Ackley mathematical equation
+    term_one = -20.0 * np.exp(-0.2 * np.sqrt(sum_of_squares / dimension))
+    
+    # Compute the second component involving the trigonometric summation
+    term_two = -np.exp(sum_of_cosines / dimension)
+    
+    # Aggregate all terms alongside the mathematical constants
+    final_fitness = term_one + term_two + 20.0 + np.exp(1.0)
+    
+    return final_fitness