pyVolutionary 1.0.1__py3-none-any.whl

pyvolutionary/earthworms/models.py

@@ -0,0 +1,62 @@
+from pydantic import field_validator, model_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Earthworm(Agent):
+    pass
+
+
+class EarthwormsOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Earthworms Optimization algorithm.
+        prob_mutate (float): [0, 1), probability of mutation of an earthworm.\n
+        prob_crossover (float): [0, 1), probability of crossover of an earthworm.\n
+        keep (int): [2, int(population_size/2)], number of earthworms to keep.\n
+        alpha (float): [0, 1), similarity factor.\n
+        beta (float): [0, 1), the initial proportional factor.\n
+        gamma (float): [0, 1), a sort cooling factor for beta.
+    """
+    prob_mutate: float
+    prob_crossover: float
+    keep: int
+    alpha: float
+    beta: float
+    gamma: float
+
+    @model_validator(mode="after")
+    def validate_keep(self) -> "EarthwormsOptimizationConfig":
+        if not 2 <= self.keep <= int(self.population_size / 2):
+            raise ValueError(f"keep must be a positive integer greater than 2 and lower than population_size / 2. "
+                             f"Got {self.keep}")
+        return self
+
+    @field_validator("prob_mutate")
+    def correct_prob_mutate(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"prob_mutate\" must be a positive float lower than 1. Got {v}")
+        return v
+
+    @field_validator("prob_crossover")
+    def correct_prob_crossover(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"prob_crossover\" must be a positive float lower than 1. Got {v}")
+        return v
+
+    @field_validator("alpha")
+    def correct_alpha(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"alpha\" must be a positive float lower than 1. Got {v}")
+        return v
+
+    @field_validator("beta")
+    def correct_beta(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"beta\" must be a positive float lower than 1. Got {v}")
+        return v
+
+    @field_validator("gamma")
+    def correct_gamma(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"gamma\" must be a positive float lower than 1. Got {v}")
+        return v

pyvolutionary/electromagnetic_field/__init__.py

@@ -0,0 +1,2 @@
+from .models import Electromagnet, ElectromagneticFieldOptimizationConfig
+from .electromagnetic_field_optimization import ElectromagneticFieldOptimization

pyvolutionary/electromagnetic_field/electromagnetic_field_optimization.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import Electromagnet, ElectromagneticFieldOptimizationConfig
+
+
+class ElectromagneticFieldOptimization(OptimizationAbstract):
+    """
+    Implementation of the Electromagnetic Field Optimization (EFO) algorithm.
+
+    Args:
+        config (ElectromagneticFieldOptimizationConfig): an instance of ElectromagneticFieldOptimizationConfig class.
+            {parse_obj_doc(ElectromagneticFieldOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Abedinpourshotorban, H., Shamsuddin, S.M., Beheshti, Z. and Jawawi, D.N., 2016. Electromagnetic field
+        optimization: a physics-inspired metaheuristic optimization algorithm. Swarm and Evolutionary Computation, 26,
+        pp.8-22.
+    """
+    def __init__(self, config: ElectromagneticFieldOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__phi = (1 + np.sqrt(5)) / 2  # golden ratio
+
+    def optimization_step(self):
+        pop_size = self._config.population_size
+        n_field = int(pop_size * (1 - self._config.n_field))
+        n_field1 = int(pop_size * self._config.p_field + 1)
+        p_field = int(pop_size * self._config.p_field)
+        ps_rate = self._config.ps_rate
+
+        phi = self.__phi
+        r_rate = self._config.r_rate
+        n_dims = self._task.space_dimension
+
+        best_pos = np.array(self._best_agent.position)
+        for idx, electromagnet in enumerate(self._population):
+            if np.random.random() < ps_rate:
+                r_idx1 = np.random.randint(0, p_field)  # top
+                r_idx2 = np.random.randint(n_field, pop_size)  # bottom
+                r_idx3 = np.random.randint(n_field1, n_field)  # middle
+
+                pos_new = np.array(self._population[r_idx1].position) + phi * np.random.random() * (
+                    best_pos - np.array(self._population[r_idx3].position)
+                ) + np.random.random() * (best_pos - np.array(self._population[r_idx2].position))
+            else:
+                pos_new = self._init_position()
+
+            # replacement of one electromagnet of generated particle with a random number
+            # (only for some generated particles) to bring diversity to the population
+            if np.random.random() < r_rate:
+                pos_new[np.random.randint(0, n_dims)] = self._uniform_coordinates(np.random.randint(0, n_dims))
+
+            # checking whether the generated number is inside boundary or not
+            agent = self._init_agent(self._correct_position(pos_new))
+
+            self._population[idx] = self._greedy_select_agent(electromagnet, agent)

pyvolutionary/electromagnetic_field/models.py

@@ -0,0 +1,45 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Electromagnet(Agent):
+    pass
+
+
+class ElectromagneticFieldOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class for the Electromagnetic Field Optimization algorithm.
+        r_rate (float): [0.1, 0.6], like mutation parameter in GA but for one variable.\n
+        ps_rate (float): [0.5, 0.95], like crossover parameter in GA.\n
+        p_field (float): [0.05, 0.3], portion of population, positive field.\n
+        n_field (float): [0.3, 0.7], portion of population, negative field.
+    """
+    r_rate: float
+    ps_rate: float
+    p_field: float
+    n_field: float
+    
+    @field_validator("r_rate")
+    def r_rate_validator(cls, v):
+        if not 0.1 <= v <= 0.6:
+            raise ValueError("r_rate must be between 0.1 and 0.6")
+        return v
+    
+    @field_validator("ps_rate")
+    def ps_rate_validator(cls, v):
+        if not 0.5 <= v <= 0.95:
+            raise ValueError("ps_rate must be between 0.5 and 0.95")
+        return v
+    
+    @field_validator("p_field")
+    def p_field_validator(cls, v):
+        if not 0.05 <= v <= 0.3:
+            raise ValueError("p_field must be between 0.05 and 0.3")
+        return v
+    
+    @field_validator("n_field")
+    def n_field_validator(cls, v):
+        if not 0.3 <= v <= 0.7:
+            raise ValueError("n_field must be between 0.3 and 0.7")
+        return v

pyvolutionary/elephant_herd/__init__.py

@@ -0,0 +1,2 @@
+from .models import Elephant, ElephantHerdOptimizationConfig
+from .elephant_herd_optimization import ElephantHerdOptimization

pyvolutionary/elephant_herd/elephant_herd_optimization.py

@@ -0,0 +1,56 @@
+import numpy as np
+
+from ..helpers import (
+    generate_group_population,
+    sort_by_cost,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import Elephant, ElephantHerdOptimizationConfig
+
+
+class ElephantHerdOptimization(OptimizationAbstract):
+    """
+    Implementation of the Elephant Herd Optimization algorithm.
+
+    Args:
+        config (ElephantHerdOptimizationConfig): an instance of ElephantHerdOptimizationConfig class.
+            {parse_obj_doc(ElephantHerdOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Wang, G.G., Deb, S. and Coelho, L.D.S., 2015, December. Elephant herding optimization.
+        In 2015 3rd international symposium on computational and business intelligence (ISCBI) (pp. 1-5). IEEE.
+    """
+    def __init__(self, config: ElephantHerdOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__n_individuals: int = int(self._config.population_size / self._config.n_clans)
+        self.__groups: list[list[Elephant]] = []
+
+    def _init_population(self):
+        super()._init_population()
+        self.__groups = generate_group_population(self._population, self._config.n_clans, self.__n_individuals)
+
+    def optimization_step(self):
+        n_individuals = self.__n_individuals
+
+        for idx in range(0, self._config.population_size):
+            clan_idx = int(idx / n_individuals)
+            pos_group = [np.array(elephant.position) for elephant in self.__groups[clan_idx]]
+
+            # pos_clan_idx == 0 means the best in clan, because all clans are sorted based on cost
+            pos_clan_idx = int(idx % n_individuals)
+            pos_new = self._config.beta * np.mean(pos_group, axis=0) if pos_clan_idx == 0 else (
+                pos_group[pos_clan_idx] + self._config.alpha * np.random.random() * (
+                    pos_group[0] - pos_group[pos_clan_idx]
+                )
+            )
+            self._population[idx] = self._greedy_select_agent(self._population[idx], self._init_agent(pos_new))
+
+        self.__groups = generate_group_population(self._population, self._config.n_clans, n_individuals)
+
+        # Separating operator
+        for idx in range(0, self._config.n_clans):
+            sort_by_cost(self.__groups[idx])
+            self.__groups[idx][-1] = self._init_agent()
+        self._population = [elephant for pack in self.__groups for elephant in pack]

pyvolutionary/elephant_herd/models.py

@@ -0,0 +1,38 @@
+from pydantic import field_validator, model_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Elephant(Agent):
+    pass
+
+
+class ElephantHerdOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Earthworms Optimization algorithm.
+        alpha (float): (0, 3), a factor that determines the influence of the best in each clan.\n
+        beta (float): (0, 1), a factor that determines the influence of the x_center.\n
+        n_clans (int): [2, int(population_size/5)], the number of clans.
+    """
+    alpha: float
+    beta: float
+    n_clans: int
+
+    @model_validator(mode="after")
+    def validate_n_clans(self) -> "ElephantHerdOptimizationConfig":
+        if not 2 <= self.n_clans <= int(self.population_size / 5):
+            raise ValueError(f"n_clans must be a positive integer greater than 2 and lower than population_size / 5. "
+                             f"Got {self.n_clans}")
+        return self
+
+    @field_validator("alpha")
+    def correct_alpha(cls, v):
+        if not 0 < v < 3:
+            raise ValueError(f"\"alpha\" must be a positive float lower than 3. Got {v}")
+        return v
+
+    @field_validator("beta")
+    def correct_beta(cls, v):
+        if not 0 < v < 1:
+            raise ValueError(f"\"beta\" must be a positive float lower than 1. Got {v}")
+        return v

pyvolutionary/enums.py

@@ -0,0 +1,39 @@
+from enum import Enum as BaseEnum, EnumMeta
+
+
+class MetaEnum(EnumMeta):
+    """
+    Enables the use of the `in` operator for enums.
+    For example:
+    if el not in Elements:
+        raise ValueError("invalid element")
+    """
+
+    def __contains__(cls, item):
+        try:
+            cls(item)  # pylint: disable=E1120
+        except ValueError:
+            return False
+        return True
+
+
+class Enum(BaseEnum, metaclass=MetaEnum):
+    def __str__(self):
+        return self.value
+
+
+class TaskType(Enum):
+    """
+    The type of task that the user wants to perform.
+    """
+    MIN = "min"
+    MAX = "max"
+
+
+class ModeSolver(Enum):
+    """
+    The mode of the solver.
+    """
+    SERIAL = "serial"
+    THREAD = "thread"
+    PROCESS = "process"

pyvolutionary/firefly_swarm/__init__.py

@@ -0,0 +1,2 @@
+from .models import Firefly, FireflySwarmOptimizationConfig
+from .firefly_swarm_optimization import FireflySwarmOptimization

pyvolutionary/firefly_swarm/firefly_swarm_optimization.py

@@ -0,0 +1,76 @@
+import numpy as np
+
+from ..helpers import (
+    best_agent,
+    distance,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import Firefly, FireflySwarmOptimizationConfig
+
+
+class FireflySwarmOptimization(OptimizationAbstract):
+    """
+    Implementation of the Firefly Swarm Optimization algorithm.
+
+    Args:
+        config (FireflySwarmOptimizationConfig): an instance of FireflySwarmOptimizationConfig class.
+            {parse_obj_doc(FireflySwarmOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Yang, Xin-She. "Firefly algorithms for multimodal optimization". International symposium on stochastic algorithms.
+        Springer, Berlin, Heidelberg, 2009.
+    [2] Yang, Xin-She. "Firefly algorithm, stochastic test functions and design optimization." International Journal of
+        Bio-Inspired Computation 2.2 (2010): 78-84. https://doi.org/10.1504/IJBIC.2010.032124
+    [3] Yang, Xin-She. "Firefly algorithm, Levy flights and global optimization." Research and development in intelligent
+        systems XXVI. Springer, London, 2010. 209-218. https://doi.org/10.1007/978-1-84996-153-4_15
+    """
+
+    def __init__(self, config: FireflySwarmOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def __update_alpha__(self):
+        """
+        Update alpha parameter. This parameter is used to control the randomness of the movement of the fireflies.
+        """
+        delta = 1.0 - (10.0 ** -4.0 / 0.9) ** (1.0 / self._cycles)
+        self._config.alpha *= (1 - delta) * self._config.alpha
+
+    def __update_population__(self):
+        """
+        Update the population of fireflies. This method is called at each iteration of the algorithm. It updates the
+        position of each firefly based on the position of the other fireflies. The fireflies with the best fitness
+        values will attract the other fireflies and the fireflies with the worst fitness values will be attracted by the
+        other fireflies. The fireflies with the best fitness values will move towards the fireflies with the worst
+        fitness values. The fireflies with the worst fitness values will move away from the fireflies with the best
+        fitness values.
+        """
+        alpha = self._config.alpha
+        beta_min = self._config.beta_min
+        gamma = self._config.gamma
+
+        n_dims = self._task.space_dimension
+        pop_size = self._config.population_size
+        for idx in range(0, self._config.population_size):
+            position = self._population[idx].position
+            cost = self._population[idx].cost
+            weighted_pos = [np.array(position) + beta_min * np.exp(
+                -gamma * distance(position, firefly.position) / np.sqrt(n_dims)
+            ) * np.matmul(
+                np.array(firefly.position) - np.array(position), np.random.uniform(0, 1, (n_dims, n_dims))
+            ) + alpha * np.random.uniform(0, 1, n_dims)
+                for firefly in self._population[idx+1:] if firefly.cost < cost]
+
+            new_agents = (
+                [self._init_agent(position) for position in weighted_pos] +
+                [self._init_agent() for _ in range(0, pop_size - len(weighted_pos) + 1)]
+            )
+            self._population[idx] = best_agent(new_agents)
+
+    def optimization_step(self):
+        # update alpha
+        self.__update_alpha__()
+
+        # replace old population
+        self.__update_population__()

pyvolutionary/firefly_swarm/models.py

@@ -0,0 +1,37 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Firefly(Agent):
+    pass
+
+
+class FireflySwarmOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Firefly Swarm Optimization algorithm.
+        alpha (float): [0, 1), the attractiveness constant of the fireflies.\n
+        beta_min (float): [0, 1), the minimum value of the attractiveness constant of the fireflies.\n
+        gamma (float): [0, 1), the light absorption coefficient.
+    """
+    alpha: float
+    beta_min: float
+    gamma: float
+
+    @field_validator("alpha")
+    def correct_alpha(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"alpha\" must be a positive float lower than 1. Got {v}")
+        return v
+
+    @field_validator("beta_min")
+    def correct_beta_min(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"beta_min\" must be a positive float lower than 1. Got {v}")
+        return v
+
+    @field_validator("gamma")
+    def correct_gamma(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"gamma\" must be a positive float lower than 1. Got {v}")
+        return v

pyvolutionary/fireworks/__init__.py

@@ -0,0 +1,2 @@
+from .models import Firework, FireworksOptimizationConfig
+from .fireworks_optimization import FireworksOptimization

pyvolutionary/fireworks/fireworks_optimization.py

@@ -0,0 +1,96 @@
+from typing import Final
+import numpy as np
+
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import Firework, FireworksOptimizationConfig
+
+
+class FireworksOptimization(OptimizationAbstract):
+    """
+    Implementation of the Fireworks Algorithm Optimization algorithm.
+
+    Args:
+        config (FireworksOptimizationConfig): an instance of FireworksAlgorithmOptimizationConfig class.
+            {parse_obj_doc(FireworksOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Yang, X. S. (2010). Fireworks algorithm for optimization. International Journal of Bio-Inspired Computation,
+        2(4), 78–84. https://doi.org/10.1504/IJBIC.2010.037285
+    [2] Yang, X. S. (2010). Fireworks Algorithm: A Novel Swarm Intelligence Optimization Method. In Nature Inspired
+        Cooperative Strategies for Optimization (pp. 355–364). Springer Berlin Heidelberg.
+        https://doi.org/10.1007/978-3-642-12538-6_35
+    [3] Yang, X. S. (2012). Fireworks Algorithm for Optimization. In Nature-Inspired Optimization Algorithms
+        (pp. 355–364). Elsevier. https://doi.org/10.1016/B978-0-12-416743-8.00016-2
+    [4] Yang, X. S. (2013). Fireworks Algorithm: Recent Advances and Applications. In Studies in Computational
+        Intelligence (Vol. 476, pp. 355–364). Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-31688-4_17
+    [5] Yang, X. S. (2014). Fireworks Algorithm: A Novel Swarm Intelligence Optimization Method. In Nature-Inspired
+        Computation in Engineering (pp. 355–364). Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-39829-2_35
+    [6] Yang, X. S. (2015). Fireworks Algorithm: A Survey. International Journal of Swarm Intelligence Research,
+        5(1), 1–18. https://doi.org/10.4018/IJSIR.2015010101
+    """
+    EPS: Final[float] = np.finfo(float).eps
+
+    def __init__(self, config: FireworksOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def __explode__(self) -> list[Firework]:
+        """
+        This method performs the explosion of the fireworks. It generates new fireworks by exploding the current ones.
+        Gaussian sparks are generated by each firework. The number of sparks is proportional to the cost of the
+        firework. The amplitude of the explosion is proportional to the cost of the firework. The new fireworks are
+        generated by adding the amplitude to the position of the firework. The new fireworks are then corrected to
+        be within the bounds of the search space. The new fireworks are then added to the population.
+        :return: the new population
+        :rtype: list[Firework]
+        """
+        costs = sorted([firework.cost for firework in self._population])
+
+        sparks_num = self._config.sparks_num
+        pop_size = self._config.population_size
+        explosion_amplitude = self._config.explosion_amplitude
+        a = self._config.a
+        b = self._config.b
+
+        n_dims = self._task.space_dimension
+
+        pop_new = []
+        for firework in self._population:
+            si = sparks_num * (costs[-1] - firework.cost + self.EPS) / (pop_size * costs[-1] - np.sum(costs) + self.EPS)
+            Ai = explosion_amplitude * (firework.cost - costs[0] + self.EPS) / (np.sum(costs) - costs[0] + self.EPS)
+
+            si_ = int(round(si) + 1)
+            if si < a * sparks_num:
+                si_ = int(round(a * sparks_num) + 1)
+            elif si > b * sparks_num:
+                si_ = int(round(b * sparks_num) + 1)
+
+            # generate Gaussian sparks
+            for j in range(0, si_):
+                pos_new = firework.position
+                list_idx = np.random.choice(range(0, n_dims), round(np.random.uniform() * n_dims), replace=False)
+                pos_new = [pos_new[i] + int(i in list_idx) * Ai * np.random.uniform(-1, 1) for i in range(0, n_dims)]
+                pop_new.append(Firework(**self._init_agent(pos_new).model_dump()))
+
+        return pop_new
+
+    def __evolve__(self, candidates: list[Firework]) -> list[Firework]:
+        sparks_num = self._config.sparks_num
+        pop_size = self._config.population_size
+        n_dims = self._task.space_dimension
+
+        for _ in range(0, sparks_num):
+            idx = np.random.randint(0, pop_size)
+            pos_new = self._population[idx].position
+            list_idx = np.random.choice(range(0, n_dims), round(np.random.uniform() * n_dims), replace=False)
+            # Gaussian explosion
+            pos_new = [pos_new[i] + int(i in list_idx) * np.random.normal(0, 1) for i in range(0, n_dims)]
+            candidates.append(Firework(**self._init_agent(pos_new).model_dump()))
+
+        return candidates
+
+    def optimization_step(self):
+        candidates = self.__evolve__(self.__explode__())
+        self._extend_and_trim_population(candidates)
+

pyvolutionary/fireworks/models.py

@@ -0,0 +1,41 @@
+from pydantic import model_validator, field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Firework(Agent):
+    pass
+
+
+class FireworksOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Fireworks Algorithm.
+        sparks_num (int): number of sparks to be generated by each firework.\n
+        a (float): (0, 1), parameter to control the explosion amplitude.\n
+        b (float): (0, 1), parameter to control the explosion amplitude.\n
+        explosion_amplitude (int): maximum amplitude of the explosion.\n
+        gaussian_explosion_number (int): number of gaussian explosions (less than the population size).
+    """
+    sparks_num: int
+    a: float
+    b: float
+    explosion_amplitude: int
+    gaussian_explosion_number: int
+
+    @model_validator(mode="after")
+    def validate_gaussian_explosion_number(self) -> "FireworksOptimizationConfig":
+        if self.gaussian_explosion_number > self.population_size:
+            raise ValueError("\"gaussian_explosion_number\" must be less than or equal to population_size")
+        return self
+
+    @field_validator("a")
+    def correct_a(cls, v):
+        if not 0 < v < 1:
+            raise ValueError(f"\"a\" must be a positive float lower than 1. Got {v}")
+        return v
+
+    @field_validator("b")
+    def correct_b(cls, v):
+        if not 0 < v < 1:
+            raise ValueError(f"\"b\" must be a positive float lower than 1. Got {v}")
+        return v

pyvolutionary/fish_school_search/__init__.py

@@ -0,0 +1,2 @@
+from .models import Fish, FishSchoolSearchOptimizationConfig
+from .fish_school_search_optimization import FishSchoolSearchOptimization