Add MutationType::Discrete to RangeGenotype for symmetry reasons

Author: basvanwesting

src/genotype/range.rs

@@ -102,6 +102,16 @@ where
             let genes_size = builder.genes_size.unwrap();
             let allele_range = builder.allele_range.unwrap();
             let mutation_type = builder.mutation_type.unwrap_or(MutationType::Random);
+            let allele_sampler = match mutation_type {
+                MutationType::Discrete => {
+                    // [start, end+1) for uniform floor() sampling
+                    Uniform::new(*allele_range.start(), *allele_range.end() + T::one())
+                }
+                _ => {
+                    // [start, end] for uniform sampling
+                    Uniform::from(allele_range.clone())
+                }
+            };
             let allele_bandwidth_sampler = match &mutation_type {
                 MutationType::Range(bandwidth) => {
                     Some(Uniform::new_inclusive(T::smallest_increment(), bandwidth))
@@ -118,7 +128,7 @@ where
                 allele_range: allele_range.clone(),
                 mutation_type,
                 gene_index_sampler: Uniform::from(0..genes_size),
-                allele_sampler: Uniform::from(allele_range.clone()),
+                allele_sampler,
                 allele_bandwidth_sampler,
                 current_scale_index: 0,
                 seed_genes_list: builder.seed_genes_list,
@@ -137,15 +147,21 @@ where
         &self.mutation_type
     }
     pub fn sample_gene_random<R: Rng>(&self, rng: &mut R) -> T {
-        self.allele_sampler.sample(rng)
+        match self.mutation_type {
+            MutationType::Discrete => self.allele_sampler.sample(rng).floor(),
+            _ => self.allele_sampler.sample(rng),
+        }
     }
 
     // all delta's are positive, because we support unsigned integers as RangeAllele
     // quite the overhead to make this work, but I think it is worth it
     pub fn mutate_gene<R: Rng>(&self, chromosome: &mut Chromosome<T>, index: usize, rng: &mut R) {
         match &self.mutation_type {
             MutationType::Random => {
-                chromosome.genes[index] = self.sample_gene_random(rng);
+                chromosome.genes[index] = self.allele_sampler.sample(rng);
+            }
+            MutationType::Discrete => {
+                chromosome.genes[index] = self.allele_sampler.sample(rng).floor();
             }
             MutationType::Range(_) => {
                 // post-clamp
@@ -178,7 +194,7 @@ where
                     let allele_range_end = *self.allele_range.end();
                     if allele_range_end - allele_range_start <= bandwidth {
                         // Random, leverage existing sampler
-                        chromosome.genes[index] = self.sample_gene_random(rng);
+                        chromosome.genes[index] = self.allele_sampler.sample(rng);
                     } else {
                         // Bandwidth
                         let current_value = chromosome.genes[index];
@@ -219,9 +235,6 @@ where
                         T::clamped_sub(current_value, delta, *self.allele_range.start());
                 }
             }
-            MutationType::Discrete => {
-                panic!("RangeGenotype has no implementation for MutationType::Discrete")
-            }
         }
     }
 }
@@ -454,7 +467,7 @@ where
                 }
             }
             MutationType::Discrete => {
-                panic!("RangeGenotype has no implementation for MutationType::Discrete")
+                self.fill_neighbouring_population_discrete(chromosome, population)
             }
         }
     }
@@ -583,6 +596,28 @@ where
             };
         });
     }
+    fn fill_neighbouring_population_discrete(
+        &self,
+        chromosome: &Chromosome<T>,
+        population: &mut Population<T>,
+    ) {
+        let starting_value = self.allele_range.start().floor();
+        let ending_value = self.allele_range.end().floor();
+
+        (0..self.genes_size).for_each(|index| {
+            let mut working_value = starting_value;
+            let current_value = chromosome.genes[index].floor();
+            while working_value <= ending_value {
+                if working_value != current_value {
+                    let mut new_chromosome = population.new_chromosome(chromosome);
+                    new_chromosome.genes[index] = working_value;
+                    new_chromosome.reset_metadata(self.genes_hashing);
+                    population.chromosomes.push(new_chromosome);
+                }
+                working_value += T::one();
+            }
+        });
+    }
 }
 
 impl<T: RangeAllele> PermutateGenotype for Range<T>
