scarlet_queen_selector/
roulette.rs

1use rand::{distr::weighted::WeightedIndex, rng, seq::IndexedRandom};
2use scarlet_queen_core::{EachCrateIndividual, Individual, SelectorIndividualTrait};
3use std::{
4    collections::{HashMap, HashSet},
5    rc::Rc,
6};
7
8use crate::error::SelectorError;
9
10#[derive(Debug)]
11pub struct RouletteSelectorIndividual<T, const R: usize> {
12    individual: Rc<Individual<T>>,
13}
14
15impl<T, const R: usize> EachCrateIndividual for RouletteSelectorIndividual<T, R> {
16    type Item = T;
17
18    fn new(individual: &Rc<Individual<T>>) -> Self {
19        RouletteSelectorIndividual {
20            individual: Rc::clone(individual),
21        }
22    }
23
24    fn get_id(&self) -> usize {
25        self.individual.get_id()
26    }
27
28    fn get_value(&self) -> &T {
29        self.individual.get_value()
30    }
31
32    fn get_individual(&self) -> &Individual<T> {
33        &self.individual
34    }
35}
36
37impl<T, const R: usize> SelectorIndividualTrait<R> for RouletteSelectorIndividual<T, R> {
38    type Err = SelectorError;
39
40    fn selected_ids<'a, U>(
41        // idと種類の組
42        group: U,
43        // idとスコアの組
44        _scores: HashMap<usize, usize>,
45    ) -> Result<HashSet<usize>, Self::Err>
46    where
47        U: IntoIterator<Item = &'a Self>,
48        Self: 'a,
49    {
50        let group = group.into_iter().collect::<Vec<&Self>>();
51
52        if group.len() < R {
53            return Err(SelectorError::TooFewGroupError);
54        }
55
56        // (type, id)
57        let mut type_with_id: HashMap<usize, Vec<usize>> = HashMap::new();
58        // (type, score)
59        let mut type_with_score: HashMap<usize, usize> = HashMap::new();
60        for v in group {
61            type_with_score.insert(v.get_id(), 0);
62        }
63        let scores =
64            WeightedIndex::new(type_with_score.values()).map_err(SelectorError::WeightError)?;
65
66        let mut rng = rng();
67
68        Ok(HashSet::new())
69    }
70}