Add PermutableGenotype support for scaled MultiRangeGenotype

Author: basvanwesting

src/genotype/multi_range.rs

@@ -1,5 +1,5 @@
 use super::builder::{Builder, TryFromBuilderError};
-use super::{EvolveGenotype, Genotype, HillClimbGenotype, MutationType};
+use super::{EvolveGenotype, Genotype, HillClimbGenotype, MutationType, PermutateGenotype};
 use crate::allele::RangeAllele;
 use crate::chromosome::{ChromosomeManager, GenesHash, GenesOwner, MultiRangeChromosome};
 use crate::population::Population;
@@ -574,6 +574,190 @@ where
     }
 }
 
+impl<T: RangeAllele + Into<f64>> PermutateGenotype for MultiRange<T>
+where
+    T: SampleUniform,
+    Uniform<T>: Send + Sync,
+{
+    fn chromosome_permutations_into_iter<'a>(
+        &'a self,
+        chromosome: Option<&Self::Chromosome>,
+        scale_index: Option<usize>,
+    ) -> Box<dyn Iterator<Item = Self::Chromosome> + Send + 'a> {
+        if self.seed_genes_list.is_empty() {
+            match self.mutation_type {
+                MutationType::Scaled => Box::new(
+                    self.permutable_gene_values_scaled(chromosome, scale_index.unwrap())
+                        .into_iter()
+                        .multi_cartesian_product()
+                        .map(MultiRangeChromosome::new),
+                ),
+                MutationType::Relative => {
+                    panic!("RangeGenotype is not permutable for MutationType::Relative")
+                }
+                MutationType::Random => {
+                    panic!("RangeGenotype is not permutable for MutationType::Random")
+                }
+            }
+        } else {
+            Box::new(
+                self.seed_genes_list
+                    .clone()
+                    .into_iter()
+                    .map(MultiRangeChromosome::new),
+            )
+        }
+    }
+
+    fn chromosome_permutations_size(&self, scale_index: Option<usize>) -> BigUint {
+        if self.seed_genes_list.is_empty() {
+            match self.mutation_type {
+                MutationType::Scaled => {
+                    let median_chromosome = self.median_chromosome();
+                    self.permutable_gene_values_scaled(
+                        Some(&median_chromosome),
+                        scale_index.unwrap(),
+                    )
+                    .iter()
+                    .map(|v| BigUint::from(v.len()))
+                    .product()
+                }
+                MutationType::Relative => {
+                    panic!("RangeGenotype is not permutable for MutationType::Relative")
+                }
+                MutationType::Random => {
+                    panic!("RangeGenotype is not permutable for MutationType::Random")
+                }
+            }
+        } else {
+            self.seed_genes_list.len().into()
+        }
+    }
+    fn mutation_type_allows_permutation(&self) -> bool {
+        match self.mutation_type {
+            MutationType::Scaled => true,
+            MutationType::Relative => false,
+            MutationType::Random => false,
+        }
+    }
+}
+
+impl<T: RangeAllele + Into<f64>> MultiRange<T>
+where
+    T: SampleUniform,
+    Uniform<T>: Send + Sync,
+{
+    // scales should be symmetrical, so the step is simply the scale end
+    pub fn permutable_gene_values_scaled(
+        &self,
+        chromosome: Option<&MultiRangeChromosome<T>>,
+        scale_index: usize,
+    ) -> Vec<Vec<T>> {
+        self.allele_ranges
+            .clone()
+            .into_iter()
+            .enumerate()
+            .map(|(index, allele_range)| {
+                let allele_range_start = *allele_range.start();
+                let allele_range_end = *allele_range.end();
+
+                let (allele_value_start, allele_value_end) = if let Some(chromosome) = chromosome {
+                    if let Some(previous_scale_index) = scale_index.checked_sub(1) {
+                        let working_range = &self.allele_mutation_scaled_ranges.as_ref().unwrap()
+                            [previous_scale_index][index];
+
+                        let working_range_start = *working_range.start();
+                        let working_range_end = *working_range.end();
+
+                        let base_value = chromosome.genes[index];
+                        let value_start = if base_value + working_range_start < allele_range_start {
+                            allele_range_start
+                        } else {
+                            base_value + working_range_start
+                        };
+                        let value_end = if base_value + working_range_end > allele_range_end {
+                            allele_range_end
+                        } else {
+                            base_value + working_range_end
+                        };
+
+                        (value_start, value_end)
+                    } else {
+                        (allele_range_start, allele_range_end)
+                    }
+                } else {
+                    (allele_range_start, allele_range_end)
+                };
+
+                let working_range =
+                    &self.allele_mutation_scaled_ranges.as_ref().unwrap()[scale_index][index];
+                let working_range_step = *working_range.end();
+
+                std::iter::successors(Some(allele_value_start), |value| {
+                    if *value < allele_value_end {
+                        let next_value = *value + working_range_step;
+                        if next_value > allele_value_end {
+                            Some(allele_value_end)
+                        } else {
+                            Some(next_value)
+                        }
+                    } else {
+                        None
+                    }
+                })
+                .collect()
+            })
+            .collect()
+    }
+
+    // pub fn permutable_gene_values_relative(
+    //     &self,
+    //     _chromosome: Option<&MultiRangeChromosome<T>>,
+    // ) -> Vec<Vec<T>> {
+    //     panic!("MultiRangeGenotype is not permutable for MutationType::Relative");
+    // }
+    //
+    // pub fn permutable_gene_values_random(
+    //     &self,
+    //     _chromosome: Option<&MultiRangeChromosome<T>>,
+    // ) -> Vec<Vec<T>> {
+    //     panic!("MultiRangeGenotype is not permutable for MutationType::Random");
+    // }
+
+    pub fn median_chromosome(&self) -> MultiRangeChromosome<T> {
+        let median_genes = self
+            .allele_ranges
+            .clone()
+            .into_iter()
+            .enumerate()
+            .map(|(index, allele_range)| {
+                let allele_range_start = *allele_range.start();
+                let allele_range_end = *allele_range.end();
+
+                let working_range = &self.allele_mutation_scaled_ranges.as_ref().unwrap()[0][index];
+                let working_range_step = *working_range.end();
+
+                let allele_value_iter = std::iter::successors(Some(allele_range_start), |value| {
+                    if *value < allele_range_end {
+                        let next_value = *value + working_range_step;
+                        if next_value > allele_range_end {
+                            Some(allele_range_end)
+                        } else {
+                            Some(next_value)
+                        }
+                    } else {
+                        None
+                    }
+                });
+
+                let median_step = allele_value_iter.clone().count() / 2;
+                allele_value_iter.clone().nth(median_step).unwrap()
+            })
+            .collect();
+        MultiRangeChromosome::new(median_genes)
+    }
+}
+
 impl<T: RangeAllele + Into<f64>> ChromosomeManager<Self> for MultiRange<T>
 where
     T: SampleUniform,

src/genotype/range.rs

@@ -588,7 +588,7 @@ where
     T: SampleUniform,
     Uniform<T>: Send + Sync,
 {
-    // scales should be symmetrical, so the stap is simply the scale end
+    // scales should be symmetrical, so the step is simply the scale end
     pub fn permutable_gene_values_scaled(
         &self,
         chromosome: Option<&RangeChromosome<T>>,
@@ -688,21 +688,6 @@ where
     }
 }
 
-// impl<T: RangeAllele> PermutableGenotype for Range<T>
-// where
-//     T: SampleUniform,
-//     Uniform<T>: Send + Sync,
-// {
-//     fn chromosome_permutations_into_iter(&self) -> impl Iterator<Item = Self::Chromosome> + Send {
-//         panic!("RangeGenotype is not permutable");
-//         #[allow(unreachable_code)]
-//         [].into_iter()
-//     }
-//     fn chromosome_permutations_size(&self) -> BigUint {
-//         BigUint::default()
-//     }
-// }
-
 impl<T: RangeAllele> ChromosomeManager<Self> for Range<T>
 where
     T: SampleUniform,