@@ -604,6 +639,7 @@ where
                         MutationType::StepScaled(steps) => {
                             self.permutable_gene_values_step_scaled(index, chromosome, steps)
                         }
+                        MutationType::Discrete => self.permutable_gene_values_discrete(),
                         _ => {
                             panic!(
                                 "RangeGenotype is not permutable for {:?}",
@@ -649,7 +685,7 @@ where
     fn allows_permutation(&self) -> bool {
         matches!(
             self.mutation_type,
-            MutationType::Step(_) | MutationType::StepScaled(_)
+            MutationType::Step(_) | MutationType::StepScaled(_) | MutationType::Discrete
         )
     }
 }
@@ -713,6 +749,24 @@ where
         .collect()
     }
 
+    pub fn permutable_gene_values_discrete(&self) -> Vec<T> {
+        let allele_value_start = self.allele_range.start().floor();
+        let allele_value_end = self.allele_range.end().floor();
+        std::iter::successors(Some(allele_value_start), |value| {
+            if *value < allele_value_end {
+                let next_value = *value + T::one();
+                if next_value > allele_value_end {
+                    Some(allele_value_end)
+                } else {
+                    Some(next_value)
+                }
+            } else {
+                None
+            }
+        })
+        .collect()
+    }
+
     pub fn chromosome_permutations_size_per_scale(&self) -> Vec<BigUint> {
         // first scale is affected by seed_genes_list
         let mut results = vec![];
@@ -774,6 +828,24 @@ where
                     })
                     .count()
                 }
