pyVolutionary 1.0.1__py3-none-any.whl

pyvolutionary/fish_school_search/fish_school_search_optimization.py

@@ -0,0 +1,142 @@
+import numpy as np
+
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import Fish, FishSchoolSearchOptimizationConfig
+
+
+class FishSchoolSearchOptimization(OptimizationAbstract):
+    """
+    Implementation of the Fish School Search Optimization.
+
+    Args:
+        config (FishSchoolSearchOptimizationConfig): an instance of FishSchoolSearchOptimizationConfig class.
+            {parse_obj_doc(FishSchoolSearchOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Bastos Filho, Lima Neto, Lins, D. O. Nascimento and P. Lima, A novel search algorithm based on fish school
+        behavior, in 2008 IEEE International Conference on Systems, Man and Cybernetics, Oct 2008, pp. 2646–2651.
+    """
+    def __init__(self, config: FishSchoolSearchOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__school_weight = self._config.population_size * self._config.w_scale / 2.0
+        self.__step_individual: np.ndarray | None = None
+        self.__step_volitive: np.ndarray | None = None
+
+    def before_initialization(self):
+        self.__step_individual = self._config.step_individual_init * self._bandwidth()
+        self.__step_volitive = self._config.step_volitive_init * self._bandwidth()
+
+    def _init_agent(self, position: list[float] | np.ndarray | None = None) -> Fish:
+        agent = super()._init_agent(position)
+        return Fish(**agent.model_dump(), weight=self._config.w_scale / 2.0)
+
+    def __update_steps__(self):
+        """
+        Update the steps of the fishes. The steps are updated according to the current cycle. The steps are updated
+        according to the following equations: \n
+        step_individual = step_individual_init - (cycles + 1) * (step_individual_init - step_individual_final) / max_cycles \n
+        step_volitive = step_volitive_init - (cycles + 1) * (step_volitive_init - step_volitive_final) / max_cycles \n
+        where: \n
+        step_individual_init: length of initial individual step \n
+        step_individual_final: length of final individual step \n
+        step_volitive_init: length of initial volatile step \n
+        step_volitive_final: length of final volatile step \n
+        cycles: current cycle \n
+        max_cycles: maximum number of cycles.
+        """
+        def update(init: float, final: float) -> np.ndarray:
+            return np.full(
+                self._task.space_dimension, init - (self._cycles + 1) * (init - final) / self._config.max_cycles
+            )
+
+        self.__step_individual = update(self._config.step_individual_init, self._config.step_individual_final)
+        self.__step_volitive = update(self._config.step_volitive_init, self._config.step_volitive_final)
+
+    def __feeding__(self):
+        """
+        Feed all fishes. The feeding is done according to the following equation: \n
+        weight = weight + delta_cost / max_delta_cost \n
+        where: \n
+        weight: weight of the fish \n
+        delta_cost: difference between the current cost and the previous cost of the fish \n
+        max_delta_cost: maximum difference between the current cost and the previous cost of all fishes.
+        """
+        def feeding(fish: Fish, mxd: float) -> Fish:
+            if mxd:
+                fish.weight += (fish.delta_cost / mxd)
+            fish.weight = np.clip(fish.weight, self._config.min_w, self._config.w_scale)
+            return fish
+
+        max_delta_cost = max([fish.delta_cost for fish in self._population])
+        self._population = [feeding(fish, max_delta_cost) for fish in self._population]
+
+    def __individual_movement__(self):
+        """
+        Perform individual movement for each fish.
+        """
+        def move(fish: Fish, sd: int, si: np.ndarray) -> Fish:
+            pos = np.array(fish.position)
+            new_fish = self._init_agent(pos + (si * self._uniform_position()))
+            if new_fish.cost < fish.cost:
+                delta_cost = abs(new_fish.cost - fish.cost)
+                delta_pos = (np.array(new_fish.position) - pos).tolist()
+
+                fish = new_fish
+                fish.delta_cost = delta_cost
+                fish.delta_pos = delta_pos
+                return fish
+
+            fish.delta_pos = np.zeros(sd).tolist()
+            fish.delta_cost = 0
+            return fish
+
+        self._population = [move(
+            fish, self._task.space_dimension, self.__step_individual
+        ) for fish in self._population]
+
+    def __collective_instinctive_movement__(self):
+        """
+        Perform collective instinctive movement.
+        """
+        cost_eval_enhanced = sum(
+            [fish.delta_cost * np.array(fish.delta_pos) for fish in self._population],
+            start=np.zeros(self._task.space_dimension)
+        )
+        density = sum([f.delta_cost for f in self._population])
+        if density != 0:
+            cost_eval_enhanced /= density
+        self._population = [
+            self._init_agent((np.array(fish.position) + cost_eval_enhanced).tolist()) for fish in self._population
+        ]
+
+    def __collective_volitive_movement__(self):
+        """
+        Perform collective volitive movement.
+        """
+        def move(fish: Fish, m: int, bc: np.ndarray, s: np.ndarray, d: int) -> Fish:
+            pos = np.array(fish.position)
+            step = (pos - bc) * s
+            new_pos = pos + (m * step * np.random.uniform(0, 1, d))
+            return self._init_agent(new_pos)
+
+        school_weight = sum([fish.weight for fish in self._population])
+        multiplier = -1 if school_weight > self.__school_weight else 1
+
+        barycenter = sum(
+            [np.array(fish.position) * fish.weight for fish in self._population],
+            start=np.zeros(self._task.space_dimension)
+        )
+        barycenter /= sum([fish.weight for fish in self._population])
+
+        self._population = [move(
+            fish, multiplier, barycenter, self.__step_volitive, self._task.space_dimension
+        ) for fish in self._population]
+
+    def optimization_step(self):
+        self.__individual_movement__()
+        self.__feeding__()
+        self.__collective_instinctive_movement__()
+        self.__collective_volitive_movement__()
+        self.__update_steps__()

pyvolutionary/fish_school_search/models.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Fish(Agent):
+    weight: float
+    delta_pos: list[float] | None = None
+    delta_cost: float | None = None
+
+
+class FishSchoolSearchOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Fish School Search Optimization.\n
+        step_individual_init (float): length of initial individual step.\n
+        step_individual_final (float): length of final individual step.\n
+        step_volitive_init (float): length of initial volatile step.\n
+        step_volitive_final (float): length of final volatile step.\n
+        min_w (float): minimum weight of a fish.\n
+        w_scale (float): scale weight of a fish.
+    """
+    step_individual_init: float
+    step_individual_final: float
+    step_volitive_init: float
+    step_volitive_final: float
+    min_w: float
+    w_scale: float

pyvolutionary/flower_pollination_algorithm/__init__.py

@@ -0,0 +1,2 @@
+from .models import Pollinator, FlowerPollinationAlgorithmOptimizationConfig
+from .flower_pollination_algorithm_optimization import FlowerPollinationAlgorithmOptimization

pyvolutionary/flower_pollination_algorithm/flower_pollination_algorithm_optimization.py

@@ -0,0 +1,46 @@
+import numpy as np
+
+from ..helpers import (
+    get_levy_flight_step,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import FlowerPollinationAlgorithmOptimizationConfig
+
+
+class FlowerPollinationAlgorithmOptimization(OptimizationAbstract):
+    """
+    Implementation of the Flower Pollination Algorithm Optimization.
+
+    Args:
+        config (FlowerPollinationAlgorithmOptimizationConfig): an instance of
+            FlowerPollinationAlgorithmOptimizationConfig class.
+            {parse_obj_doc(FlowerPollinationAlgorithmOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Yang, X.S., 2012, September. Flower pollination algorithm for global optimization. In International
+        conference on unconventional computing and natural computation (pp. 240-249). Springer, Berlin, Heidelberg.
+    """
+    def __init__(self, config: FlowerPollinationAlgorithmOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def optimization_step(self):
+        n_dims = self._task.space_dimension
+        pop_size = self._config.population_size
+
+        for idx, pollinator in enumerate(self._population):
+            position = np.array(pollinator.position)
+            best_position = np.array(self._best_agent.position)
+
+            if np.random.uniform() < self._config.p_s:
+                levy = get_levy_flight_step(multiplier=self._config.levy_multiplier, size=n_dims, case=-1)
+                pos_new = position + 1.0 / np.sqrt(self._cycles) * levy * (position - best_position)
+            else:
+                id1, id2 = np.random.choice(list(set(range(0, pop_size)) - {idx}), 2, replace=False)
+                pos_new = position + np.random.uniform() * (
+                    np.array(self._population[id1].position) - np.array(self._population[id2].position)
+                )
+            self._population[idx] = self._greedy_select_agent(
+                self._init_agent(self._correct_position(pos_new)), pollinator
+            )

pyvolutionary/flower_pollination_algorithm/models.py

@@ -0,0 +1,29 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Pollinator(Agent):
+    pass
+
+
+class FlowerPollinationAlgorithmOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Flower Pollination Algorithm.
+        p_s (float): [0.5, 0.95], switch probability.\n
+        levy_multiplier (float): [0.0001, 1000], multiplier factor of Levy-flight trajectory, depends on the problem.
+    """
+    p_s: float
+    levy_multiplier: float
+
+    @field_validator("p_s")
+    def correct_p_s(cls, v):
+        if not 0.5 <= v <= 0.95:
+            raise ValueError(f"\"p_s\" must be a float between 0.5 and 0.95. Got {v}")
+        return v
+
+    @field_validator("levy_multiplier")
+    def correct_levy_multiplier(cls, v):
+        if not 0.0001 <= v <= 1000:
+            raise ValueError(f"\"levy_multiplier\" must be a float between 0.0001 and 1000. Got {v}")
+        return v

pyvolutionary/forest_algorithm/__init__.py

@@ -0,0 +1,2 @@
+from .models import Tree, ForestOptimizationAlgorithmConfig
+from .forest_optimization_algorithm import ForestOptimizationAlgorithm

pyvolutionary/forest_algorithm/forest_optimization_algorithm.py

@@ -0,0 +1,121 @@
+import numpy as np
+
+from ..helpers import (
+    sort_and_trim,
+    sort_by_cost,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import Tree, ForestOptimizationAlgorithmConfig
+
+
+class ForestOptimizationAlgorithm(OptimizationAbstract):
+    """
+    Implementation of the Forest Optimization Algorithm.
+
+    Args:
+        config (ForestOptimizationAlgorithmConfig): an instance of ForestOptimizationAlgorithmConfig class.
+            {parse_obj_doc(ForestOptimizationAlgorithmConfig)}
+
+    Bibliography
+    ----------
+    [1] Manizheh Ghaemi, Mohammad-Reza Feizi-Derakhshi, Forest Optimization Algorithm, Expert Systems with Applications,
+        Volume 41, Issue 15, 2014, Pages 6676-6687, ISSN 0957-4174, https://doi.org/10.1016/j.eswa.2014.05.009.
+    """
+    def __init__(self, config: ForestOptimizationAlgorithmConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__dx: np.ndarray | None = None
+
+    def before_initialization(self):
+        _, ub = self._get_bounds()
+        self.__dx = np.absolute(ub) / 5.0
+
+    def _init_agent(self, position: list[float] | np.ndarray | None = None) -> Tree:
+        agent = super()._init_agent(position)
+        return Tree(**agent.model_dump())
+
+    def __local_seeding__(self) -> list[Tree]:
+        """
+        Local optimum search stage that should prevent getting stuck in a local optimum. It is performed by randomly
+        changing the position of a tree, i.e. by randomly seeding a tree around it. The number of changes is defined by
+        the local_seeding_changes parameter. Finally, the age of each tree is increased by one and the seeded trees are
+        added to the population.
+        :return: list of seeded trees.
+        :rtype: list[Tree]
+        """
+        def update_position(position: np.ndarray) -> np.ndarray:
+            indices = np.random.choice(self._task.space_dimension, self._config.local_seeding_changes, replace=False)
+            position[indices] += np.random.uniform(-self.__dx[indices], self.__dx[indices])
+            return position
+
+        # repeat local_seeding_changes times each tree that is going to be removed
+        candidates = [
+            self._init_agent(update_position(np.array(tree.position)))
+            for tree in self._population if tree.age == 0
+            for _ in range(self._config.local_seeding_changes)
+        ]
+
+        # increase the age of each tree
+        for tree in self._population:
+            tree.age += 1
+
+        return candidates
+
+    def __global_seeding__(self, candidates: list[Tree], size: int) -> list[Tree]:
+        """
+        Global optimum search stage that should prevent getting stuck in a local optimum. It is performed by randomly
+        changing the position of a tree, i.e. by randomly seeding a tree around it. The number of changes is defined by
+        the global_seeding_changes parameter. The difference between this method and the local_seeding method is that
+        this method is performed on trees that are dying, i.e. that are going to be removed.
+        :param candidates: list of trees that are dying, i.e. that are going to be removed.
+        :param size: number of seeds to be generated.
+        :return: list of seeded trees.
+        """
+        def update_position(position: np.ndarray) -> np.ndarray:
+            indices = np.random.choice(self._task.space_dimension, self._config.global_seeding_changes, replace=False)
+            position[indices] = self._uniform_coordinates(indices)
+            return position
+
+        return [self._init_agent(
+            update_position(np.array(candidates[idx].position))
+        ) for idx in np.random.choice(len(candidates), size, replace=False)]
+
+    def __remove_lifetime_exceeded__(self) -> list[Tree]:
+        """
+        Remove trees that exceeded their lifetime. The lifetime of a tree is defined by the lifetime parameter.
+        :return: list of trees that exceeded their lifetime.
+        :rtype: list[Tree]
+        """
+        candidates = [tree for tree in self._population if tree.age > self._config.lifetime]
+        # remove trees that exceeded their lifetime from the population
+        self._population = [tree for tree in self._population if tree.age <= self._config.lifetime]
+        return candidates
+
+    def __survival_of_the_fittest__(self, candidates: list[Tree]):
+        """
+        Survival of the fittest stage. It is performed by removing the trees with the highest cost function value.
+        :param candidates: list of trees that are dying, i.e. that are going to be removed.
+        :return: candidates to be removed.
+        :rtype: list[Tree]
+        """
+        sort_by_cost(self._population)
+        candidates += self._population[self._config.area_limit+1:]
+        self._population = self._population[:self._config.area_limit]
+        return candidates
+
+    def optimization_step(self):
+        # add seeded trees to the population
+        self._population += self.__local_seeding__()
+
+        # identify trees that exceeded their lifetime and area limit
+        dying_trees = self.__survival_of_the_fittest__(
+            self.__remove_lifetime_exceeded__()
+        )
+
+        # global seeding
+        gsn = int(self._config.transfer_rate * len(dying_trees))
+        if gsn > 0:
+            self._population += self.__global_seeding__(dying_trees, gsn)
+
+        self._population = sort_and_trim(self._population, self._config.population_size)
+        self._population[0].age = 0

pyvolutionary/forest_algorithm/models.py

@@ -0,0 +1,53 @@
+from pydantic import model_validator, field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Tree(Agent):
+    age: int = 0
+
+
+class ForestOptimizationAlgorithmConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Forest Optimization Algorithm.
+        lifetime (int): the lifetime of a tree.\n
+        area_limit (int): the area limit of a tree.\n
+        local_seeding_changes (int): the number of local seeding changes.\n
+        global_seeding_changes (int): the number of global seeding changes.\n
+        transfer_rate (float): (0, 1), the transfer rate.
+    """
+    lifetime: int = 10
+    area_limit: int = 10
+    local_seeding_changes: int = 3
+    global_seeding_changes: int = 3
+    transfer_rate: float = 0.5
+
+    @model_validator(mode="after")
+    def _check_area_limit(self) -> "ForestOptimizationAlgorithmConfig":
+        if not 0 < self.area_limit < self.population_size:
+            raise ValueError('area_limit must be a positive integer, lower than the population size')
+        return self
+
+    @field_validator('lifetime')
+    def _check_lifetime(cls, v):
+        if v < 0:
+            raise ValueError('lifetime must be a positive integer')
+        return v
+
+    @field_validator('local_seeding_changes')
+    def _check_local_seeding_changes(cls, v):
+        if v < 0:
+            raise ValueError('local_seeding_changes must be a positive integer')
+        return v
+
+    @field_validator('global_seeding_changes')
+    def _check_global_seeding_changes(cls, v):
+        if v < 0:
+            raise ValueError('global_seeding_changes must be a positive integer')
+        return v
+
+    @field_validator('transfer_rate')
+    def _check_transfer_rate(cls, v):
+        if not 0 < v < 1:
+            raise ValueError('transfer_rate must be a float between 0 and 1')
+        return v

pyvolutionary/fox/__init__.py

@@ -0,0 +1,2 @@
+from .models import Fox, FoxOptimizationConfig
+from .fox_optimization import FoxOptimization

pyvolutionary/fox/fox_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 FoxOptimizationConfig
+
+
+class FoxOptimization(OptimizationAbstract):
+    """
+    Implementation of the Fox Optimization algorithm.
+
+    Args:
+        config (FoxOptimizationConfig): an instance of FoxOptimizationConfig class.
+            {parse_obj_doc(FoxOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Mohammed, H., & Rashid, T. (2023). FOX: a FOX-inspired optimization algorithm. Applied Intelligence, 53(1),
+        1030-1050.
+    """
+    def __init__(self, config: FoxOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__mint = np.inf
+
+    def optimization_step(self):
+        a = 2 * (1 - (1.0 / self._cycles))
+        best_position = np.array(self._best_agent.position)
+        
+        for idx, fox in enumerate(self._population):
+            if np.random.random() >= 0.5:
+                time1 = np.random.random(self._task.space_dimension)
+                sps = best_position / time1
+                travel_distance = 0.5 * sps * time1
+                tt = np.mean(time1)
+                jump = 0.5 * 9.81 * (tt / 2) ** 2
+                pos_new = travel_distance * jump * (self._config.c1 if np.random.random() > 0.18 else self._config.c2)
+                if self.__mint > tt:
+                    self.__mint = tt
+            else:
+                pos_new = best_position + np.random.standard_normal(self._task.space_dimension) * (self.__mint * a)
+            agent = self._init_agent(self._correct_position(pos_new))
+
+            self._population[idx] = self._greedy_select_agent(fox, agent)

pyvolutionary/fox/models.py

@@ -0,0 +1,29 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Fox(Agent):
+    pass
+
+
+class FoxOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Fox Optimization algorithm.
+        c1 (float): [0, 0.18], the probability of jumping (c1 in the paper)
+        c2 (float): [0.19, 1], the probability of jumping (c2 in the paper)
+    """
+    c1: float
+    c2: float
+
+    @field_validator("c1")
+    def correct_c1(cls, v):
+        if not 0 <= v <= 0.18:
+            raise ValueError("c1 must be in [0, 0.18]")
+        return v
+
+    @field_validator("c2")
+    def correct_c2(cls, v):
+        if not 0.19 <= v <= 1:
+            raise ValueError("c2 must be in [0.19, 1]")
+        return v

pyvolutionary/genetic_algorithm/__init__.py

@@ -0,0 +1,2 @@
+from .models import Gene, GeneticAlgorithmOptimizationConfig
+from .genetic_algorithm_optimization import GeneticAlgorithmOptimization

pyvolutionary/genetic_algorithm/genetic_algorithm_optimization.py

@@ -0,0 +1,167 @@
+import numpy as np
+
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import Gene, GeneticAlgorithmOptimizationConfig
+
+
+class GeneticAlgorithmOptimization(OptimizationAbstract):
+    """
+    Implementation of the Genetic Algorithm Optimization algorithm.
+
+    Args:
+        config (GeneticAlgorithmOptimizationConfig): an instance of GeneticAlgorithmOptimizationConfig class.
+            {parse_obj_doc(GeneticAlgorithmOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Alander, Jarmo. (1999). An Indexed Bibliography of Genetic Algorithm Implementations.
+    [2] Goldberg, David E. (1989). Genetic Algorithms in Search, Optimization, and Machine Learning. Addison-Wesley.
+        ISBN 978-0201157673. OCLC 18319123.
+    [3] Holland, John H. (1975). Adaptation in Natural and Artificial Systems. University of Michigan Press.
+        ISBN 978-0262581110. OCLC 1635804.
+    """
+    def __init__(self, config: GeneticAlgorithmOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__n_bits: int | None = None
+        self.__p_mutation: float | None = None
+        self.__bit_positions: list[list[int]] | None = None
+
+    def before_initialization(self):
+        self.__n_bits = 8 * self._task.space_dimension
+        self.__p_mutation = 1.0 / (float(self.__n_bits) * self._task.space_dimension)
+
+    def _init_population(self):
+        self.__bit_positions = [np.random.randint(
+            0, 2, self.__n_bits * self._task.space_dimension
+        ).tolist() for _ in range(0, self._config.population_size)]
+
+        self._population = self.__from_bit_positions_to_population__()
+
+    def __decode__(self, bitstring: list[int]) -> list[float]:
+        """
+        Decode a bitstring to a float list.
+        :param bitstring: the bitstring to decode
+        :return: the decoded float list
+        :rtype: list[float]
+        """
+        decoded = []
+        largest = 2 ** self.__n_bits
+
+        lb, ub = self._get_bounds()
+        for i in range(0, self._task.space_dimension):
+            # extract the substring
+            start, end = i * self.__n_bits, (i * self.__n_bits) + self.__n_bits
+            substring = bitstring[start:end]
+            # convert bitstring to a string of chars
+            chars = ''.join([str(s) for s in substring])
+            # convert string to integer
+            integer = int(chars, 2)
+            # scale integer to desired range
+            value = lb[i] + (integer / largest) * (ub[i] - lb[i])
+            # store
+            decoded.append(value)
+        return decoded
+
+    def __encode__(self, position: list[float]) -> list[int]:
+        """
+        Encode a float list to a bitstring.
+        :param position: the float list to encode
+        :return: the encoded bitstring
+        :rtype: list[int]
+        """
+        encoded = []
+
+        lb, ub = self._get_bounds()
+        for i in range(0, self._task.space_dimension):
+            # scale integer to desired range
+            value = (position[i] - lb[i]) / (ub[i] - lb[i])
+            # convert to bitstring
+            value = bin(int(value * (2 ** self.__n_bits)))[2:].zfill(self.__n_bits)
+            binary_representation = [int(bit) for bit in value]
+            # append to the encoded list
+            encoded.extend(binary_representation)
+        return encoded
+
+    def __selection__(self, k: int | None = 3) -> list[int]:
+        """
+        Select a parent from the population. The selection is based on the fitness of the genes. The lower the cost,
+        the higher the fitness. The selection is performed by tournament selection. The tournament size is k. The
+        selection is repeated until k parents are selected. The best parent is selected from the k parents. The best is
+        the one with the lowest cost. The selection is repeated until the population size is reached. The selection is
+        performed with replacement. The same parent can be selected multiple times. The selection is performed with a 3
+        tournament selection by default.
+        :param k: the tournament size
+        :return: the selected parent
+        """
+        scores = [gene.cost for gene in self._population]
+
+        # first random selection
+        selection_ix = np.random.randint(len(self.__bit_positions))
+        for ix in np.random.randint(0, len(self.__bit_positions), k - 1):
+            # check if better (e.g. perform a tournament)
+            if scores[ix] < scores[selection_ix]:
+                selection_ix = ix
+        return self.__bit_positions[selection_ix]
+
+    def __crossover__(self, parent1: list[int], parent2: list[int]) -> tuple[list[int], list[int]]:
+        """
+        Crossover two parents to create two children. The crossover is performed with a probability of px_over. The
+        crossover point is selected randomly. The crossover point is not on the end of the string. The crossover is
+        performed by default. The children are copies of the parents by default.
+        :param parent1: the first parent
+        :param parent2: the second parent
+        :return: the two children
+        :rtype: tuple[list[int], list[int]]
+        """
+        # children are copies of parents by default
+        c1, c2 = parent1.copy(), parent2.copy()
+        # check for recombination
+        if np.random.rand() < self._config.px_over:
+            # select crossover point that is not on the end of the string
+            pt = np.random.randint(1, len(parent1) - 2)
+            # perform crossover
+            c1 = parent1[:pt] + parent2[pt:]
+            c2 = parent1[:pt] + parent2[pt:]
+        return c1, c2
+
+    def __mutation__(self, bitstring: list[int]) -> list[int]:
+        """
+        Mutate a bitstring by flipping bits with a probability of pm_mutate. The mutation is performed by default.
+        :param bitstring: the bitstring to mutate
+        :return: the mutated bitstring
+        :rtype: list[int]
+        """
+        return [1 - bit if np.random.rand() < self.__p_mutation else bit for bit in bitstring]
+
+    def __from_bit_positions_to_population__(self) -> list[Gene]:
+        """
+        Convert the bit positions to a population. The cost of each gene is calculated. The fitness of each gene is
+        calculated.
+        :return: the population
+        :rtype: list[Gene]
+        """
+        def to_gene(bitstring: list[int]) -> Gene:
+            position = self.__decode__(bitstring)
+            return Gene(**self._init_agent(position).model_dump())
+
+        return list(map(to_gene, self.__bit_positions))
+
+    def optimization_step(self):
+        # select parents
+        selected = [self.__selection__() for _ in range(0, self._config.population_size)]
+
+        # create the next generation
+        children = []
+        for i in range(0, self._config.population_size, 2):
+            # get selected parents in pairs
+            p1, p2 = selected[i], selected[i + 1]
+            # crossover
+            c1, c2 = self.__crossover__(p1, p2)
+            # mutations and store for next generation
+            children.append(self.__mutation__(c1))
+            children.append(self.__mutation__(c2))
+
+        # update population
+        self.__bit_positions = children
+        self._population = self.__from_bit_positions_to_population__()