Add test for reordering parameterization consistency check

cgp/ea/mu_plus_lambda.py

@@ -45,12 +45,12 @@ def __init__(
         k_local_search : int
             Number of individuals in the whole population (parents +
             offsprings) to apply local search to.
-        reorder_genome: bool, optional
+       reorder_genome: bool, optional
             Whether genome reordering should be applied.
-            If True, reorder is applied to the parents genomes
-            at every generation before creating offspring.
-            Thereby creating a neutral drift though the search space.
-            Reorder randomizes the genotype of an individual without changing the phenotype.
+            Reorder shuffles the genotype of an individual without changing its phenotype,
+            thereby contributing to neutral drift through the genotypic search space.
+            If True, reorder is applied to each parents genome at every generation
+            before creating offsprings.
             Defaults to True.
         """
         self.n_offsprings = n_offsprings
@@ -80,9 +80,7 @@ def initialize_fitness_parents(
         pop._parents = self._compute_fitness(pop.parents, objective)
 
     def step(
-        self,
-        pop: Population,
-        objective: Callable[[IndividualBase], IndividualBase],
+        self, pop: Population, objective: Callable[[IndividualBase], IndividualBase],
     ) -> Population:
         """Perform one step in the evolution.
 

cgp/genome.py

@@ -355,8 +355,9 @@ def _replace_invalid_input_alleles(self, dna: List[int], rng: np.random.RandomSt
                 gene_value = rng.choice(permissible_values)
                 dna[gene_idx] = gene_value
 
-    def _get_addable_nodes(self, node_dependencies: Dict[int, Set[int]],
-                           used_node_indices: List[Union[int, None]] = []) -> Set[int]:
+    def _get_addable_nodes(
+        self, node_dependencies: Dict[int, Set[int]], used_node_indices: List[int] = [],
+    ) -> Set[int]:
         """ Get the set of addable nodes,
          nodes which have no dependencies and were not already used.
         """
@@ -394,7 +395,7 @@ def _determine_node_dependencies(self) -> Dict[int, Set[int]]:
                 input_node_idx = self._dna[operator_idx + idx_gene]
                 if not self._is_input_region(
                     input_node_idx
-                ):  # not necessary to add input regions, since they are first anyway
+                ):  # not necessary to add input regions, since their positions remain fixed
                     current_node_dependencies.add(input_node_idx)
 
             dependencies[region_idx] = current_node_dependencies

examples/example_reorder.py

@@ -118,12 +118,10 @@ def recording_callback_with_reorder(pop):
 
 # %%
 # and finally perform the evolution of the two populations
-print("Population without genome reordering:")
 cgp.evolve(
     pop, objective, ea, **evolve_params, print_progress=True, callback=recording_callback,
 )
 
-print("Population with genome reordering:")
 cgp.evolve(
     pop_with_reorder,
     objective,

test/test_genome.py

@@ -616,3 +616,34 @@ def test_genome_reordering_empirically(rng):
         genome.reorder(rng)
         sympy_expression_after_reorder = cgp.CartesianGraph(genome).to_sympy()
         assert sympy_expression_after_reorder == sympy_expression
+
+
+def test_genome_reordering_parameterization_consistency(rng):
+
+    genome_params = {
+        "n_inputs": 2,
+        "n_outputs": 1,
+        "n_columns": 10,
+        "n_rows": 2,
+        "levels_back": None,
+        "primitives": (cgp.Mul, cgp.Sub, cgp.Add, cgp.ConstantFloat),
+    }
+
+    genome = cgp.Genome(**genome_params)
+
+    with pytest.raises(ValueError):
+        genome.reorder(rng)
+
+    genome_params = {
+        "n_inputs": 2,
+        "n_outputs": 1,
+        "n_columns": 10,
+        "n_rows": 1,
+        "levels_back": 5,
+        "primitives": (cgp.Mul, cgp.Sub, cgp.Add, cgp.ConstantFloat),
+    }
+
+    genome = cgp.Genome(**genome_params)
+
+    with pytest.raises(ValueError):
+        genome.reorder(rng)