+                MutationType::Discrete => {
+                    let allele_value_start = self.allele_range.start().floor();
+                    let allele_value_end = self.allele_range.end().floor();
+
+                    std::iter::successors(Some(allele_value_start), |value| {
+                        if *value < allele_value_end {
+                            let next_value = *value + T::one();
+                            if next_value > allele_value_end {
+                                Some(allele_value_end)
+                            } else {
+                                Some(next_value)
+                            }
+                        } else {
+                            None
+                        }
+                    })
+                    .count()
+                }
                 _ => {
                     panic!(
                         "RangeGenotype is not permutable for {:?}",
@@ -791,7 +863,19 @@ where
     Uniform<T>: Send + Sync,
 {
     fn clone(&self) -> Self {
-        let allele_sampler = Uniform::from(self.allele_range.clone());
+        let allele_sampler = match self.mutation_type {
+            MutationType::Discrete => {
+                // [start, end+1) for uniform floor() sampling
+                Uniform::new(
+                    *self.allele_range.start(),
+                    *self.allele_range.end() + T::one(),
+                )
+            }
+            _ => {
+                // [start, end] for uniform sampling
+                Uniform::from(self.allele_range.clone())
+            }
+        };
         let allele_bandwidth_sampler = match &self.mutation_type {
             MutationType::Range(bandwidth) => {
                 Some(Uniform::new_inclusive(T::smallest_increment(), bandwidth))

tests/genotype/range_test.rs

@@ -200,6 +200,31 @@ fn float_mutate_chromosome_single_step_scaled() {
     ));
 }
 
+#[test]
+fn float_mutate_chromosome_single_discrete() {
+    let mut rng = SmallRng::seed_from_u64(0);
+    let genotype = RangeGenotype::builder()
+        .with_genes_size(10)
+        .with_allele_range(0.0..=10.0)
+        .with_mutation_type(MutationType::Discrete)
+        .build()
+        .unwrap();
+
+    let mut chromosome = Chromosome::new(genotype.random_genes_factory(&mut rng));
+    assert!(relative_chromosome_eq(
+        inspect::chromosome(&chromosome),
+        vec![4.0, 4.0, 10.0, 5.0, 9.0, 10.0, 6.0, 5.0, 4.0, 9.0],
+        0.001,
+    ));
+
+    genotype.mutate_chromosome_genes(3, false, &mut chromosome, &mut rng);
+    assert!(relative_chromosome_eq(
+        inspect::chromosome(&chromosome),
+        vec![2.0, 4.0, 10.0, 5.0, 9.0, 2.0, 6.0, 5.0, 4.0, 3.0],
+        0.001,
+    ));
+}
+
 #[test]
 fn mutate_chromosome_genes_random_with_duplicates() {
     let mut rng = SmallRng::seed_from_u64(0);
@@ -429,6 +454,40 @@ fn float_neighbouring_population_2_step_scaled() {
     ));
 }
 
+#[test]
+fn float_neighbouring_population_2_discrete() {
+    let mut rng = SmallRng::seed_from_u64(0);
+    let genotype = RangeGenotype::builder()
+        .with_genes_size(2)
+        .with_allele_range(0.0..=3.0)
+        .with_mutation_type(MutationType::Discrete)
+        .build()
+        .unwrap();
+
+    let chromosome = Chromosome::new(genotype.random_genes_factory(&mut rng));
+    assert!(relative_chromosome_eq(
+        inspect::chromosome(&chromosome),
+        vec![1.0, 1.0],
+        0.001
+    ));
+
+    assert_eq!(genotype.neighbouring_population_size(), BigUint::from(4u32));
+    let mut population = Population::new(vec![], true);
+    genotype.fill_neighbouring_population(&chromosome, &mut population, &mut rng);
+    assert!(relative_population_eq(
+        inspect::population(&population),
+        vec![
+            vec![0.0, 1.0],
+            vec![2.0, 1.0],
+            vec![3.0, 1.0],
+            vec![1.0, 0.0],
+            vec![1.0, 2.0],
+            vec![1.0, 3.0]
+        ],
+        0.001,
+    ));
+}
+
 #[test]
 fn float_neighbouring_population_3() {
     let mut rng = SmallRng::seed_from_u64(0);
@@ -655,6 +714,56 @@ fn float_chromosome_permutations_2_step_scaled() {
     ));
 }
 
+#[test]
+fn float_chromosome_permutations_2_discrete() {
+    let mut rng = SmallRng::seed_from_u64(0);
+    let genotype = RangeGenotype::builder()
+        .with_genes_size(2)
+        .with_allele_range(0.0..=3.0)
+        .with_mutation_type(MutationType::Discrete)
+        .build()
+        .unwrap();
+
+    assert_eq!(
+        genotype.chromosome_permutations_size(),
+        BigUint::from(16u32)
+    );
+
+    let chromosome = Chromosome::new(genotype.random_genes_factory(&mut rng));
+    assert!(relative_chromosome_eq(
+        inspect::chromosome(&chromosome),
+        vec![1.0, 1.0],
+        0.001
+    ));
+
+    let chromosomes = genotype
+        .chromosome_permutations_into_iter(Some(&chromosome))
+        .collect::<Vec<_>>();
+
+    assert!(relative_population_eq(
+        inspect::chromosomes(&chromosomes),
+        vec![
+            vec![0.0, 0.0],
+            vec![0.0, 1.0],
+            vec![0.0, 2.0],
+            vec![0.0, 3.0],
+            vec![1.0, 0.0],
+            vec![1.0, 1.0],
+            vec![1.0, 2.0],
+            vec![1.0, 3.0],
+            vec![2.0, 0.0],
+            vec![2.0, 1.0],
+            vec![2.0, 2.0],
+            vec![2.0, 3.0],
+            vec![3.0, 0.0],
+            vec![3.0, 1.0],
+            vec![3.0, 2.0],
+            vec![3.0, 3.0],
+        ],
+        0.001,
+    ));
+}
+
 #[test]
 fn integer_mutate_chromosome_single_random() {
     let mut rng = SmallRng::seed_from_u64(0);