pyVolutionary 1.0.1__py3-none-any.whl

pyvolutionary/camel_caravan/camel_caravan_optimization.py

@@ -0,0 +1,96 @@
+import numpy as np
+
+from ..helpers import (
+    best_agent,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import Camel, CamelCaravanOptimizationConfig
+
+
+class CamelCaravanOptimization(OptimizationAbstract):
+    """
+    Implementation of the Camels Optimization algorithm.
+
+    Args:
+        config (CamelCaravanOptimizationConfig): an instance of CamelCaravanOptimizationConfig class.
+            {parse_obj_doc(CamelCaravanOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Ali, Ramzy. (2016). Novel Optimization Algorithm Inspired by Camel Traveling Behavior.
+        Iraq J. Electrical and Electronic Engineering. 12. 167-177.
+    """
+    def __init__(self, config: CamelCaravanOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def _init_agent(
+        self,
+        position: list[float] | np.ndarray | None = None,
+        endurance: float | None = None,
+        supply: float | None = None,
+    ) -> Camel:
+        agent = super()._init_agent(position=position)
+
+        return Camel(
+            **agent.model_dump(),
+            endurance=endurance if endurance is not None else self._config.endurance,
+            supply=supply if supply is not None else self._config.supply,
+            temperature=np.random.uniform(*self._config.temperatures),
+        )
+
+    def __walk__(self, camel: Camel) -> Camel:
+        """
+        Move the camel in search space. This function is used to move Camel.
+        :param camel: the camel to consider.
+        :return: the moved camel.
+        :rtype: Camel
+        """
+        bc_position = np.array(best_agent(self._population).position)
+
+        min_temperature, max_temperature = self._config.temperatures
+
+        temperature = np.random.uniform(min_temperature, max_temperature)
+        supply = camel.supply * (1 - self._config.burden_factor * camel.steps / self._config.max_cycles)
+        endurance = camel.endurance * (1 - temperature / max_temperature) * (1 - camel.steps / self._config.max_cycles)
+
+        new_position = camel.position + np.random.uniform(-1, 1) * (
+            1 - (endurance / self._config.endurance)
+        ) * np.exp(1 - supply / self._config.supply) * (bc_position - np.array(camel.position))
+        if self._is_valid_position(new_position):
+            return self._init_agent(position=new_position, endurance=endurance, supply=supply)
+
+        return self._init_agent(position=camel.position, endurance=endurance, supply=supply)
+
+    def __oasis__(self, camel: Camel, past_cost: float) -> Camel:
+        """
+        Apply oasis function to Camel. This function is used to refill supply and endurance of Camel.
+        :param camel: the camel to consider.
+        :param past_cost: the past cost of Camel.
+        :return: the camel after oasis function.
+        """
+        if np.random.random() <= (1 - self._config.visibility) and camel.cost <= past_cost:
+            camel.supply = self._config.supply
+            camel.endurance = self._config.endurance
+        return camel
+
+    def __life_cycle__(self, camel: Camel, past_cost: float) -> Camel:
+        """
+        Apply life cycle to Camel. This function is used to kill Camel.
+        :param camel: the camel to consider.
+        :param past_cost: the past cost of Camel.
+        :return: the camel after life cycle.
+        """
+        if past_cost <= self._config.death_rate * camel.cost:
+            return self._init_agent(endurance=self._config.endurance, supply=self._config.supply)
+
+        camel.steps += 1
+        return camel
+
+    def optimization_step(self):
+        for idx in range(0, self._config.population_size):
+            camel = self._population[idx].model_copy()
+            past_cost = camel.cost
+
+            camel = self.__life_cycle__(self.__walk__(camel), past_cost)
+            self._population[idx] = self.__oasis__(camel, past_cost)

pyvolutionary/camel_caravan/models.py

@@ -0,0 +1,61 @@
+import numpy as np
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Camel(Agent):
+    endurance: float
+    supply: float
+    temperature: float | None = None
+    steps: int = 1
+
+
+class CamelCaravanOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Camel Caravan algorithm.
+        burden_factor (float): [0, 1], burden factor.\n
+        death_rate (float): [0, 1], dying rate.\n
+        visibility (float): view range of camel.\n
+        supply (float): (0, Inf), initial supply.\n
+        endurance (float): (0, Inf), initial endurance.\n
+        temperatures (list[float]): minimum and maximum temperatures.\n
+    """
+    burden_factor: float
+    death_rate: float
+    visibility: float
+    supply: float
+    endurance: float
+    temperatures: list[float]
+
+    @field_validator('burden_factor')
+    def check_burden_factor(cls, v):
+        if not 0 <= v <= 1:
+            raise ValueError('burden_factor must be in range [0, 1]')
+        return v
+
+    @field_validator('death_rate')
+    def check_death_rate(cls, v):
+        if not 0 <= v <= 1:
+            raise ValueError('death_rate must be in range [0, 1]')
+        return v
+
+    @field_validator('supply')
+    def check_supply(cls, v):
+        if not 0 < v:
+            raise ValueError('supply must be greater than 0')
+        return v
+
+    @field_validator('endurance')
+    def check_endurance(cls, v):
+        if not 0 < v:
+            raise ValueError('endurance must be greater than 0')
+        return v
+
+    @field_validator('temperatures')
+    def check_temperatures(cls, v):
+        if not len(v) == 2:
+            raise ValueError('temperatures must be a list of length 2')
+        if not v[0] < v[1]:
+            raise ValueError('temperatures[0] must be less than temperatures[1]')
+        return v

pyvolutionary/coral_reef/__init__.py

@@ -0,0 +1,2 @@
+from .models import Coral, CoralReefOptimizationConfig
+from .coral_reef_optimization import CoralReefOptimization

pyvolutionary/coral_reef/coral_reef_optimization.py

@@ -0,0 +1,133 @@
+import numpy as np
+
+from ..helpers import (
+    sort_and_trim,
+    parse_obj_doc  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import Coral, CoralReefOptimizationConfig
+
+
+class CoralReefOptimization(OptimizationAbstract):
+    """
+    Implementation of the Coral Reef Optimization algorithm.
+
+    Args:
+        config (CoralReefOptimizationConfig): an instance of CoralReefOptimizationConfig class.
+            {parse_obj_doc(CoralReefOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Salcedo-Sanz, S., Del Ser, J., Landa-Torres, I., Gil-López, S. and Portilla-Figueras, J.A., 2014.
+        The coral reefs optimization algorithm: a novel metaheuristic for efficiently solving optimization problems.
+        The Scientific World Journal, 2014.
+    """
+    def __init__(self, config: CoralReefOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        _, self.__G1 = self._config.gamma
+        self.__alpha = 10 * self._config.Pd / self._config.max_cycles
+        self.__gamma = 10 * (self._config.gamma[1] - self._config.gamma[0]) / self._config.max_cycles
+        self.__num_occupied = int(self._config.population_size / (1 + self._config.po))
+        self.__dyn_Pd = 0
+        self.__occupied_list = np.zeros(self._config.population_size, dtype=int)
+        self.__occupied_idx_list = np.random.choice(
+            list(range(self._config.population_size)), self.__num_occupied, replace=False
+        )
+        self.__occupied_list[self.__occupied_idx_list] = 1
+        self.__reset_count = 0
+
+    def __broadcast_spawning_brooding__(self) -> list[Coral]:
+        """
+        Broadcast spawning and brooding process. This process is done in two steps: 1a and 1b. In step 1a, the corals
+        that are going to broadcast spawning are selected. In step 1b, the corals that are going to brooding are
+        selected. The corals that are going to broadcast spawning are selected randomly from the occupied corals. The
+        corals that are going to brooding are selected randomly from the occupied corals that are not selected for
+        broadcast spawning.
+        :return: the list of larvae.
+        :rtype: list[Coral]
+        """
+        def gaussian_mutation(position):
+            return self._correct_position(np.where(
+                np.random.random(self._task.space_dimension) < self._config.GCR,
+                position + self.__G1 * self._bandwidth() * np.random.normal(0, 1,  self._task.space_dimension),
+                position
+            ))
+
+        def multi_point_cross(pos1, pos2):
+            p1, p2 = np.random.choice(list(range(0, len(pos1))), 2, replace=False)
+            start, end = min(p1, p2), max(p1, p2)
+            return self._correct_position(
+                np.concatenate((pos1[:start], pos2[start:end], pos1[end:]), axis=0)
+            )
+
+        # Step 1a
+        selected_corals = np.random.choice(
+            self.__occupied_idx_list, int(len(self.__occupied_idx_list) * self._config.Fb), replace=False
+        )
+        larvae = [Coral(**self._init_agent(gaussian_mutation(self._population[idx].position)).model_dump())
+                  for idx in self.__occupied_idx_list if idx not in selected_corals]
+
+        # Step 1b
+        while len(selected_corals) >= 2:
+            id1, id2 = np.random.choice(range(len(selected_corals)), 2, replace=False)
+            agent = Coral(**self._init_agent(multi_point_cross(
+                self._population[selected_corals[id1]].position,
+                self._population[selected_corals[id2]].position
+            )).model_dump())
+            larvae.append(agent)
+            selected_corals = np.delete(selected_corals, [id1, id2])
+        return larvae
+
+    def __larvae_setting__(self, larvae: list[Coral]):
+        """
+        Larvae setting process. This process is done in two steps: 2a and 2b. In step 2a, the larvae are evaluated and
+        the larvae that are going to be settled are selected. In step 2b, the larvae that are going to be settled are
+        placed in the occupied corals.
+        :param larvae: the list of larvae.
+        """
+        def find_available_slot(lc: Coral) -> tuple[int | None, bool]:
+            for i in range(self._config.n_trials):
+                p = np.random.randint(0, self._config.population_size - 1)
+                if self.__occupied_list[p] == 0:
+                    return p, True
+                if lc.cost < self._population[p].cost:
+                    return p, False
+            return None, False
+
+        def update(p: int, upd: bool, lc: Coral):
+            self._population[p] = lc  # update population
+            if upd:
+                self.__occupied_idx_list = np.append(self.__occupied_idx_list, p)  # update occupied id
+                self.__occupied_list[p] = 1  # update occupied list
+
+        # trial to land on a square of reefs
+        res = list(map(find_available_slot, larvae))
+        for idx, (pdx, upd_occupied) in enumerate(res):
+            if pdx is not None:
+                update(pdx, upd_occupied, larvae[idx])
+
+    def __reef_cost__(self, idx):
+        return self._population[idx].cost
+
+    def optimization_step(self):
+        # broadcast spawning brooding
+        larvae = self.__broadcast_spawning_brooding__()
+        self.__larvae_setting__(larvae)
+
+        # asexual reproduction
+        pop_best = sort_and_trim(
+            [self._population[idx] for idx in self.__occupied_idx_list],
+            int(len(self.__occupied_idx_list) * self._config.Fa)
+        )
+        self.__larvae_setting__(pop_best)
+
+        # depredation
+        if np.random.random() < self.__dyn_Pd:
+            num_depredation = int(len(self.__occupied_idx_list) * self._config.Fd)
+            idx_list_sorted = sorted(self.__occupied_idx_list, key=self.__reef_cost__)
+            for idx in idx_list_sorted[-num_depredation:]:
+                self.__occupied_list[idx] = 0
+        if self.__dyn_Pd <= self._config.Pd:
+            self.__dyn_Pd += self.__alpha
+        if self.__G1 >= self._config.gamma[0]:
+            self.__G1 -= self.__gamma

pyvolutionary/coral_reef/models.py

@@ -0,0 +1,81 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Coral(Agent):
+    pass
+
+
+class CoralReefOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Coral Reef algorithm.
+        po (float): [0.2, 0.5], the rate between free/occupied at the beginning.\n
+        Fb (float): [0.6, 0.9], BroadcastSpawner/ExistingCorals rate.\n
+        Fa (float): [0.05, 0.3], fraction of corals duplicates its self and tries to settle in a different part of the
+        reef.\n
+        Fd (float): [0.05, 0.5], fraction of the worse health corals in reef will be applied depredation.\n
+        Pd (float): [0.1, 0.7], Probability of depredation.\n
+        GCR (float): [0.05, 0.2], probability for mutation process.\n
+        gamma (list[float]): [0.01, 0.1], [0.1, 0.5], min and max factors for mutation process.\n
+        n_trials (int): [2, 10], number of attempts for a larvae to set in the reef.
+    """
+    po: float
+    Fb: float
+    Fa: float
+    Fd: float
+    Pd: float
+    GCR: float
+    gamma: list[float]
+    n_trials: int
+
+    @field_validator('po')
+    def check_po(cls, v):
+        if not 0.2 <= v <= 0.5:
+            raise ValueError('po must be in range [0.2, 0.5]')
+        return v
+
+    @field_validator('Fb')
+    def check_Fb(cls, v):
+        if not 0.6 <= v <= 0.9:
+            raise ValueError('Fb must be in range [0.6, 0.9]')
+        return v
+
+    @field_validator('Fa')
+    def check_Fa(cls, v):
+        if not 0.05 <= v <= 0.3:
+            raise ValueError('Fa must be in range [0.05, 0.3]')
+        return v
+
+    @field_validator('Fd')
+    def check_Fd(cls, v):
+        if not 0.05 <= v <= 0.5:
+            raise ValueError('Fd must be in range [0.05, 0.5]')
+        return v
+
+    @field_validator('Pd')
+    def check_Pd(cls, v):
+        if not 0.1 <= v <= 0.7:
+            raise ValueError('Pd must be in range [0.1, 0.7]')
+        return v
+
+    @field_validator('GCR')
+    def check_GCR(cls, v):
+        if not 0.05 <= v <= 0.2:
+            raise ValueError('GCR must be in range [0.05, 0.2]')
+        return v
+
+    @field_validator('gamma')
+    def check_gamma(cls, v):
+        gamma_min, gamma_max = v
+        if not 0.01 <= gamma_min <= 0.1:
+            raise ValueError('gamma_min must be in range [0.01, 0.1]')
+        if not 0.1 <= gamma_max <= 0.5:
+            raise ValueError('gamma_max must be in range [0.1, 0.5]')
+        return v
+
+    @field_validator('n_trials')
+    def check_n_trials(cls, v):
+        if not 2 <= v <= 10:
+            raise ValueError('n_trials must be in range [2, 10]')
+        return v

pyvolutionary/coyotes/__init__.py

@@ -0,0 +1,2 @@
+from .models import Coyote, CoyotesOptimizationConfig
+from .coyotes_optimization import CoyotesOptimization

pyvolutionary/coyotes/coyotes_optimization.py

@@ -0,0 +1,96 @@
+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 Coyote, CoyotesOptimizationConfig
+
+
+class CoyotesOptimization(OptimizationAbstract):
+    """
+    Implementation of the Coyotes Optimization algorithm.
+
+    Args:
+        config (CoyotesOptimizationConfig): an instance of CoyotesOptimizationConfig class.
+            {parse_obj_doc(CoyotesOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Pierezan, J. and Coelho, L.D.S., 2018, July. Coyote optimization algorithm: a new metaheuristic
+        for global optimization problems. In 2018 IEEE congress on evolutionary computation (CEC) (pp. 1-8). IEEE.
+    """
+    def __init__(self, config: CoyotesOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__n_packs: int = 0
+        self.__ps: float = 0.
+        self.__p_leave: float = 0.
+        self.__packs: list[list[Coyote]] = []
+
+    def before_initialization(self):
+        self.__n_packs = int(self._config.population_size / self._config.num_coyotes)
+        self.__ps = 1. / self._task.space_dimension  # Probability of selecting a dimension
+        self.__p_leave = 0.005 * (self._config.num_coyotes ** 2)  # Probability of leaving a pack
+
+    def _init_agent(self, position: list[float] | np.ndarray | None = None, age: int | None = None) -> Coyote:
+        agent = super()._init_agent(position)
+        return Coyote(**agent.model_dump(), age=age if age is not None else 0)
+
+    def optimization_step(self):
+        self.__packs = generate_group_population(self._population, self.__n_packs, self._config.num_coyotes)
+
+        for p in range(self.__n_packs):
+            pack = self.__packs[p]
+
+            # get the coyotes that belong to each pack and compute the social tendency of the pack (Eq. 6)
+            sort_by_cost(pack)
+            tendency = np.mean(np.array([coyote.position for coyote in pack]), axis=0)
+
+            # update social condition of coyotes (Eq. 8)
+            for i, coyote in enumerate(pack):
+                rc1, rc2 = np.random.choice(list(set(range(0, self._config.num_coyotes)) - {i}), 2, replace=False)
+
+                # try to update the social condition according to the alpha and the pack tendency (Eq. 12)
+                pos_new = np.array(coyote.position) + np.random.random() * (
+                    np.array(pack[0].position) - np.array(pack[rc1].position)
+                ) + np.random.random() * (tendency - np.array(pack[rc2].position))
+
+                # keep the coyotes in the search space (optimization problem constraint) and evaluate the new position
+                # it means to evaluate the new social condition (Eq. 13) and apply the adaptation (Eq. 14)
+                pack[i] = self._greedy_select_agent(
+                    coyote, self._init_agent(self._correct_position(pos_new), coyote.age)
+                )
+
+            # birth of a new coyote from random parents (Eq. 7 and Alg. 1)
+            id_parent1, id_parent2 = np.random.choice(list(range(0, self._config.num_coyotes)), 2, replace=False)
+            # generate the coyote considering intrinsic and extrinsic influence, with eventual noise
+            pup_pos = np.array(np.where(
+                np.random.random(self._task.space_dimension) < (1. - self.__ps) / 2.,
+                pack[id_parent1].position,
+                pack[id_parent2].position
+            )) * np.random.normal(0, 1)
+            pup = self._init_agent(self._correct_position(pup_pos.tolist()))
+
+            # Verify if the pup will survive
+            sort_by_cost(pack)
+            # find index of element has cost larger than new child: if existing, new child is good
+            if pup.cost < pack[-1].cost:
+                # replace the worst element by new child, New born child with age = 0
+                pack = sorted(pack, key=lambda x: x.age)
+                pack[-1] = pup
+                self.__packs[p] = [coyote.model_copy() for coyote in pack]
+
+        # a coyote can leave a pack and enter to another pack (Eq. 4)
+        if self.__n_packs > 1 and np.random.random() < self.__p_leave:
+            id_pack1, id_pack2 = np.random.choice(list(range(0, self.__n_packs)), 2, replace=False)
+            id1, id2 = np.random.choice(list(range(0, self._config.num_coyotes)), 2, replace=False)
+            self.__packs[id_pack1][id1], self.__packs[id_pack2][id2] = (
+                self.__packs[id_pack2][id2], self.__packs[id_pack1][id1]
+            )
+
+        # Update coyotes ages
+        self._population = [
+            self._init_agent(position=coyote.position, age=coyote.age + 1) for pack in self.__packs for coyote in pack
+        ]

pyvolutionary/coyotes/models.py

@@ -0,0 +1,22 @@
+from pydantic import model_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Coyote(Agent):
+    age: int
+
+
+class CoyotesOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Coyotes Optimization algorithm.
+        num_coyotes (int): [2, int(population_size/2)], the number of coyotes per group.
+    """
+    num_coyotes: int
+
+    @model_validator(mode="after")
+    def validate_keep(self) -> "CoyotesOptimizationConfig":
+        if not 2 <= self.num_coyotes <= int(self.population_size / 2):
+            raise ValueError(f"num_coyotes must be greater than 2 and lower than population_size / 2. "
+                             f"Got {self.num_coyotes}")
+        return self

pyvolutionary/earthworms/__init__.py

@@ -0,0 +1,2 @@
+from .models import Earthworm, EarthwormsOptimizationConfig
+from .earthworms_optimization import EarthwormsOptimization

pyvolutionary/earthworms/earthworms_optimization.py

@@ -0,0 +1,124 @@
+import numpy as np
+
+from ..helpers import (
+    best_agents,
+    sort_by_cost,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import Earthworm, EarthwormsOptimizationConfig
+
+
+class EarthwormsOptimization(OptimizationAbstract):
+    """
+    Implementation of the Earthworms Optimization algorithm.
+
+    Args:
+        config (EarthwormsOptimizationConfig): an instance of EarthwormsOptimizationConfig class.
+            {parse_obj_doc(EarthwormsOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Wang, Gai-Ge & Deb, Suash & Coelho, Leandro. (2015). Earthworm optimization algorithm: a bio-inspired
+        metaheuristic algorithm for global optimization problems. International Journal of Bio-Inspired Computation.
+        DOI: 10.1504/IJBIC.2015.10004283.
+    """
+    def __init__(self, config: EarthwormsOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__chrome_keep: list[Earthworm] = []
+        self.__dyn_beta = self._config.beta
+
+    def __evolve__(self):
+        """
+        The earthworm optimization algorithm process. It is composed of two reproduction operators and a mutation
+        operator. The reproduction operators are used to generate new individuals, and the mutation operator is used
+        to improve the individuals. The reproduction operators are: (1) the first way of reproducing, and (2) the
+        second way of reproducing. The mutation operator is: Cauchy's mutation (CM). The reproduction operators and
+        the mutation operator are applied to all individuals in the population.
+        :return:
+        """
+        alpha = self._config.alpha
+        beta = self.__dyn_beta
+
+        n_chromes = self._config.population_size
+        keep = self._config.keep
+        for idx in range(0, self._config.population_size):
+            position = np.array(self._population[idx].position)
+
+            # reproduction 1: the first way of reproducing
+            x_t1 = self._sum_bounds() - alpha * np.array(position)
+
+            # reproduction 2: the second way of reproducing
+            x_child = self._population[np.random.randint(0, n_chromes - 1)].position
+            if idx >= keep:  # select two parents to mate and create two children
+                # 80% parents selected from best population
+                rng = range(0, int(n_chromes * 0.2)) if np.random.uniform(0, 1) < 0.5 else range(idx, n_chromes)
+                idx1, idx2 = np.random.choice(rng, 2, replace=len(rng) < 2)
+                r = np.random.rand()
+                x_child = (
+                    r * np.array(self._population[idx2].position) + (1 - r) * np.array(self._population[idx1].position)
+                )
+
+            self._population[idx] = self._init_agent(beta * np.array(x_t1) + (1 - beta) * np.array(x_child))
+        self.__dyn_beta *= self._config.gamma
+
+    def __cauchy_mutation__(self):
+        """
+        Cauchy's mutation (CM): make sure each individual is legal
+        """
+        keep = self._config.keep
+
+        pos_list = np.array([agent.position for agent in self._population])
+        x_mean = np.mean(pos_list, axis=0)
+        cauchy_w = self._best_agent.position
+        for idx in range(keep, self._config.population_size):
+            # Cauchy's mutation (CM)
+            cauchy_w = np.where(np.random.rand() < self._config.prob_mutate, x_mean, cauchy_w)
+            x_t1 = (cauchy_w + self._best_agent.position) / 2
+            # make sure each individual is legal
+            self._population[idx] = self._init_agent(x_t1)
+
+    def __clear_duplicates__(self):
+        """
+        Clear duplicates in the population
+        """
+        n_chromes = self._config.population_size
+        for idx in range(0, n_chromes):
+            pos_idx = self._population[idx].position
+
+            jdx_list = [jdx for jdx, chrome in enumerate(self._population[(idx + 1):], idx + 1) if np.array_equal(
+                pos_idx, chrome.position
+            )]
+            for jdx in jdx_list:
+                dimension_to_change = np.random.randint(0, self._task.space_dimension - 1)
+                position_jdx = self._population[jdx].position
+                position_jdx[dimension_to_change] = self._uniform_coordinates(dimension_to_change)
+                self._population[jdx] = self._init_agent(position_jdx)
+
+    def __elitism__(self, agents: list[Earthworm], keep: int):
+        """
+        Elitism operator. Replace the worst individuals with the best ones from the previous cycle.
+        :param agents: the agents
+        :param keep: the number of best individuals to keep
+        """
+        # sorted from best, i.e., minor cost, to worst
+        sort_by_cost(self._population)
+        population_size = self._config.population_size
+        for idx in range(0, keep):
+            self._population[population_size - idx - 1] = agents[idx].model_copy()
+
+    def optimization_step(self):
+        # elitism strategy: save the best "keep" earthworms into the self.__chrome_keep
+        self.__chrome_keep = best_agents(self._population, self._config.keep)
+
+        # the earthworm optimization algorithm process
+        self.__evolve__()
+
+        # Cauchy's mutation (CM): make sure each individual is legal and doesn't have duplicates
+        self.__cauchy_mutation__()
+
+        # elitism strategy: save the best earthworms in a temporary array
+        self.__elitism__(self.__chrome_keep, self._config.keep)
+
+        # clear duplicates in the population
+        self.__clear_duplicates__()