pyVolutionary 2.7.0__tar.gz → 2.7.1__tar.gz

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyVolutionary
-Version: 2.7.0
+Version: 2.7.1
 Summary: pyVolutionary is a package collecting metaheuristic algorithms, available for free usage and able to solve a wide range of optimization problems.
 License: GPL-3.0-only
 License-File: LICENSE

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyVolutionary"
-version = "2.7.0"
+version = "2.7.1"
 description = "pyVolutionary is a package collecting metaheuristic algorithms, available for free usage and able to solve a wide range of optimization problems."
 authors = ["Matteo Cacciola <matteo.cacciola@gmail.com>"]
 license = "GPL-3.0-only"

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/abstract.py

@@ -51,6 +51,15 @@ class OptimizationAbstract(ABC, Generic[T]):
     def before_initialization(self):
         pass
 
+    def _minimum_population_size(self) -> int:
+        """
+        The minimum size of the population the algorithm can work with (e.g. an algorithm guided by the three best
+        agents needs at least three agents). The algorithms needing more than two agents override it.
+        :return: the minimum population size
+        :rtype: int
+        """
+        return 2
+
     def after_initialization(self):
         pass
 
@@ -224,6 +233,13 @@ class OptimizationAbstract(ABC, Generic[T]):
         if not self._config:
             raise ValueError("Invalid configuration")
 
+        minimum_population_size = self._minimum_population_size()
+        if self._config.population_size < minimum_population_size:
+            raise ValueError(
+                f"{self.name} needs a population of at least {minimum_population_size} agents. "
+                f"Got {self._config.population_size}"
+            )
+
         np.random.seed(task.seed)
         random.seed(task.seed)
         evolution: list[Population] = []

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/bee_colony/bee_colony_optimization.py

@@ -34,6 +34,10 @@ class BeeColonyOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = BeeColonyOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # half of the colony are food sources, and a food source needs a partner
+        return 4
+
     def _init_population(self):
         # half of the colony are employed bees, each one bound to a food source: the population is made of the food
         # sources (the configuration is not altered, so that it can be reused for further optimizations)

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/brain_storm/brain_storm_optimization.py

@@ -4,6 +4,7 @@ import numpy as np
 
 from ..helpers import (
     find_centers,
+    split_in_clusters,
     parse_obj_doc,  # type: ignore
 )
 from ..abstract import OptimizationAbstract
