Add Population unique_chromosome_indices and best_unique_chromosome_indices functions

Author: basvanwesting

src/population.rs

@@ -1,9 +1,11 @@
 //! The population is a  container for [Chromosomes](Chromosome)
-use crate::chromosome::Chromosome;
+use crate::chromosome::{Chromosome, GenesHash};
 use crate::fitness::{FitnessOrdering, FitnessValue};
 use cardinality_estimator::CardinalityEstimator;
+use itertools::Itertools;
 use rand::prelude::*;
 use std::cmp::Reverse;
+use std::collections::HashMap;
 
 #[derive(Clone, Debug)]
 pub struct Population<C: Chromosome> {
@@ -65,6 +67,7 @@ impl<C: Chromosome> Population<C> {
 
     // Returns one less than total size with known fitness due to implementation constraints
     // Doesn't matter the amount should be much less than the population size
+    // Does not care about uniqueness of the genes_hash
     pub fn best_chromosome_indices(
         &self,
         amount: usize,
@@ -95,6 +98,57 @@ impl<C: Chromosome> Population<C> {
         }
     }
 
+    // Only works when genes_hash is stored on chromosome, as this is the uniqueness key.
+    // Takes the first index occurence of a genes_hash. Returns indices in ascending order
+    pub fn unique_chromosome_indices(&self) -> Vec<usize> {
+        let mut data: HashMap<GenesHash, usize> = HashMap::new();
+        self.chromosomes
+            .iter()
+            .enumerate()
+            .for_each(|(index, chromosome)| {
+                if let Some(genes_hash) = chromosome.genes_hash() {
+                    data.entry(genes_hash).or_insert_with(|| index);
+                }
+            });
+        data.into_values().sorted().collect()
+    }
+
+    // Only works when genes_hash is stored on chromosome, as this is the uniqueness key.
+    // Assume chromosomes sorted by fitness, takes the first index occurence of a genes_hash
+    // Returns indices in ascending order (irrespective of fitness)
+    pub fn best_unique_chromosome_indices(
+        &self,
+        amount: usize,
+        fitness_ordering: FitnessOrdering,
+    ) -> Vec<usize> {
+        let mut data: HashMap<GenesHash, (usize, isize)> = HashMap::new();
+        self.chromosomes
+            .iter()
+            .enumerate()
+            .for_each(|(index, chromosome)| {
+                if let Some(genes_hash) = chromosome.genes_hash() {
+                    if let Some(fitness_score) = chromosome.fitness_score() {
+                        data.entry(genes_hash)
+                            .or_insert_with(|| (index, fitness_score));
+                    }
+                }
+            });
+
+        if data.is_empty() {
+            Vec::new()
+        } else {
+            let iterator = match fitness_ordering {
+                FitnessOrdering::Maximize => data
+                    .into_values()
+                    .sorted_unstable_by_key(|(_, score)| Reverse(*score)),
+                FitnessOrdering::Minimize => data
+                    .into_values()
+                    .sorted_unstable_by_key(|(_, score)| *score),
+            };
+            iterator.take(amount).map(|(idx, _)| idx).sorted().collect()
+        }
+    }
+
     pub fn age_mean(&self) -> f32 {
         stats::mean(self.chromosomes.iter().map(|c| c.age())) as f32
     }

tests/population_test.rs

@@ -177,6 +177,98 @@ mod population_tests {
         );
     }
 
+    #[test]
+    fn unique_chromosome_indices() {
+        let genotype = BinaryGenotype::builder()
+            .with_genes_size(3)
+            .with_genes_hashing(true)
+            .build()
+            .unwrap();
+
+        let mut population: Population<BinaryChromosome> =
+            build::population_with_fitness_scores(vec![
+                (vec![false, true, true], Some(2)),
+                (vec![false, true, true], Some(2)),
+                (vec![false, false, false], Some(0)),
+                (vec![true, true, true], Some(3)),
+                (vec![false, false, false], Some(0)),
+                (vec![true, true, true], Some(3)),
+                (vec![false, false, true], Some(1)),
+                (vec![false, false, true], Some(1)),
+                (vec![true, true, false], None),
+                (vec![true, true, false], None),
+            ]);
+
+        population.chromosomes.iter_mut().for_each(|chromosome| {
+            let genes_hash = genotype.calculate_genes_hash(chromosome);
+            chromosome.set_genes_hash(genes_hash);
+        });
+
+        assert_eq!(population.unique_chromosome_indices(), vec![0, 2, 3, 6, 8]);
+    }
+
+    #[test]
+    fn best_unique_chromosome_indices() {
+        let genotype = BinaryGenotype::builder()
+            .with_genes_size(3)
+            .with_genes_hashing(true)
+            .build()
+            .unwrap();
+
+        let mut population: Population<BinaryChromosome> =
+            build::population_with_fitness_scores(vec![
+                (vec![false, true, true], Some(2)),
+                (vec![false, true, true], Some(2)),
+                (vec![false, false, false], Some(0)),
+                (vec![true, true, true], Some(3)),
+                (vec![false, false, false], Some(0)),
+                (vec![true, true, true], Some(3)),
+                (vec![false, false, true], Some(1)),
+                (vec![false, false, true], Some(1)),
+                (vec![true, true, false], None),
+                (vec![true, true, false], None),
+            ]);
+
+        population.chromosomes.iter_mut().for_each(|chromosome| {
+            let genes_hash = genotype.calculate_genes_hash(chromosome);
+            chromosome.set_genes_hash(genes_hash);
+        });
+
+        assert_eq!(
+            population.best_unique_chromosome_indices(2, FitnessOrdering::Maximize),
+            vec![0, 3]
+        );
+        assert_eq!(
+            population.best_unique_chromosome_indices(1, FitnessOrdering::Maximize),
+            vec![3]
+        );
+        assert_eq!(
+            population.best_unique_chromosome_indices(0, FitnessOrdering::Maximize),
+            vec![]
+        );
+        assert_eq!(
+            population.best_unique_chromosome_indices(10, FitnessOrdering::Maximize),
+            vec![0, 2, 3, 6]
+        );
+
+        assert_eq!(
+            population.best_unique_chromosome_indices(2, FitnessOrdering::Minimize),
+            vec![2, 6]
+        );
+        assert_eq!(
+            population.best_unique_chromosome_indices(1, FitnessOrdering::Minimize),
+            vec![2]
+        );
+        assert_eq!(
+            population.best_unique_chromosome_indices(0, FitnessOrdering::Minimize),
+            vec![]
+        );
+        assert_eq!(
+            population.best_unique_chromosome_indices(10, FitnessOrdering::Minimize),
+            vec![0, 2, 3, 6]
+        );
+    }
+
     #[test]
     fn fitness_score_cardinality() {
         let population: Population<BinaryChromosome> = build::population(vec![