pyVolutionary 1.0.1__py3-none-any.whl

pyvolutionary/imperialist_competitive/classes.py

@@ -0,0 +1,119 @@
+import numpy as np
+
+from .models import Empire as EmpireModel
+from ..enums import TaskType
+from ..helpers import calculate_fitness
+from ..models import Agent
+
+
+class Country:
+    def __init__(self, agent: Agent):
+        self.__colonies = []
+        self.__from_agent(agent)
+
+    def __from_agent(self, agent: Agent):
+        self.__representation = agent.position
+        self.__makespan = agent.cost
+
+    @property
+    def is_colony(self):
+        return False
+
+    @property
+    def is_imperialist(self):
+        return not self.is_colony
+
+    @property
+    def representation(self):
+        return self.__representation
+
+    @property
+    def position(self):
+        return self.representation
+
+    @property
+    def cost(self):
+        return self.__makespan
+
+    def set_representation(self, agent: Agent):
+        self.__from_agent(agent)
+
+
+class Empire:
+    def __init__(self, emperor: Country):
+        self.__emperor = emperor
+        self.__colonies: list[Country] = []
+        self.__cost = emperor.cost
+
+    def __calculate_cost(self):
+        self.__cost = self.__emperor.cost + sum([x.cost for x in self.__colonies])
+
+    def replace_colony(self, index: int, colony: Country):
+        self.__colonies[index] = colony
+        self.__calculate_cost()
+
+    def replace_emperor(self, colony: Country):
+        self.__emperor = colony
+        self.__calculate_cost()
+
+    def delete_colony(self, index: int):
+        del self.__colonies[index]
+        self.__calculate_cost()
+
+    @property
+    def cost(self) -> float:
+        return self.__cost
+
+    def add_colony(self, colony: Country, index: int = 0):
+        self.__colonies.insert(len(self.__colonies) if index == 0 else index, colony)
+        self.__calculate_cost()
+
+    def remove_colony(self, index: int):
+        del self.__colonies[index]
+        self.__calculate_cost()
+
+    @property
+    def number_of_colonies(self) -> int:
+        return len(self.__colonies)
+
+    @property
+    def colonies(self) -> list[Country]:
+        return self.__colonies
+
+    def get_colony(self, index: int) -> Country:
+        return self.__colonies[index]
+
+    def get_strongest_colony(self) -> tuple[int, Country | None]:
+        """
+        Among all the colonies, find the one and its index with the lowest cost
+        :return: a tuple of the index and the colony with the lowest cost
+        :rtype: tuple[int, Country]
+        """
+        if self.number_of_colonies == 0:
+            return -1, None
+
+        strongest_colony_index = np.argmin(np.array([colony.cost for colony in self.__colonies]))
+        strongest_colony = self.get_colony(strongest_colony_index)
+        return strongest_colony_index, strongest_colony
+
+    @property
+    def emperor(self) -> Country:
+        return self.__emperor
+
+
+class Transformer:
+    """
+    This class is used to transform the Empire class to EmpireModel class.
+    """
+    @staticmethod
+    def transform(empire: Empire, task_type: TaskType) -> EmpireModel:
+        """
+        :type empire: Empire
+        :param empire: the empire to be transformed
+        :param task_type: the type of the task, i.e. whether it is a minimization or maximization task
+        :return: an instance of EmpireModel class, i.e. the pydantic representation of the empire
+        """
+        cost = empire.cost
+        return EmpireModel(
+            position=empire.emperor.representation, cost=cost, fitness=calculate_fitness(cost, task_type)
+        )

pyvolutionary/imperialist_competitive/imperialist_competitive_optimization.py