@@ -25,38 +26,37 @@ class BrainStormOptimization(OptimizationAbstract):
     """
     def __init__(self, config: BrainStormOptimizationConfig | None = None, debug: bool | None = False):
         super().__init__(config, debug)
-        self.__m_solution: int | None = None
         self.__clusters: list[list[Person]] = []
         self.__centers: list[Person] = []
 
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = BrainStormOptimizationConfig(**parameters)
 
-    def before_initialization(self):
-        self.__m_solution = int(self._config.population_size / self._config.m_clusters)
-
     def after_initialization(self):
-        self.__clusters = self._generate_group_population(self._config.m_clusters, self.__m_solution, False)
+        # every agent belongs to a cluster, also when the population size is not a multiple of m_clusters
+        self.__clusters = split_in_clusters(self._population, self._config.m_clusters)
         self.__centers: list[Person] = find_centers(self.__clusters)
 
     def optimization_step(self):
         def evolve(idx: int) -> tuple[Person, int, int]:
-            cluster_id = int(idx / m_solution)
-            location_id = int(idx % m_solution)
+            cluster_id, location_id = locations[idx]
             if np.random.uniform() < p2:  # p_6b
-                rand_idx = np.random.randint(0, m_solution)
+                rand_idx = np.random.randint(0, len(self.__clusters[cluster_id]))
                 pos_new = np.array(self.__clusters[cluster_id][rand_idx].position) + np.random.normal(0, 1, n_dims)
                 if np.random.uniform() < p3:  # p_6i
-                    cluster_id = np.random.randint(0, m_clusters)
-                    pos_new = np.array(self.__centers[cluster_id].position) + epsilon * np.random.normal(0, 1, n_dims)
+                    # the new idea comes from the center of a random cluster, and competes with the agent idx
+                    center_id = np.random.randint(0, m_clusters)
+                    pos_new = np.array(self.__centers[center_id].position) + epsilon * np.random.normal(0, 1, n_dims)
             else:
                 id1, id2 = np.random.choice(m_clusters, 2, replace=False)
                 pos_new = 0.5 * (
                     np.array(self.__centers[id1].position) + np.array(self.__centers[id2].position)
                 ) + epsilon * np.random.normal(0, 1, n_dims)
                 if np.random.uniform() >= p4:
-                    pos_rand_id1 = np.array(self.__clusters[id1][np.random.randint(0, m_solution)].position)
-                    pos_rand_id2 = np.array(self.__clusters[id2][np.random.randint(0, m_solution)].position)
+                    cluster1 = self.__clusters[id1]
+                    pos_rand_id1 = np.array(cluster1[np.random.randint(0, len(cluster1))].position)
+                    cluster2 = self.__clusters[id2]
+                    pos_rand_id2 = np.array(cluster2[np.random.randint(0, len(cluster2))].position)
                     pos_new = 0.5 * (pos_rand_id1 + pos_rand_id2) + epsilon * np.random.normal(0, 1, n_dims)
             agent = Person(**self._init_agent(pos_new).__dict__)
             return agent, cluster_id, location_id
@@ -68,16 +68,17 @@ class BrainStormOptimization(OptimizationAbstract):
         epsilon = np.random.uniform() * (1 / (1 + np.exp(-x)))
 
         p1, p2, p3, p4 = self._config.p1, self._config.p2, self._config.p3, self._config.p4
-        m_solution = self.__m_solution
+        # the (cluster, location) of each agent, cluster by cluster
+        locations = [(c_id, l_id) for c_id, cluster in enumerate(self.__clusters) for l_id in range(0, len(cluster))]
 
         n_dims = self._task.space_dimension
-        m_clusters = self._config.m_clusters
+        m_clusters = len(self.__clusters)
 
         epsilon = 1. - 1. * epoch / epochs
         if np.random.uniform() < p1:
             self.__centers[np.random.randint(0, m_clusters)] = Person(**self._init_agent().__dict__)
 
-        new_agents, cluster_ids, location_ids = zip(*[evolve(idx) for idx in range(0, self._config.population_size)])
+        new_agents, cluster_ids, location_ids = zip(*[evolve(idx) for idx in range(0, len(locations))])
         for cl_id, loc_id, new_agent in zip(cluster_ids, location_ids, new_agents):
             self.__clusters[cl_id][loc_id] = self._greedy_select_agent(self.__clusters[cl_id][loc_id], new_agent)
 

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/brain_storm/improved_brain_storm_optimization.py

@@ -4,6 +4,7 @@ import numpy as np
 
 from ..helpers import (
     find_centers,
+    split_in_clusters,
     get_levy_flight_step,
     parse_obj_doc,  # type: ignore
 )
@@ -26,24 +27,20 @@ class ImprovedBrainStormOptimization(OptimizationAbstract):
     """
     def __init__(self, config: ImprovedBrainStormOptimizationConfig | None = None, debug: bool | None = False):
         super().__init__(config, debug)
-        self.__m_solution: int | None = None
         self.__clusters: list[list[Person]] = []
         self.__centers: list[Person] = []
 
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = ImprovedBrainStormOptimizationConfig(**parameters)
 
-    def before_initialization(self):
-        self.__m_solution = int(self._config.population_size / self._config.m_clusters)
-
     def after_initialization(self):
-        self.__clusters = self._generate_group_population(self._config.m_clusters, self.__m_solution, False)
+        # every agent belongs to a cluster, also when the population size is not a multiple of m_clusters
+        self.__clusters = split_in_clusters(self._population, self._config.m_clusters)
         self.__centers: list[Person] = find_centers(self.__clusters)
 
     def optimization_step(self):
         def evolve(idx: int) -> tuple[Person, int, int]:
-            cluster_id = int(idx / m_solution)
-            location_id = int(idx % m_solution)
+            cluster_id, location_id = locations[idx]
             if np.random.uniform() < p2:  # p_6b
                 temp_pos = np.array(self.__centers[cluster_id].position)
                 offset = epsilon * np.random.normal(0, 1, n_dims)
