scarlet_queen_core/
group.rs

1//! Mod for `InitializerTrait` and `GroupTrait`.
2
3pub use group_trait::GroupTrait;
4pub use initializer::InitializerTrait;
5
6mod initializer {
7    //! Mod for `InitializerTrait`.
8
9    use super::GroupTrait;
10
11    /// A trait for initializing the group.
12    /// * `T` - A data generated by this.(A element of the group)
13    /// * `N` - The number of datas generated by this.(The number of the elements of the group)
14    pub trait InitializerTrait<T, const N: usize> {
15        /// Generate an initalized array.
16        fn initialize() -> [T; N];
17
18        /// Initialize the group.
19        /// * `G` - group
20        /// * `R` - The `R` of group
21        fn init_group<G, const R: usize>() -> G
22        where
23            G: GroupTrait<T, N, R>,
24        {
25            G::new(Self::initialize())
26        }
27    }
28
29    #[cfg(test)]
30    mod tests {
31        use super::InitializerTrait;
32
33        struct SampleInitializer;
34        impl<const N: usize> InitializerTrait<u8, N> for SampleInitializer {
35            fn initialize() -> [u8; N] {
36                let mut i: u8 = 0;
37                [0; N].map(|_| {
38                    i += 1;
39                    i - 1
40                })
41            }
42        }
43
44        #[test]
45        fn test_initalizertrait_initialize() {
46            assert_eq!(
47                <SampleInitializer as InitializerTrait<u8, 0>>::initialize(),
48                []
49            );
50            assert_eq!(
51                <SampleInitializer as InitializerTrait<u8, 4>>::initialize(),
52                [0, 1, 2, 3]
53            );
54            assert_eq!(
55                <SampleInitializer as InitializerTrait<u8, 6>>::initialize(),
56                [0, 1, 2, 3, 4, 5]
57            );
58        }
59    }
60}
61
62mod group_trait {
63    //! Mod for `GroupTrait`.
64
65    use std::{fmt::Debug, io::Write};
66
67    use super::InitializerTrait;
68    use crate::each_individual::Individual;
69
70    /// A trait for a group which contains individuals.
71    /// * `T` - A element of this group
72    /// * `N` - The number of individuals
73    /// * `R` - The number of individuals after individuals are reduced by selector
74    pub trait GroupTrait<T, const N: usize, const R: usize> {
75        /// An error of cycle
76        type Err: Debug;
77
78        /// Create `Self` from a array.
79        /// * `data` - A array of individuals
80        fn new(data: [T; N]) -> Self;
81
82        /// Run one cycle and update individuals.
83        fn one_cycle(&mut self) -> Result<(), Self::Err>;
84
85        /// Create an iterator of indivuduals.
86        /// * `'a` - A lifetime of `self`.
87        fn iter<'a>(&'a self) -> impl Iterator<Item = &'a Individual<T>>
88        where
89            T: 'a;
90
91        /// Initialize `Self` by `I` algorithm.
92        /// * `I` - Algorithm of initializing.
93        fn init<I>() -> Self
94        where
95            I: InitializerTrait<T, N>,
96            Self: Sized,
97        {
98            I::init_group::<Self, R>()
99        }
100
101        /// Assign a number to individuals in order.
102        fn reset_id(&self) {
103            self.iter().enumerate().for_each(|(i, v)| v.set_id(i));
104        }
105
106        #[allow(unused_variables)]
107        /// Run one cycle with outputing and update individuals.
108        ///
109        /// By default, there is not outputing.(Run `one_cycle` simply.)
110        /// * `out` - A target of outputing.
111        fn one_cycle_out<W>(&mut self, out: &mut W) -> Result<(), Self::Err>
112        where
113            W: Write,
114        {
115            <Self as GroupTrait<T, N, R>>::one_cycle(self)
116        }
117
118        /// Clone individuals which are contained by this.
119        fn clone_values(&self) -> Vec<T>
120        where
121            T: Clone,
122        {
123            self.iter()
124                .map(|v| v.get_value())
125                .cloned()
126                .collect::<Vec<T>>()
127        }
128    }
129}