@@ -0,0 +1,198 @@
+import math
+import numpy as np
+
+from .classes import Country
+from ..helpers import (
+    random_selection,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .classes import Empire as EmpireClass, Transformer
+from .models import ImperialistCompetitiveOptimizationConfig
+
+
+class ImperialistCompetitiveOptimization(OptimizationAbstract):
+    """
+    Implementation of the Imperialist Competitive Optimization algorithm.
+
+    Args:
+        config (ParticleSwarmOptimizationConfig): an instance of ParticleSwarmOptimizationConfig class.
+            {parse_obj_doc(ParticleSwarmOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Esmaeilzadeh, E., & Ghane, M. (2013). Imperialist competitive algorithm: A metaheuristic algorithm for
+        optimization inspired by imperialistic competition. 2013 3rd International Conference on Computer and Knowledge
+        Engineering (ICCKE), 1–6. https://doi.org/10.1109/ICCKE.2013.6687751
+    [2] Esmaeilzadeh, E., & Ghane, M. (2014). Imperialist competitive algorithm: An algorithm for optimization inspired
+        by imperialistic competition. Applied Soft Computing Journal, 14, 240–256.
+        https://doi.org/10.1016/j.asoc.2013.08.006
+    """
+    def __init__(self, config: ImperialistCompetitiveOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__countries: list[Country] = []
+        self.__empires: list[EmpireClass] = []
+
+    def _init_population(self):
+        # Create countries
+        k = self._config.number_of_countries
+        countries = []
+        i = 0
+        while i < k:
+            candidate = Country(self._init_agent())
+            if (True for elem in countries if np.array_equal(elem.representation, candidate.representation)):
+                countries.append(candidate)
+                i += 1
+
+        self.__countries = countries
+
+        # Create empires
+        costs = np.array([np.sum(countries[i].cost) for i in range(0, len(countries))])
+        indices = np.argsort(costs)
+        new_countries = np.array([countries[i] for i in indices])
+
+        candidate_empires = new_countries[:self._config.population_size]
+        candidate_colonies = new_countries[self._config.population_size:]
+
+        for ctr in candidate_empires:
+            self.__empires.append(EmpireClass(ctr))
+
+        empires_costs = np.array([np.sum(empire.cost) for empire in self.__empires])
+        p = np.exp(-np.multiply(self._config.alpha_rate, empires_costs) / np.max(empires_costs))
+        p = p / np.sum(p)
+        for country in candidate_colonies:
+            k = random_selection(p)
+            self.__empires[k].add_colony(country)
+
+        task_type = self._task.minmax
+        self._population = [Transformer.transform(empire, task_type) for empire in self.__empires]
+
+    def __assimilate(self):
+        """
+        Assimilate colonies into empires. The assimilation rate is defined by the user. The assimilation is done by
+        replacing the representation of the colony with the representation of the empire.
+        """
+        assimilation_rate = self._config.assimilation_rate
+        dim = self._task.space_dimension
+        for empire in self.__empires:
+            empire_representation = empire.emperor.representation
+            for colony in empire.colonies:
+                candidates = np.random.choice(
+                    range(0, dim), int(np.round(dim * assimilation_rate, decimals=0)), replace=False,
+                )
+                colony.set_representation(self._init_agent(
+                    [r if i in candidates else colony.representation[i] for i, r in enumerate(empire_representation)]
+                ))
+
+    def __revolution(self):
+        """
+        Revolution is a process that is applied to a colony. The revolution rate is defined by the user. The revolution
+        is done by exchanging the representation of the colony with the representation of another colony.
+        """
+        revolution_probability = self._config.revolution_probability
+        revolution_rate = self._config.revolution_rate
+        fcn = self._fcn
+        dim = self._task.space_dimension
+        for empire in self.__empires:
+            for i, colony in enumerate(empire.colonies):
+                if np.random.random() <= revolution_probability:
+                    # select the colony to exchange with
+                    colony_representation = colony.representation
+                    old_cost = colony.cost
+                    number_of_tasks = int(math.ceil(revolution_rate * dim))
+
+                    candidates = np.random.choice(range(0, dim), number_of_tasks, replace=False)
+                    exchange = list(range(0, dim))
+
+                    # remove the candidates from the exchange list
+                    for index in candidates:
+                        del exchange[index]
+
+                    # select the candidates to exchange with
+                    exchange_candidates = np.random.choice(exchange, number_of_tasks)
+                    new_colony_representation = colony_representation
+                    # exchange the candidates
+                    for (x, y) in zip(candidates, exchange_candidates):
+                        new_colony_representation[x], new_colony_representation[y] = (
+                            colony_representation[y], colony_representation[x]
+                        )
+                    new_colony = Country(self._init_agent(new_colony_representation))
+                    if new_colony.cost < old_cost:
+                        empire.replace_colony(i, new_colony)
+
+    def __inter_empire_war(self):
+        """
+        Inter-empire competition is a process that is applied to empires. The weakest empire is selected and a war is
+        held between the weakest empire and the other empires. The probability of winning the war is proportional to
+        the cost of the empire. The winning empire assimilates the weakest empire's colonies and the weakest colony
+        from the weakest empire. If the weakest empire has no colonies, then the weakest emperor is assimilated by the
+        winning empire.
+        """
+        if len(self.__empires) == 1:
+            return
+
+        total_cost = np.array([empire.cost for empire in self.__empires])
+
+        # the weakest empire is the one with the highest cost
+        weakest_empire_index = np.argmax(total_cost)
+        weakest_empire = self.__empires[weakest_empire_index]
+        p = np.exp(-np.multiply(self._config.alpha_rate, total_cost) / np.max(total_cost))
+
+        # the weakest empire has a probability of 0 to win the war
+        p[weakest_empire_index] = 0
+        p = p / np.sum(p)
+        # if all probabilities are 0, then the weakest empire wins the war
+        if np.any(np.isnan(p)):
+            p[np.isnan(p)] = 0
+            if all(p == 0):
+                p[:] = 1
+            p = p / sum(p)
+
+        # if the weakest empire has colonies, then select the weakest colony and add it to the winning empire
+        if weakest_empire.number_of_colonies > 0:
+            weakest_empire_colonies_cost = np.array([colony.cost for colony in weakest_empire.colonies])
+            weakest_colony_index = np.argmax(weakest_empire_colonies_cost)
+            weakest_colony = weakest_empire.get_colony(weakest_colony_index)
+
+            winning_empire_index = random_selection(p)
+            winning_empire = self.__empires[winning_empire_index]
+
+            winning_empire.add_colony(weakest_colony)
+            weakest_empire.delete_colony(weakest_colony_index)
+
+        # if the weakest empire has no colonies, then select the weakest emperor and add it to the winning empire
+        if weakest_empire.number_of_colonies == 0:
+            winning_empire_index = random_selection(p)
+            winning_empire = self.__empires[winning_empire_index]
+
+            winning_empire.add_colony(weakest_empire.emperor)
+            del self.__empires[self.__empires.index(weakest_empire)]
+
+    def __intra_empire_war(self):
+        """
+        Intra-empire competition is a process that is applied to empires. It replaces a weakest emperor with the
+        strongest colony in case of internal war. The probability of winning the war is proportional to the cost of the
+        colony. Total cost remains unchanged for the empire
+        """
+        for empire in self.__empires:
+            strongest_colony_index, strongest_colony = empire.get_strongest_colony()
+            # if there is a picked colony and its cost is lower than the emperor, then swap them
+            if strongest_colony and strongest_colony.cost < empire.emperor.cost:
+                empire.replace_colony(strongest_colony_index, empire.emperor)
+                empire.replace_emperor(strongest_colony)
+
+    def optimization_step(self):
+        # assimilation
+        self.__assimilate()
+
+        # revolution
+        self.__revolution()
+
+        # Intra - empire competition
+        self.__intra_empire_war()
+
+        # Inter - empire competition
+        self.__inter_empire_war()
+
+        task_type = self._task.minmax
+        self._population = [Transformer.transform(empire, task_type) for empire in self.__empires]

pyvolutionary/imperialist_competitive/models.py

@@ -0,0 +1,47 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Empire(Agent):
+    pass
+
+
+class ImperialistCompetitiveOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Imperialist Competitive Optimization algorithm.
+        assimilation_rate (float): [0, 1), the rate of assimilation of the colonies by the imperialist.\n
+        revolution_rate (float): [0, 1), the rate of revolution of the colonies.\n
+        alpha_rate (float): [0, 1), the rate of alpha.\n
+        revolution_probability (float): [0, 1), the probability of revolution.\n
+        number_of_countries (int): the number of countries per empire.\n
+    """
+    assimilation_rate: float
+    revolution_rate: float
+    alpha_rate: float
+    revolution_probability: float
+    number_of_countries: int
+
+    @field_validator("assimilation_rate")
+    def correct_assimilation_rate(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"assimilation_rate\" must be a positive float lower than 1. Got {v}")
+        return v
+
+    @field_validator("revolution_rate")
+    def correct_revolution_rate(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"revolution_rate\" must be a positive float lower than 1. Got {v}")
+        return v
+
+    @field_validator("alpha_rate")
+    def correct_alpha_rate(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"alpha_rate\" must be a positive float lower than 1. Got {v}")
+        return v
+
+    @field_validator("revolution_probability")
+    def correct_revolution_probability(cls, v):
+        if not 0 <= v < 1:
+            raise ValueError(f"\"revolution_probability\" must be a positive float lower than 1. Got {v}")
+        return v

pyvolutionary/invasive_weed/__init__.py

@@ -0,0 +1,2 @@
+from .models import InvasiveWeed, InvasiveWeedOptimizationConfig
+from .invasive_weed_optimization import InvasiveWeedOptimization

pyvolutionary/invasive_weed/invasive_weed_optimization.py

@@ -0,0 +1,52 @@
+import numpy as np
+
+from ..helpers import (
+    special_agents,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import InvasiveWeedOptimizationConfig
+
+
+class InvasiveWeedOptimization(OptimizationAbstract):
+    """
+    Implementation of the Invasive Weed Optimization algorithm.
+
+    Args:
+        config (InvasiveWeedOptimizationConfig): an instance of InvasiveWeedOptimizationConfig class.
+            {parse_obj_doc(InvasiveWeedOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Mehrabian, A.R. and Lucas, C., 2006. A novel numerical optimization algorithm inspired from weed colonization.
+        Ecological informatics, 1(4), pp.355-366.
+    """
+    def __init__(self, config: InvasiveWeedOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def optimization_step(self):
+        # update Standard Deviation
+        sigma_start, sigma_end = self._config.sigma
+        sigma = (
+            (self._config.max_cycles - self._cycles) / (self._config.max_cycles - 1)
+        ) ** self._config.exponent * (sigma_start - sigma_end) + sigma_end
+
+        # get best and worst Invasive Weeds
+        (best, ), (worst, ) = special_agents(self._population, n_best=1, n_worst=1)
+
+        seed_min, seed_max = self._config.seed
+        pop_size = self._config.population_size
+        n_dims = self._task.space_dimension
+
+        pop_new = []
+        for weed in self._population:
+            ratio = (
+                np.random.random() if best.cost == worst.cost else (weed.cost - worst.cost) / (best.cost - worst.cost)
+            )
+            s = min(int(np.ceil(seed_min + (seed_max - seed_min) * ratio)), int(np.sqrt(pop_size)))
+            for jdx in range(0, s):
+                # initialize offspring and generate random location
+                pop_new.append(self._init_agent(weed.position + sigma * np.random.normal(0, 1, n_dims)))
+
+        # update population
+        self._extend_and_trim_population(pop_new)

pyvolutionary/invasive_weed/models.py

@@ -0,0 +1,51 @@
+from pydantic import field_validator, model_validator, conlist
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class InvasiveWeed(Agent):
+    pass
+
+
+class InvasiveWeedOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Invasive Weed Optimization algorithm.
+        seed (list[int]): [1, 3], [4, pop_size/2], minmax numbers of Seeds.\n
+        exponent (int): [2, 4], variance reduction exponent.\n
+        sigma (list[float]): [0.5, 5.0], (0, 0.5), the initial minmax values of Standard Deviation.
+    """
+    seed: conlist(int, min_length=2, max_length=2)
+    exponent: int
+    sigma: conlist(float, min_length=2, max_length=2)
+
+    @model_validator(mode="after")
+    def validate_seed(self) -> "InvasiveWeedOptimizationConfig":
+        seed_min, seed_max = self.seed
+        if seed_max > self.population_size / 2:
+            raise ValueError(f"\"seed_max\" must be less than the half of the population_size. Got {seed_max}")
+        return self
+
+    @field_validator("seed")
+    def correct_seed(cls, v):
+        seed_min, seed_max = v
+
+        if not 1 <= seed_min <= 3:
+            raise ValueError(f"\"seed[0]\" must be a positive int within the range [1, 3]. Got {seed_min}")
+        if seed_max < 4:
+            raise ValueError(f"\"seed[1]\" must be a positive int within the range [4, pop_size/2]. Got {seed_max}")
+        return v
+
+    @field_validator("exponent")
+    def correct_exponent(cls, v):
+        if not 2 <= v <= 4:
+            raise ValueError(f"\"exponent\" must be a positive int within the range [2, 4]. Got {v}")
+        return v
+
+    @field_validator("sigma")
+    def correct_sigma(cls, v):
+        start, end = v
+        if not 0.5 <= start <= 5:
+            raise ValueError(f"\"sigma[0]\" must be a positive float within the range [0.5, 5]. Got {start}")
+        if not 0 < end < 0.5:
+            raise ValueError(f"\"sigma[1]\" must be a positive float within the range (0, 0.5). Got {end}")
+        return v

pyvolutionary/krill_herd/__init__.py

@@ -0,0 +1,2 @@
+from .models import Krill, KrillHerdOptimizationConfig
+from .krill_herd_optimization import KrillHerdOptimization

pyvolutionary/krill_herd/krill_herd_optimization.py

@@ -0,0 +1,179 @@
+from typing import Final
+import numpy as np
+
+from ..helpers import (
+    distance,
+    special_agents,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import Krill, KrillHerdOptimizationConfig
+
+
+class KrillHerdOptimization(OptimizationAbstract):
+    """
+    Implementation of the Krill Herd Optimization algorithm.
+
+    Args:
+        config (KrillHerdOptimizationConfig): an instance of KrillHerdOptimizationConfig class.
+            {parse_obj_doc(KrillHerdOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Amir Hossein Gandomi, Amir Hossein Alavi, Krill herd: A new bio-inspired optimization algorithm, Communications
+        in Nonlinear Science and Numerical Simulation, Volume 17, Issue 12, 2012, Pages 4831-4845, ISSN 1007-5704,
+        https://doi.org/10.1016/j.cnsns.2012.05.010.
+    """
+    EPS: Final[float] = np.finfo(float).eps
+
+    def __init__(self, config: KrillHerdOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__w_neighbour: np.ndarray | None = None
+        self.__w_foraging: np.ndarray | None = None
+
+    def before_initialization(self):
+        self.__w_neighbour = np.full(self._task.space_dimension, self._config.w_neighbour)
+        self.__w_foraging = np.full(self._task.space_dimension, self._config.w_foraging)
+
+    def _init_agent(
+        self,
+        position: list[float] | np.ndarray | None = None,
+        induced_speed: list[float] | None = None,
+        foraging_speed: list[float] | None = None,
+    ) -> Krill:
+        agent = super()._init_agent(position)
+
+        zeros = np.zeros(self._task.space_dimension).tolist()
+
+        return Krill(
+            **agent.model_dump(),
+            induced_speed=induced_speed if induced_speed is not None else zeros,
+            foraging_speed=foraging_speed if foraging_speed is not None else zeros,
+        )
+
+    def __get_food_location__(self) -> list[float]:
+        """
+        Get food location for krill heard.
+        :return: food location.
+        :rtype: list[float]
+        """
+        costs = np.array([krill.cost for krill in self._population])
+        positions = np.array([krill.position for krill in self._population])
+
+        return self._correct_position(np.array(
+            [np.sum(positions[:, i] / costs) for i in range(0, self._task.space_dimension)]
+        ) / np.sum(1 / costs))
+
+    def __get_x__(self, x: Krill, y: Krill) -> np.ndarray:
+        """
+        Get x values.
+        :param x: First krill/individual.
+        :param y: Second krill/individual.
+        :return: X values.
+        :rtype: np.ndarray
+        """
+        return (
+            (np.array(y.position) - np.array(x.position)) + self.EPS
+        ) / (distance(y.position, x.position) + self.EPS)
+
+    def __get_k__(self, x: Krill, y: Krill, best: Krill, worst: Krill) -> float:
+        """
+        Get k values.
+        :param x: First krill/individual.
+        :param y: Second krill/individual.
+        :param best: Best krill/individual.
+        :param worst: Worst krill/individual.
+        :return: K values.
+        :rtype: float
+        """
+        return (x.cost - y.cost + self.EPS) / (worst.cost - best.cost + self.EPS)
+
+    def __induce_neighbours_motion__(self, idx: int, krill: Krill, best: Krill, worst: Krill) -> np.ndarray:
+        """
+        Induced neighbours motion operator.
+        :param idx: Index of current krill being operated.
+        :param krill: Krill being operated.
+        :param best: Best krill in heard.
+        :param worst: Worst krill in heard.
+        :return: Induced speed.
+        :rtype: np.ndarray
+        """
+        # calculate sense range for selected individual
+        population_size = self._config.population_size
+        sense_range = np.sum(
+            [distance(krill.position, self._population[i].position) for i in range(0, population_size)]
+        ) / (self._config.max_neighbours * population_size)
+
+        # get neighbours
+        neighbours = [agent for jdx, agent in enumerate(self._population) if jdx != idx and sense_range > distance(
+            krill.position, agent.position
+        )]
+        if not neighbours:
+            neighbours = [self._population[np.random.randint(self._config.population_size)]]
+
+        alpha_l = np.sum(
+            np.array([self.__get_k__(krill, neighbour, best, worst) for neighbour in neighbours]) * np.array(
+                [self.__get_x__(krill, neighbour) for neighbour in neighbours]
+            ).T
+        )
+
+        alpha_t = 2 * (1 + np.random.random() * (self._cycles + 1) / self._config.max_cycles)
+        return self._config.n_max * (alpha_l + alpha_t) + self.__w_neighbour * krill.induced_speed
+
+    def __induce_foraging_motion__(
+            self, krill: Krill, pos_food: list[float], g_best: Krill, g_worst: Krill
+    ) -> np.ndarray:
+        """
+        Induced foraging motion operator.
+        :param krill: Krill being operated.
+        :param pos_food: Food position.
+        :param g_best: Best krill/individual.
+        :param g_worst: Worst krill/individual.
+        :return: Foraging speed.
+        :rtype: np.ndarray
+        """
+        temp_krill = self._init_agent(position=pos_food)
+        beta_f = 2 * (1 - (self._cycles + 1) / self._config.max_cycles) * self.__get_k__(
+            krill, temp_krill, g_best, g_worst
+        ) * self.__get_x__(krill, temp_krill) if g_best.cost < krill.cost else 0
+        beta_b = self.__get_k__(krill, g_best, g_best, g_worst) * self.__get_x__(krill, g_best)
+        return self._config.foraging_speed * (beta_f + beta_b) + self.__w_foraging * krill.foraging_speed
+
+    def optimization_step(self):
+        (g_best, ), (g_worst, ) = special_agents(self._population, n_best=1, n_worst=1)
+        pos_food = self.__get_food_location__()
+
+        new_pop = []
+        for idx, krill in enumerate(self._population):
+            pos = krill.position
+
+            induced_speed = self.__induce_neighbours_motion__(idx, krill, g_best, g_worst)
+            foraging_speed = self.__induce_foraging_motion__(krill, pos_food, g_best, g_worst)
+
+            # induced physical diffusion operator
+            diffusion = self._config.diffusion_speed * (
+                1 - (self._cycles + 1) / self._config.max_cycles
+            ) * np.random.uniform(-1, 1, self._task.space_dimension)
+
+            # get a new position by a new delta factor
+            new_pos = self._correct_position(krill.position + (
+                self._config.c_t * np.sum(self._bandwidth()) * (induced_speed + foraging_speed + diffusion)
+            ))
+
+            # crossover
+            crossover_rate = self._config.crossover_rate * self.__get_k__(krill, g_best, g_best, g_worst)
+            new_pos = self._correct_position(np.where(
+                [np.random.random() < crossover_rate for _ in range(0, self._task.space_dimension)], pos, new_pos
+            ))
+
+            # mutation
+            mutation_rate = self._config.mutation_rate / (self.__get_k__(krill, g_best, g_best, g_worst) + 1e-31)
+            new_pos = np.where(
+                [np.random.random() < mutation_rate for _ in range(0, self._task.space_dimension)],
+                new_pos,
+                g_best.position + np.random.random(self._task.space_dimension)
+            )
+
+            new_pop.append(self._init_agent(new_pos, induced_speed.tolist(), foraging_speed.tolist()))
+
+        self._greedy_select_population(new_pop)