pyVolutionary 1.0.1__py3-none-any.whl

pyvolutionary/particle_swarm/particle_swarm_optimization.py

@@ -0,0 +1,78 @@
+import numpy as np
+
+from ..models import ContinuousVariable
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import Particle, ParticleSwarmOptimizationConfig
+
+
+class ParticleSwarmOptimization(OptimizationAbstract):
+    """
+    Implementation of the Particle Swarm Optimization algorithm.
+
+    Args:
+        config (ParticleSwarmOptimizationConfig): an instance of ParticleSwarmOptimizationConfig class.
+            {parse_obj_doc(ParticleSwarmOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Kennedy, J., & Eberhart, R. (1995). Particle swarm optimization. Proceedings of ICNN’95 - International
+        Conference on Neural Networks, 4, 1942–1948 vol.4. https://doi.org/10.1109/ICNN.1995.488968
+    [2] Kennedy, J., & Eberhart, R. C. (1995). A new optimizer using particle swarm theory. Proceedings of the Sixth
+        International Symposium on Micro Machine and Human Science, 39–43. https://doi.org/10.1109/MHS.1995.494215
+    3[] Eberhart, R. C., & Shi, Y. (2001). Particle swarm optimization: Developments, applications and resources.
+        Proceedings of the 2001 Congress on Evolutionary Computation (IEEE Cat. No.01TH8546), 1, 81–86.
+        https://doi.org/10.1109/CEC.2001.934374
+    """
+    def __init__(self, config: ParticleSwarmOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__v: np.ndarray | None = None
+        self.__pbest: list[Particle] = []
+
+    def before_initialization(self):
+        self.__v = 0.2 * self._bandwidth()
+
+    def _init_agent(
+        self,
+        position: list[float] | np.ndarray | None = None,
+        velocity: list[float] | np.ndarray | None = None
+    ) -> Particle:
+        agent = super()._init_agent(position=position)
+
+        if velocity is None:
+            return Particle(**agent.model_dump(), velocity=np.zeros(self._task.space_dimension).tolist())
+
+        velocity = np.where(
+            isinstance(self._task.variables, ContinuousVariable), np.clip(velocity, -self.__v, self.__v), velocity
+        ).tolist()
+        return Particle(**agent.model_dump(), velocity=velocity)
+
+    def _init_population(self):
+        super()._init_population()
+        self.__pbest = self._population.copy()
+
+    def optimization_step(self):
+        """
+        Merge the population and the archive, sort them by cost and update the population with the best n_ants
+        """
+        # Update the particles
+        w_min, w_max = self._config.w
+
+        for idx in range(0, self._config.population_size):
+            particle = self._population[idx].model_copy()
+            pbest = self.__pbest[idx].model_copy()
+
+            # Randomly generate r1, r2 and inertia weight from normal distribution, and then calculate the new velocity
+            w = np.random.uniform(w_min, w_max)  # Inertia weight * (cycles + 1) / max_cycles
+
+            velocity = w * np.array(particle.velocity) + self._config.c1 * np.random.rand() * (
+                np.array(pbest.position) - np.array(particle.position)
+            ) + self._config.c2 * np.random.rand() * (
+                    np.array(self._best_agent.position) - np.array(particle.position)
+            )
+
+            # Move particles by adding velocity
+            self._population[idx] = self._init_agent(position=particle.position + velocity, velocity=velocity)
+
+            # Update personal best
+            self.__pbest[idx] = self._greedy_select_agent(self._population[idx], pbest)

pyvolutionary/pathfinder_algorithm/__init__.py

@@ -0,0 +1,2 @@
+from .models import Pathfinder, PathfinderAlgorithmOptimizationConfig
+from .pathfinder_algorithm_optimization import PathfinderAlgorithmOptimization

pyvolutionary/pathfinder_algorithm/models.py

@@ -0,0 +1,12 @@
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Pathfinder(Agent):
+    pass
+
+
+class PathfinderAlgorithmOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Pathfinder Algorithm Optimization algorithm.
+    """
+    pass

pyvolutionary/pathfinder_algorithm/pathfinder_algorithm_optimization.py

@@ -0,0 +1,56 @@
+import numpy as np
+
+from ..helpers import (
+    distance,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import PathfinderAlgorithmOptimizationConfig
+
+
+class PathfinderAlgorithmOptimization(OptimizationAbstract):
+    """
+    Implementation of the Pathfinder Algorithm Optimization.
+
+    Args:
+        config (PathfinderAlgorithmOptimizationConfig): an instance of PathfinderAlgorithmOptimizationConfig class.
+            {parse_obj_doc(PathfinderAlgorithmOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Yapici, H. and Cetinkaya, N., 2019. A new meta-heuristic optimizer: Pathfinder algorithm. Applied soft
+        computing, 78, pp.545-568.
+    """
+    def __init__(self, config: PathfinderAlgorithmOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def optimization_step(self):
+        alpha, beta = np.random.uniform(1, 2, 2)
+        best_position = np.array(self._best_agent.position)
+
+        A = self._uniform_position() * np.exp(-2 * self._cycles / self._config.max_cycles)
+        t = 1. - self._cycles / (self._config.max_cycles + 1)
+        space = self._bandwidth()
+        
+        # update the position of pathfinder and check the bound
+        new_pathfinder = self._init_agent(np.array(self._population[0].position) + 2 * np.random.uniform() * (
+            best_position - np.array(self._population[0].position)
+        ) + A)
+
+        # update positions of members, check the bound and calculate new fitness
+        for idx in range(1, self._config.population_size):
+            pathfinder_position = np.array(self._population[idx].position)
+            pos_new = pathfinder_position.copy().astype(float)
+
+            dist = distance(new_pathfinder.position, pathfinder_position.tolist()) / self._task.space_dimension
+            pos_new += alpha * np.random.uniform() * (best_position - pathfinder_position) + (
+                beta * np.random.uniform() * (self._population[idx - 1].position - pathfinder_position)
+            ) + np.random.uniform() * t * (dist / space)
+
+            pos_new = self._correct_position(pos_new)
+            agent = self._init_agent(pos_new)
+
+            self._population[idx] = self._greedy_select_agent(agent, self._population[idx])
+
+        # update the position of the pathfinder
+        self._population[0] = self._greedy_select_agent(new_pathfinder, self._population[0])

pyvolutionary/pelican/__init__.py

@@ -0,0 +1,2 @@
+from .models import Pelican, PelicanOptimizationConfig
+from .pelican_optimization import PelicanOptimization

pyvolutionary/pelican/models.py

@@ -0,0 +1,9 @@
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Pelican(Agent):
+    pass
+
+
+class PelicanOptimizationConfig(BaseOptimizationConfig):
+    pass

pyvolutionary/pelican/pelican_optimization.py

@@ -0,0 +1,46 @@
+import numpy as np
+
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import PelicanOptimizationConfig
+
+
+class PelicanOptimization(OptimizationAbstract):
+    """
+    Implementation of the Pelican Optimization algorithm.
+
+    Args:
+        config (PelicanOptimizationConfig): an instance of PelicanOptimizationConfig class.
+            {parse_obj_doc(OspreyOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Trojovský, P., & Dehghani, M. (2022). Pelican optimization algorithm: A novel nature-inspired algorithm for
+        engineering applications. Sensors, 22(3), 855.
+    """
+    def __init__(self, config: PelicanOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def optimization_step(self):
+        n_dims = self._task.space_dimension
+        for idx, pelican in enumerate(self._population):
+            # update location of food
+            kk = np.random.permutation(self._config.population_size)[0]
+            pos_kk = np.array(self._population[kk].position)
+
+            pos = np.array(pelican.position)
+
+            # phase 1: moving towards prey (exploration phase), Eq. 4
+            pos_new = pos + np.random.random() * (
+                pos_kk - np.random.randint(1, 3) * pos
+            ) if self._population[kk].cost < pelican.cost else pos + np.random.random() * (pos - pos_kk)
+            agent = self._init_agent(self._correct_position(pos_new))
+
+            pelican = self._greedy_select_agent(pelican, agent)
+
+            # phase 2: Winging on the water surface (exploitation phase), with Eq. 6
+            pos_new = np.array(pelican.position) + 0.2 * (1 - self._cycles / self._config.max_cycles) * (
+                2 * np.random.random(n_dims) - 1
+            ) * np.array(pelican.position)
+            agent = self._init_agent(self._correct_position(pos_new))
+            self._population[idx] = self._greedy_select_agent(pelican, agent)

pyvolutionary/seagull/__init__.py

@@ -0,0 +1,2 @@
+from .models import Seagull, SeagullOptimizationConfig
+from .seagull_optimization import SeagullOptimization

pyvolutionary/seagull/models.py

@@ -0,0 +1,21 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Seagull(Agent):
+    pass
+
+
+class SeagullOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class for the Seagull Optimization algorithm.
+        fc (float): [1.0, 10.0] -> frequency of employing variable A (A linear decreased from fc to 0)
+    """
+    fc: float
+
+    @field_validator("fc")
+    def fc_validator(cls, v):
+        if not (1.0 <= v <= 10.0):
+            raise ValueError("fc must be between 1.0 and 10.0")
+        return v

pyvolutionary/seagull/seagull_optimization.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import SeagullOptimizationConfig
+
+
+class SeagullOptimization(OptimizationAbstract):
+    """
+    Implementation of the Aquila Optimization algorithm.
+
+    Args:
+        config (SeagullOptimizationConfig): an instance of AquilaOptimizationConfig class.
+            {parse_obj_doc(AquilaOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Dhiman, G., & Kumar, V. (2019). Seagull optimization algorithm: Theory and its applications for large-scale
+        industrial engineering problems. Knowledge-based systems, 165, 169-196.
+    """
+    def __init__(self, config: SeagullOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def optimization_step(self):
+        A = self._config.fc - self._cycles * self._config.fc / self._config.max_cycles  # Eq. 6
+        uu = vv = 1
+
+        best_pos = np.array(self._best_agent.position)
+        for idx, seagull in enumerate(self._population):
+            pos = np.array(seagull.position)
+
+            B = 2 * A ** 2 * np.random.random()  # Eq. 8
+            M = B * (best_pos - pos)  # Eq. 7
+            C = A * pos  # Eq. 5
+            D = np.abs(C + M)  # Eq. 9
+            k = np.random.uniform(0, 2 * np.pi)
+            r = uu * np.exp(k * vv)
+
+            pos_new = r * np.cos(k) * r * np.sin(k) * r * k * D + np.random.normal(0, 1) * best_pos  # Eq. 14
+            pos_new = self._correct_position(pos_new)
+            agent = self._init_agent(pos_new)
+
+            self._population[idx] = self._greedy_select_agent(agent, seagull)

pyvolutionary/siberian_tiger/__init__.py

@@ -0,0 +1,2 @@
+from .models import SiberianTiger, SiberianTigerOptimizationConfig
+from .siberian_tiger_optimization import SiberianTigerOptimization

pyvolutionary/siberian_tiger/models.py

@@ -0,0 +1,9 @@
+from ..models import Agent, BaseOptimizationConfig
+
+
+class SiberianTiger(Agent):
+    pass
+
+
+class SiberianTigerOptimizationConfig(BaseOptimizationConfig):
+    pass

pyvolutionary/siberian_tiger/siberian_tiger_optimization.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import SiberianTiger, SiberianTigerOptimizationConfig
+
+
+class SiberianTigerOptimization(OptimizationAbstract):
+    """
+    Implementation of the Siberian Tiger Optimization algorithm.
+
+    Args:
+        config (SiberianTigerOptimizationConfig): an instance of SiberianTigerOptimizationConfig class.
+            {parse_obj_doc(SiberianTigerOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Trojovský, P., Dehghani, M., & Hanuš, P. (2022). Siberian Tiger Optimization: A New Bio-Inspired
+        Metaheuristic Algorithm for Solving Engineering Optimization Problems. IEEE Access, 10, 132396-132431.
+    """
+    def __init__(self, config: SiberianTigerOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def __get_indexes_better__(self, siberian_tiger: SiberianTiger) -> np.ndarray:
+        costs = np.array([agent.cost for agent in self._population])
+        idxs = np.where(costs < siberian_tiger.cost)
+        return idxs[0]
+
+    def __sf__(self, siberian_tiger: SiberianTiger) -> np.ndarray:
+        idxs = self.__get_indexes_better__(siberian_tiger)
+        if len(idxs) == 0 or np.random.random() < 0.5:
+            return np.array(self._best_agent.position)
+
+        kk = np.random.permutation(idxs)[0]
+        return np.array(self._population[kk].position)
+
+    def optimization_step(self):
+        for idx, siberian_tiger in enumerate(self._population):
+            pos = np.array(siberian_tiger.position)
+
+            # phase 1: hunting (exploration)
+            sf = self.__sf__(siberian_tiger)
+            r1 = np.random.randint(1, 3)
+            pos_new = pos + np.random.random() * (sf - r1 * pos)  # Eq. 5
+            agent = self._init_agent(self._correct_position(pos_new))
+
+            siberian_tiger = self._greedy_select_agent(siberian_tiger, agent)
+
+            # phase 2: exploitation
+            pos_new = self._increase_position(siberian_tiger.position, self._cycles)  # Eq. 7
+            agent = self._init_agent(self._correct_position(pos_new))
+
+            self._population[idx] = self._greedy_select_agent(siberian_tiger, agent)

pyvolutionary/tasmanian_devil/__init__.py

@@ -0,0 +1,2 @@
+from .models import TasmanianDevil, TasmanianDevilOptimizationConfig
+from .tasmanian_devil_optimization import TasmanianDevilOptimization

pyvolutionary/tasmanian_devil/models.py

@@ -0,0 +1,9 @@
+from ..models import Agent, BaseOptimizationConfig
+
+
+class TasmanianDevil(Agent):
+    pass
+
+
+class TasmanianDevilOptimizationConfig(BaseOptimizationConfig):
+    pass

pyvolutionary/tasmanian_devil/tasmanian_devil_optimization.py

@@ -0,0 +1,69 @@
+import numpy as np
+
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import TasmanianDevil, TasmanianDevilOptimizationConfig
+
+
+class TasmanianDevilOptimization(OptimizationAbstract):
+    """
+    Implementation of the Tasmanian Devil Optimization algorithm.
+
+    Args:
+        config (TasmanianDevilOptimizationConfig): an instance of TasmanianDevilOptimizationConfig class.
+            {parse_obj_doc(TasmaniaDevilOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Dehghani, M., Hubálovský, Š., & Trojovský, P. (2022). Tasmanian devil optimization: a new bio-inspired
+        optimization algorithm for solving optimization algorithm. IEEE Access, 10, 19599-19620.
+    """
+    def __init__(self, config: TasmanianDevilOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def __strategy__(self, idx: int, tasmanian_devil: TasmanianDevil) -> TasmanianDevil:
+        """
+        Application of strategy.
+        :param idx: index of the agent
+        :param tasmanian_devil: current agent
+        :return: picked agent
+        :rtype: TasmanianDevil
+        """
+        pop_size = self._config.population_size
+        n_dims = self._task.space_dimension
+
+        pos = np.array(tasmanian_devil.position)
+
+        kk = np.random.choice(list(set(range(0, pop_size)) - {idx}))
+
+        pos_new = pos + np.random.random(n_dims) * (
+            pos - np.random.randint(1, 3) * pos
+        ) if self._population[kk].cost < tasmanian_devil.cost else pos + np.random.random(n_dims) * (
+            pos - np.array(self._population[kk].position)
+        )
+        agent = self._init_agent(self._correct_position(pos_new))
+        return self._greedy_select_agent(tasmanian_devil, agent)
+
+    def optimization_step(self):
+        epoch = self._cycles
+        epochs = self._config.max_cycles
+        n_dims = self._task.space_dimension
+
+        for idx, tasmanian_devil in enumerate(self._population):
+            # phase 1: hunting feeding
+            if np.random.random() > 0.5:
+                # strategy 1: feeding by eating carrion (exploration phase)
+                # carrion selection using (3)
+                self._population[idx] = self.__strategy__(idx, tasmanian_devil)
+            else:
+                # strategy 2: feeding by eating prey (exploitation phase)
+                # stage 1: prey selection and attack it
+                agent = self.__strategy__(idx, tasmanian_devil)
+                pos = np.array(agent.position)
+
+                # phase 2: prey chasing
+                rr = 0.01 * (1 - epoch / epochs)  # Calculating the neighborhood radius using(9)
+                pos_new = pos + (-rr + 2 * rr * np.random.random(n_dims)) * pos
+                agent = self._init_agent(self._correct_position(pos_new))
+
+                self._population[idx] = self._greedy_select_agent(tasmanian_devil, agent)

pyvolutionary/tests/fixtures.py

@@ -0,0 +1,21 @@
+import numpy as np
+from pyvolutionary.models import Task, ContinuousVariable
+
+
+class Rastrigin(Task):
+    def objective_function(self, x: list[float]) -> float:
+        A = 10
+        n = len(x)
+        sum_term = sum(xi ** 2 - A * np.cos(2 * np.pi * xi) for xi in x)
+        return A * n + sum_term
+
+
+class Sphere(Task):
+    def objective_function(self, x: list[float]) -> float:
+        return sum(xi ** 2 for xi in x)
+
+
+dimension = 3
+task = Rastrigin(
+    variables=[ContinuousVariable(name=f"x{i}", lower_bound=-10, upper_bound=10) for i in range(dimension)],
+)

pyvolutionary/tests/test_african_vulture_optimization.py

@@ -0,0 +1,34 @@
+import pytest
+
+from pyvolutionary import OptimizationResult, AfricanVultureOptimization, AfricanVultureOptimizationConfig
+from pyvolutionary.tests.fixtures import task
+
+
+@pytest.fixture
+def optimization_config() -> AfricanVultureOptimizationConfig:
+    return AfricanVultureOptimizationConfig(
+        population_size=20,
+        fitness_error=0.01,
+        max_cycles=100,
+        p=[0.6, 0.4, 0.6],
+        alpha=0.8,
+        gamma=2.5,
+    )
+
+
+def test_valid_optimization(optimization_config):
+    o = AfricanVultureOptimization(optimization_config)
+    result = o.optimize(task)
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_threads(optimization_config):
+    o = AfricanVultureOptimization(optimization_config)
+    result = o.optimize(task, mode="thread")
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_processes(optimization_config):
+    o = AfricanVultureOptimization(optimization_config)
+    result = o.optimize(task, mode="process")
+    assert isinstance(result, OptimizationResult)

pyvolutionary/tests/test_ant_colony_optimization.py

@@ -0,0 +1,34 @@
+import pytest
+
+from pyvolutionary import OptimizationResult, AntColonyOptimization, AntColonyOptimizationConfig
+from pyvolutionary.tests.fixtures import task
+
+
+@pytest.fixture
+def optimization_config() -> AntColonyOptimizationConfig:
+    return AntColonyOptimizationConfig(
+        population_size=20,
+        fitness_error=0.01,
+        max_cycles=100,
+        archive_size=20,
+        intent_factor=0.1,
+        zeta=0.85,
+    )
+
+
+def test_valid_optimization(optimization_config):
+    o = AntColonyOptimization(optimization_config)
+    result = o.optimize(task)
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_threads(optimization_config):
+    o = AntColonyOptimization(optimization_config)
+    result = o.optimize(task, mode="thread")
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_processes(optimization_config):
+    o = AntColonyOptimization(optimization_config)
+    result = o.optimize(task, mode="process")
+    assert isinstance(result, OptimizationResult)

pyvolutionary/tests/test_aquila_optimization.py

@@ -0,0 +1,27 @@
+import pytest
+
+from pyvolutionary import OptimizationResult, AquilaOptimization, AquilaOptimizationConfig
+from pyvolutionary.tests.fixtures import task
+
+
+@pytest.fixture
+def optimization_config() -> AquilaOptimizationConfig:
+    return AquilaOptimizationConfig(population_size=20, fitness_error=0.01, max_cycles=100)
+
+
+def test_valid_optimization(optimization_config):
+    o = AquilaOptimization(optimization_config)
+    result = o.optimize(task)
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_threads(optimization_config):
+    o = AquilaOptimization(optimization_config)
+    result = o.optimize(task, mode="thread")
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_processes(optimization_config):
+    o = AquilaOptimization(optimization_config)
+    result = o.optimize(task, mode="process")
+    assert isinstance(result, OptimizationResult)

pyvolutionary/tests/test_bacterial_foraging_optimization.py

@@ -0,0 +1,37 @@
+import pytest
+
+from pyvolutionary import OptimizationResult, BacterialForagingOptimization, BacterialForagingOptimizationConfig
+from pyvolutionary.tests.fixtures import task
+
+
+@pytest.fixture
+def optimization_config() -> BacterialForagingOptimizationConfig:
+    return BacterialForagingOptimizationConfig(
+        population_size=10,
+        fitness_error=0.01,
+        max_cycles=100,
+        C_s=0.1,
+        C_e=0.001,
+        Ped=0.01,
+        Ns=4,
+        N_adapt=2,
+        N_split=40,
+    )
+
+
+def test_valid_optimization(optimization_config):
+    o = BacterialForagingOptimization(optimization_config)
+    result = o.optimize(task)
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_threads(optimization_config):
+    o = BacterialForagingOptimization(optimization_config)
+    result = o.optimize(task, mode="thread")
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_processes(optimization_config):
+    o = BacterialForagingOptimization(optimization_config)
+    result = o.optimize(task, mode="process")
+    assert isinstance(result, OptimizationResult)

pyvolutionary/tests/test_bat_optimization.py

@@ -0,0 +1,34 @@
+import pytest
+
+from pyvolutionary import OptimizationResult, BatOptimization, BatOptimizationConfig
+from pyvolutionary.tests.fixtures import task
+
+
+@pytest.fixture
+def optimization_config() -> BatOptimizationConfig:
+    return BatOptimizationConfig(
+        population_size=20,
+        fitness_error=0.01,
+        max_cycles=100,
+        loudness=[1, 2],
+        pulse_rate=[0.1, 0.9],
+        pulse_frequency=[-0.5, 0.5],
+    )
+
+
+def test_valid_optimization(optimization_config):
+    o = BatOptimization(optimization_config)
+    result = o.optimize(task)
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_threads(optimization_config):
+    o = BatOptimization(optimization_config)
+    result = o.optimize(task, mode="thread")
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_processes(optimization_config):
+    o = BatOptimization(optimization_config)
+    result = o.optimize(task, mode="process")
+    assert isinstance(result, OptimizationResult)

pyvolutionary/tests/test_bee_colony_optimization.py

@@ -0,0 +1,32 @@
+import pytest
+
+from pyvolutionary import OptimizationResult, BeeColonyOptimization, BeeColonyOptimizationConfig
+from pyvolutionary.tests.fixtures import task
+
+
+@pytest.fixture
+def optimization_config() -> BeeColonyOptimizationConfig:
+    return BeeColonyOptimizationConfig(
+        population_size=20,
+        fitness_error=0.01,
+        max_cycles=100,
+        scouting_limit=5,
+    )
+
+
+def test_valid_optimization(optimization_config):
+    o = BeeColonyOptimization(optimization_config)
+    result = o.optimize(task)
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_threads(optimization_config):
+    o = BeeColonyOptimization(optimization_config)
+    result = o.optimize(task, mode="thread")
+    assert isinstance(result, OptimizationResult)
+
+
+def test_valid_optimization_with_processes(optimization_config):
+    o = BeeColonyOptimization(optimization_config)
+    result = o.optimize(task, mode="process")
+    assert isinstance(result, OptimizationResult)