@@ -57,25 +54,28 @@ class ImprovedBrainStormOptimization(OptimizationAbstract):
                     np.array(self.__centers[id1].position) + np.array(self.__centers[id2].position)
                 ) + epsilon * np.random.normal(0, 1, n_dims)
                 if np.random.uniform() >= p4:
-                    pos_rand_id1 = np.array(self.__clusters[id1][np.random.randint(0, m_solution)].position)
-                    pos_rand_id2 = np.array(self.__clusters[id2][np.random.randint(0, m_solution)].position)
+                    cluster1 = self.__clusters[id1]
+                    pos_rand_id1 = np.array(cluster1[np.random.randint(0, len(cluster1))].position)
+                    cluster2 = self.__clusters[id2]
+                    pos_rand_id2 = np.array(cluster2[np.random.randint(0, len(cluster2))].position)
                     pos_new = 0.5 * (pos_rand_id1 + pos_rand_id2) + epsilon * np.random.normal(0, 1, n_dims)
             agent = Person(**self._init_agent(pos_new).__dict__)
             return agent, cluster_id, location_id
 
         p1, p2, p3, p4 = self._config.p1, self._config.p2, self._config.p3, self._config.p4
-        m_solution = self.__m_solution
+        # the (cluster, location) of each agent, cluster by cluster
+        locations = [(c_id, l_id) for c_id, cluster in enumerate(self.__clusters) for l_id in range(0, len(cluster))]
 
         n_dims = self._task.space_dimension
         epoch = self._current_cycle
         epochs = self._config.max_cycles
-        m_clusters = self._config.m_clusters
+        m_clusters = len(self.__clusters)
 
         epsilon = 1. - 1. * epoch / epochs
         if np.random.uniform() < p1:
             self.__centers[np.random.randint(0, m_clusters)] = Person(**self._init_agent().__dict__)
 
-        new_agents, cluster_ids, location_ids = zip(*[evolve(idx) for idx in range(0, self._config.population_size)])
+        new_agents, cluster_ids, location_ids = zip(*[evolve(idx) for idx in range(0, len(locations))])
         for cl_id, loc_id, new_agent in zip(cluster_ids, location_ids, new_agents):
             self.__clusters[cl_id][loc_id] = self._greedy_select_agent(self.__clusters[cl_id][loc_id], new_agent)
 

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/chernobyl_disaster/chernobyl_disaster_optimization.py

@@ -28,6 +28,10 @@ class ChernobylDisasterOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = ChernobylDisasterOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # the agents are guided by the three best ones
+        return 3
+
     def optimization_step(self):
         def evolve(radiation: SearchRadiation) -> SearchRadiation:
             pos = np.array(radiation.position)

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/coral_reef/coral_reef_optimization.py

@@ -68,6 +68,9 @@ class CoralReefOptimization(OptimizationAbstract):
             ))
 
         def multi_point_cross(pos1, pos2) -> list[float]:
+            if len(pos1) < 2:
+                # a single dimension can not be cut in two points: the larva takes it from one of the parents
+                return self._task.correct_solution(pos1 if np.random.random() < 0.5 else pos2)
             p1, p2 = np.random.choice(list(range(0, len(pos1))), 2, replace=False)
             start, end = min(p1, p2), max(p1, p2)
             return self._task.correct_solution(

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/coyotes/coyotes_optimization.py

@@ -32,6 +32,10 @@ class CoyotesOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = CoyotesOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # a pack holds num_coyotes coyotes
+        return max(self._config.num_coyotes, 3)
+
     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

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/dwarf_mongoose/dwarf_mongoose_optimization.py

@@ -28,6 +28,10 @@ class DwarfMongooseOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = DwarfMongooseOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # a mongoose forages with a partner different from itself and the alpha
+        return 3
+
     def _init_agent(self, position: list[float] | np.ndarray | None = None) -> DwarfMongoose:
         return DwarfMongoose(**super()._init_agent(position).__dict__)
 

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/earthworms/earthworms_optimization.py

@@ -31,6 +31,10 @@ class EarthwormsOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = EarthwormsOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # the best keep earthworms are kept at each cycle
+        return max(self._config.keep, 2)
+
     def before_initialization(self):
         self.__dyn_beta = self._config.beta
 

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/electromagnetic_field/electromagnetic_field_optimization.py

@@ -1,7 +1,10 @@
 from typing import Any
 import numpy as np
 
-from ..helpers import parse_obj_doc  # type: ignore
+from ..helpers import (
+    sort_by_cost,
+    parse_obj_doc,  # type: ignore
+)
 from ..abstract import OptimizationAbstract
 from .models import Electromagnet, ElectromagneticFieldOptimizationConfig
 
@@ -30,9 +33,9 @@ class ElectromagneticFieldOptimization(OptimizationAbstract):
     def optimization_step(self):
         def evolve(electromagnet: Electromagnet) -> Electromagnet:
             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
+                r_idx1 = random_index(0, p_field)  # top
+                r_idx2 = random_index(n_field, pop_size)  # bottom
+                r_idx3 = random_index(n_field1, n_field)  # middle
 
                 pos_new = np.array(self._population[r_idx1].position) + phi * np.random.random() * (
                         best_position - np.array(self._population[r_idx3].position)
@@ -47,6 +50,14 @@ class ElectromagneticFieldOptimization(OptimizationAbstract):
             agent = Electromagnet(**self._init_agent(pos_new).__dict__)
             return self._greedy_select_agent(electromagnet, agent)
 
+        def random_index(low: int, high: int) -> int:
+            # a field may be empty with a small population: draw from the whole population then
+            return np.random.randint(low, high) if high > low else np.random.randint(0, pop_size)
+
+        # the fields are fractions of the population sorted by cost: positive (the best electromagnets), neutral and
+        # negative (the worst ones)
+        self._population = sort_by_cost(self._population)
+
         pop_size = self._config.population_size
         best_position = np.array(self._best_agent.position)
 

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/elephant_herd/elephant_herd_optimization.py

@@ -2,6 +2,7 @@ from typing import Any
 import numpy as np
 
 from ..helpers import (
+    split_in_clusters,
     sort_by_cost,
     parse_obj_doc,  # type: ignore
 )
@@ -24,38 +25,35 @@ class ElephantHerdOptimization(OptimizationAbstract):
     """
     def __init__(self, config: ElephantHerdOptimizationConfig | None = None, debug: bool | None = False):
         super().__init__(config, debug)
-        self.__n_individuals: int | None = None
         self.__groups: list[list[Elephant]] = []
 
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = ElephantHerdOptimizationConfig(**parameters)
 
-    def before_initialization(self):
-        self.__n_individuals = int(self._config.population_size / self._config.n_clans)
-
     def after_initialization(self):
-        self.__groups = self._generate_group_population(self._config.n_clans, self.__n_individuals)
+        # every elephant belongs to a clan, also when the population size is not a multiple of n_clans
+        self.__groups = split_in_clusters(self._population, self._config.n_clans)
 
     def optimization_step(self):
         def evolve(idx: int, elephant: Elephant) -> Elephant:
-            clan_idx = int(idx / n_individuals)
+            clan_idx, pos_clan_idx = locations[idx]
             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 = beta * np.mean(pos_group, axis=0) if pos_clan_idx == 0 else (
                 pos_group[pos_clan_idx] + alpha * np.random.random() * (pos_group[0] - pos_group[pos_clan_idx])
             )
             agent = Elephant(**self._init_agent(pos_new).__dict__)
             return self._greedy_select_agent(elephant, agent)
 
-        n_individuals = self.__n_individuals
+        # the (clan, position in the clan) of each elephant, clan by clan
+        locations = [(c_id, l_id) for c_id, clan in enumerate(self.__groups) for l_id in range(0, len(clan))]
         alpha = self._config.alpha
         beta = self._config.beta
         self._population = [evolve(idx, elephant) for idx, elephant in enumerate(self._population)]
-        self.__groups = self._generate_group_population(self._config.n_clans, self.__n_individuals)
+        self.__groups = split_in_clusters(self._population, self._config.n_clans)
 
         # Separating operator
-        for idx in range(0, self._config.n_clans):
+        for idx in range(0, len(self.__groups)):
             self.__groups[idx] = 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-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/energy_valley/energy_valley_optimization.py

@@ -26,6 +26,10 @@ class EnergyValleyOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = EnergyValleyOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # a particle is compared with a team of its nearest particles
+        return 4
+
     def optimization_step(self):
         def evolve(idx: int, particle: Particle) -> list[Particle]:
             pos = np.array(particle.position)

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/firehawk/firehawk_optimization.py

@@ -32,7 +32,8 @@ class FireHawkOptimization(OptimizationAbstract):
         self._config = FireHawkOptimizationConfig(**parameters)
 
     def before_initialization(self):
-        self.__hn = np.random.randint(1, np.ceil(self._config.population_size / 5))
+        # number of fire hawks: at least one (with a small population, ceil(population_size / 5) may be 1)
+        self.__hn = np.random.randint(1, max(np.ceil(self._config.population_size / 5), 2))
 
     def optimization_step(self):
         def get_groups() -> dict[int, list[FireHawk]]:

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/flower_pollination_algorithm/flower_pollination_algorithm_optimization.py

@@ -29,6 +29,10 @@ class FlowerPollinationAlgorithmOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = FlowerPollinationAlgorithmOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # the local pollination mixes two other flowers
+        return 3
+
     def optimization_step(self):
         def evolve(pollinator: Pollinator, idx: int) -> Pollinator:
             position = np.array(pollinator.position)

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/forensic_based_investigation/forensic_based_investigation_optimization.py

@@ -25,6 +25,10 @@ class ForensicBasedInvestigationOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = ForensicBasedInvestigationOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # a suspect is investigated through three other suspects
+        return 4
+
     def optimization_step(self):
         def investigation_a1(idx: int, detective: Detective) -> Detective:
             pos = detective.position

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/forest_algorithm/forest_optimization_algorithm.py

@@ -41,13 +41,13 @@ class ForestOptimizationAlgorithm(OptimizationAbstract):
     def optimization_step(self):
         def local_seeding(tree: Tree) -> Tree:
             position = np.array(tree.position, dtype=float)
-            indices = np.random.choice(dims, local_seeding_changes, replace=False)
+            indices = np.random.choice(dims, min(local_seeding_changes, dims), replace=False)
             position[indices] += np.random.uniform(-self.__dx[indices], self.__dx[indices])
             return self._init_agent(position)
 
         def global_seeding(tree: Tree) -> Tree:
             position = np.array(tree.position, dtype=float)
-            indices = np.random.choice(self._task.space_dimension, self._config.global_seeding_changes, replace=False)
+            indices = np.random.choice(dims, min(self._config.global_seeding_changes, dims), replace=False)
             position[indices] = self._task.uniform_coordinates(indices)
             return self._init_agent(position)
 
@@ -65,7 +65,7 @@ class ForestOptimizationAlgorithm(OptimizationAbstract):
 
         # identify and remove trees that exceeded their area limit
         self._population = sort_by_cost(self._population)
-        dying_trees += self._population[area_limit + 1:]
+        dying_trees += self._population[area_limit:]
 
         self._population = self._population[:area_limit]
 

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/gaining_sharing_knowledge_algorithm/gaining_sharing_knowledge_optimization.py

@@ -1,7 +1,10 @@
 from typing import Any
 import numpy as np
 
-from ..helpers import parse_obj_doc  # type: ignore
+from ..helpers import (
+    sort_by_cost,
+    parse_obj_doc,  # type: ignore
+)
 from ..abstract import OptimizationAbstract
 from .models import Knowledge, GainingSharingKnowledgeOptimizationConfig
 
@@ -40,8 +43,13 @@ class GainingSharingKnowledgeOptimization(OptimizationAbstract):
             # Other case it chooses i-1, i+1
             return idx - 1, idx + 1
 
+        def random_index(low: int, high: int, excluded: set[int]) -> int:
+            # a group may be empty with a small population: draw from the whole population then
+            candidates = list(set(range(low, high)) - excluded) or list(set(range(0, pop_size)) - excluded)
+            return np.random.choice(candidates) if candidates else np.random.randint(0, pop_size)
+
         def junior_gaining_sharing_knowledge(idx: int, agent: Knowledge) -> np.ndarray:
-            rand_idx = np.random.choice(list(set(range(0, pop_size)) - {prevs[idx], idx, nexts[idx]}))
+            rand_idx = random_index(0, pop_size, {prevs[idx], idx, nexts[idx]})
             pos = np.array(agent.position)
             if np.random.uniform() > kr:
                 return pos.copy()
@@ -57,9 +65,9 @@ class GainingSharingKnowledgeOptimization(OptimizationAbstract):
             pos = np.array(agent.position)
             if np.random.uniform() > kr:
                 return pos.copy()
-            rand_best = np.random.choice(list(set(range(0, id1)) - {idx}))
-            rand_worst = np.random.choice(list(set(range(id2, pop_size)) - {idx}))
-            rand_mid = np.random.choice(list(set(range(id1, id2)) - {idx}))
+            rand_best = random_index(0, id1, {idx})
+            rand_worst = random_index(id2, pop_size, {idx})
+            rand_mid = random_index(id1, id2, {idx})
             pos_rand_best = np.array(self._population[rand_best].position)
             pos_rand_worst = np.array(self._population[rand_worst].position)
             pos_rand_mid = np.array(self._population[rand_mid].position)
@@ -75,11 +83,17 @@ class GainingSharingKnowledgeOptimization(OptimizationAbstract):
             )
             return self._greedy_select_agent(agent, Knowledge(**self._init_agent(pos).__dict__))
 
+        # the knowledge is gained by rank: the population is sorted by cost (the best first)
+        self._population = sort_by_cost(self._population)
+
         p, kf, kr, kg = self._config.p, self._config.kf, self._config.kr, self._config.kg
         pop_size = self._config.population_size
         cycle_ratio = self._current_cycle / self._config.max_cycles
 
-        prevs, nexts = zip(*[get_prev_next(i) for i in range(pop_size)])
+        # (with a very small population, the neighbours are kept inside the population)
+        prevs, nexts = zip(*[
+            tuple(min(max(n, 0), pop_size - 1) for n in get_prev_next(i)) for i in range(pop_size)
+        ])
         n_dims = self._task.space_dimension
         dd = int(n_dims * (1 - cycle_ratio) ** kg)
 

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/genetic_algorithm/genetic_algorithm_optimization.py

@@ -52,8 +52,8 @@ class GeneticAlgorithmOptimization(OptimizationAbstract):
             return self.__bit_genes[selection_ix].bitstring
 
         def crossover(idx: int) -> tuple[list[int], list[int]]:
-            # get selected parents in pairs
-            parent1, parent2 = selected[idx].copy(), selected[idx + 1].copy()
+            # get selected parents in pairs (with an odd population, the last parent mates with the first one)
+            parent1, parent2 = selected[idx].copy(), selected[(idx + 1) % len(selected)].copy()
             # children are copies of parents by default
             child1, child2 = parent1.copy(), parent2.copy()
             # check for recombination
@@ -62,7 +62,7 @@ class GeneticAlgorithmOptimization(OptimizationAbstract):
                 pt = np.random.randint(1, len(parent1) - 2)
                 # perform crossover
                 child1 = parent1[:pt] + parent2[pt:]
-                child2 = parent1[:pt] + parent2[pt:]
+                child2 = parent2[:pt] + parent1[pt:]
             return child1, child2
 
         px_over = self._config.px_over
@@ -82,7 +82,8 @@ class GeneticAlgorithmOptimization(OptimizationAbstract):
                 c = np.array(child)
                 children.append(np.where(np.random.rand(len(c)) < self.__p_mutation, 1 - c, c).tolist())
 
-        # update population
+        # update population (with an odd population, the last pair generates one child more than needed)
+        children = children[:len(self.__bit_genes)]
         self.__bit_genes = [self.__bit_genes[idx].set_bit_string(child) for idx, child in enumerate(children)]
 
         lb, ub = self._task.get_bounds()

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/germinal_center/germinal_center_optimization.py

@@ -27,6 +27,10 @@ class GerminalCenterOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = GerminalCenterOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # the mutation mixes three cells
+        return 3
+
     def _init_agent(
         self, position: list[Any] | np.ndarray | None = None, cc: float | None = None, ls: float | None = None
     ) -> GerminalCenter:

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/grey_wolf/grey_wolf_optimization.py

@@ -32,6 +32,10 @@ class GreyWolfOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = GreyWolfOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # the pack is guided by the three best wolves (alpha, beta and delta)
+        return 3
+
     def after_initialization(self):
         self.__alpha_wolf, self.__beta_wolf, self.__gamma_wolf = best_agents(self._population, 3)
 

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/helpers.py

@@ -463,6 +463,26 @@ def get_pool_results(executors: list[parallel.Future]) -> list:
     return [executor.result() for executor in executors]
 
 
+def split_in_clusters(population: list[T], n_clusters: int) -> list[list[T]]:
+    """
+    Split the population in (at most) n_clusters clusters of consecutive agents, whose sizes differ by one at most: all
+    the agents belong to a cluster, also when the size of the population is not a multiple of n_clusters (with equal
+    sizes, the clusters are the same as consecutive groups of population_size / n_clusters agents).
+    :param population: the population
+    :param n_clusters: the number of clusters
+    :return: the clusters (copies of the agents)
+    :rtype: list[list[T]]
+    """
+    n_clusters = max(1, min(n_clusters, len(population)))
+    size, residual = divmod(len(population), n_clusters)
+    clusters, start = [], 0
+    for idx in range(0, n_clusters):
+        end = start + size + (1 if idx < residual else 0)
+        clusters.append([agent.model_copy() for agent in population[start:end]])
+        start = end
+    return clusters
+
+
 def find_centers(pop_groups: list[list[T]]) -> list[T]:
     return [best_agent(pop_group).model_copy() for pop_group in pop_groups]
 

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/nuclear_reaction/nuclear_reaction_optimization.py

@@ -29,6 +29,10 @@ class NuclearReactionOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = NuclearReactionOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # the fission and the fusion involve two other nuclei
+        return 3
+
     def optimization_step(self):
         def nfi_phase(idx: int, reaction: NuclearReaction) -> NuclearReaction:
             position = np.array(reaction.position)

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/runge_kutta/runge_kutta_optimization.py

@@ -30,6 +30,10 @@ class RungeKuttaOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = RungeKuttaOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # the search mechanism uses three agents different from the current one
+        return 4
+
     def optimization_step(self):
         def evolve_runge_kutta(
             idx: int, agent: Agent

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/spotted_hyena/spotted_hyena_optimization.py

@@ -53,7 +53,8 @@ class SpottedHyenaOptimization(OptimizationAbstract):
                 pos_new = np.array(g_best.position) - np.dot(E, D_h)
                 new_agent = SpottedHyena(**self._init_agent(pos_new).__dict__)
                 return self._greedy_select_agent(agent, new_agent)
-            N = get_n()
+            # the circle can not be larger than the population
+            N = min(get_n(), pop_size)
             idx_list = np.random.choice(pop_size, N, replace=False).tolist()
             circle_list = [circle_list_item(idx_list[j], B, E) for j in range(0, N)]
             pos_new = np.mean(np.array(circle_list), axis=0)

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/success_history_intelligent/success_history_intelligent_optimization.py

@@ -30,6 +30,10 @@ class SuccessHistoryIntelligentOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = SuccessHistoryIntelligentOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # the agents are guided by the three best ones
+        return 3
+
     def before_initialization(self):
         # the coefficient decays during the run: reset it, so that the same instance can be used several times
         self.__a = 1.5

{pyvolutionary-2.7.0 → pyvolutionary-2.7.1}/pyvolutionary/virus_colony_search/virus_colony_search_optimization.py

@@ -29,6 +29,10 @@ class VirusColonySearchOptimization(OptimizationAbstract):
     def set_config_parameters(self, parameters: dict[str, Any]):
         self._config = VirusColonySearchOptimizationConfig(**parameters)
 
+    def _minimum_population_size(self) -> int:
+        # the immune response involves two other viruses
+        return 3
+
     def before_initialization(self):
         self.__n_best = int(self._config.lamda * self._config.population_size)