Struct Group

pub struct Group<T, FI, SI, RI, const N: usize, const R: usize>
where
    T: Clone,
    FI: EachCrateIndividual<Item = T> + FitnessIndividualTrait,
    SI: EachCrateIndividual<Item = T> + SelectorIndividualTrait<R>,
    RI: EachCrateIndividual<Item = T> + ReplenisherIndividualTrait<N, R>,
{ /* private fields */ }

A group which contains GenerationIndividual.

This is implmented GroupTrait. Process three steps of one_cycle_with_output based on FitnessIndividual, SelectorIndividual, and ReplenisherIndividual of GenerationIndividual.

Example

use scarlet_queen_core::{GroupTrait, InitializerTrait};
use scarlet_queen_fitness::ord::GeFitness;
use scarlet_queen_replenisher::TournamentReplenisherIndividual;
use scarlet_queen_selector::TournamentSelectorIndividual;
use scarlet_queen_generation::{Group, ResultOut};

struct InitializerSample {}
impl<const N: usize> InitializerTrait<u8, N> for InitializerSample {
    fn initialize() -> [u8; N] {
        let mut i: u8 = 0;
        [0; N]
            .map(|_| {
                i += 2;
                i - 2
            })
    }
}

type GroupSample<const N: usize, const R: usize> = Group<u8, GeFitness<u8>, TournamentSelectorIndividual<u8, R>, TournamentReplenisherIndividual<u8, N, R>, N, R>;
let mut group: GroupSample<5, 4> = GroupSample::init::<InitializerSample>();

let output: ResultOut<u8> = group.one_cycle_with_output().unwrap();

assert_eq!(serde_json::to_string(&output).unwrap(), r#"{
    "individuals_and_scores": [
        {
            "individual": {
                "id": 4,
                "value": "8"
            },
            "score": 4
        },
        {
            "individual": {
                "id": 3,
                "value": "6"
            },
            "score": 3
        },
        {
            "individual": {
                "id": 2,
                "value": "4"
            },
            "score": 2
        },
        {
            "individual": {
                "id": 1,
                "value": "2"
            },
            "score": 1
        },
        {
            "individual": {
                "id": 0,
                "value": "0"
            },
            "score": 0
        }
    ],
    "new_individuals": [
        {
            "id": 4,
            "value": "8"
        },
        {
            "id": 3,
            "value": "6"
        },
        {
            "id": 2,
            "value": "4"
        },
        {
            "id": 1,
            "value": "2"
        },
        {
            "id": 0,
            "value": "8"
        }
    ]
}"#.to_string().chars().filter_map(|c| if c.is_whitespace() { None } else { Some(c) }).collect::<String>());
assert_eq!(
    group.clone_values(),
    vec![8u8, 6, 4, 2, 8]
);

Trait Implementations

impl<T, FI, SI, RI, const N: usize, const R: usize> Debug for Group<T, FI, SI, RI, N, R>

where T: Debug + Clone, FI: Debug + EachCrateIndividual<Item = T> + FitnessIndividualTrait, SI: Debug + EachCrateIndividual<Item = T> + SelectorIndividualTrait<R>, RI: Debug + EachCrateIndividual<Item = T> + ReplenisherIndividualTrait<N, R>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T, FI, SI, RI, const N: usize, const R: usize> GroupTrait<T, N, R> for Group<T, FI, SI, RI, N, R>

where T: Clone + Debug, FI: EachCrateIndividual<Item = T> + FitnessIndividualTrait, SI: EachCrateIndividual<Item = T> + SelectorIndividualTrait<R>, RI: EachCrateIndividual<Item = T> + ReplenisherIndividualTrait<N, R>,

type Err = GenerationError

An error of cycle.

type Out = ResultOut<T>

An output of cycle.

fn new(data: [T; N]) -> Group<T, FI, SI, RI, N, R>

Create Self from an array. The return value is already assigned a number.

fn one_cycle_with_output( &mut self, ) -> Result<<Group<T, FI, SI, RI, N, R> as GroupTrait<T, N, R>>::Out, <Group<T, FI, SI, RI, N, R> as GroupTrait<T, N, R>>::Err>

Run one cycle with outputing and update individuals. The elements of self must be already assigned a number before calling this method.

fn iter<'a>(&'a self) -> impl Iterator<Item = &'a Individual<T>>

where T: 'a,

Create an iterator of individuals.

fn init<I>() -> Self

where I: InitializerTrait<T, N>, Self: Sized,

Initialize Self by I algorithm. The elements of self must be already assigned a number.

fn reset_id(&self)

Assign numbers to individuals in order.

fn clone_values(&self) -> Vec<T>

where T: Clone,

Clone individuals of this group.

impl<'a, T, FI, SI, RI, const N: usize, const R: usize> IntoIterator for &'a Group<T, FI, SI, RI, N, R>

where T: Clone, FI: EachCrateIndividual<Item = T> + FitnessIndividualTrait, SI: EachCrateIndividual<Item = T> + SelectorIndividualTrait<R>, RI: EachCrateIndividual<Item = T> + ReplenisherIndividualTrait<N, R>,

type IntoIter = Iter<'a, GenerationIndividual<T, FI, SI, RI, N, R>>

Which kind of iterator are we turning this into?

type Item = &'a GenerationIndividual<T, FI, SI, RI, N, R>

The type of the elements being iterated over.

fn into_iter(self) -> <&'a Group<T, FI, SI, RI, N, R> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, FI, SI, RI, const N: usize, const R: usize> PartialEq for Group<T, FI, SI, RI, N, R>

where T: PartialEq + Clone, FI: PartialEq + EachCrateIndividual<Item = T> + FitnessIndividualTrait, SI: PartialEq + EachCrateIndividual<Item = T> + SelectorIndividualTrait<R>, RI: PartialEq + EachCrateIndividual<Item = T> + ReplenisherIndividualTrait<N, R>,

fn eq(&self, other: &Group<T, FI, SI, RI, N, R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, FI, SI, RI, const N: usize, const R: usize> Eq for Group<T, FI, SI, RI, N, R>

where T: Eq + Clone, FI: Eq + EachCrateIndividual<Item = T> + FitnessIndividualTrait, SI: Eq + EachCrateIndividual<Item = T> + SelectorIndividualTrait<R>, RI: Eq + EachCrateIndividual<Item = T> + ReplenisherIndividualTrait<N, R>,

impl<T, FI, SI, RI, const N: usize, const R: usize> StructuralPartialEq for Group<T, FI, SI, RI, N, R>

where T: Clone, FI: EachCrateIndividual<Item = T> + FitnessIndividualTrait, SI: EachCrateIndividual<Item = T> + SelectorIndividualTrait<R>, RI: EachCrateIndividual<Item = T> + ReplenisherIndividualTrait<N, R>,