Struct GenerationIndividual

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

An individual which has all functions of fitness, selector, and replenisher.

This is implmented FitnessIndividualTrait, SelectorIndividualTrait, and ReplenisherIndividualTrait.

Example

use std::{collections::{HashSet, HashMap}, rc::Rc};
use scarlet_queen_core::{Individual, EachCrateIndividual, FitnessIndividualTrait, SelectorIndividualTrait, ReplenisherIndividualTrait};
use scarlet_queen_fitness::ord::GeFitness;
use scarlet_queen_selector::TournamentSelectorIndividual;
use scarlet_queen_replenisher::TournamentReplenisherIndividual;
use scarlet_queen_generation::GenerationIndividual;

type IndividualFunction = GenerationIndividual::<u8, GeFitness<u8>, TournamentSelectorIndividual<u8, 8>, TournamentReplenisherIndividual<u8, 10, 8>, 10, 8>;
let x: IndividualFunction = IndividualFunction::new(&Rc::new(Individual::new(5)));
let y: IndividualFunction = IndividualFunction::new(&Rc::new(Individual::new(6)));
assert_eq!(x.get_value(), &5);
assert_eq!(x.fitness(&y), 0);

let mut group = vec![
    IndividualFunction::new(&Rc::new(Individual::new_with_id(0, 1))),
    IndividualFunction::new(&Rc::new(Individual::new_with_id(1, 2))),
    IndividualFunction::new(&Rc::new(Individual::new_with_id(2, 5))),
    IndividualFunction::new(&Rc::new(Individual::new_with_id(3, 9))),
    IndividualFunction::new(&Rc::new(Individual::new_with_id(4, 6))),
    IndividualFunction::new(&Rc::new(Individual::new_with_id(5, 13))),
    IndividualFunction::new(&Rc::new(Individual::new_with_id(6, 0))),
    IndividualFunction::new(&Rc::new(Individual::new_with_id(7, 7))),
    IndividualFunction::new(&Rc::new(Individual::new_with_id(8, 9))),
    IndividualFunction::new(&Rc::new(Individual::new_with_id(9, 11)))
];
let scores: HashMap<usize, usize> = <IndividualFunction as FitnessIndividualTrait>::fitness_group(&group);
assert_eq!(<IndividualFunction as FitnessIndividualTrait>::fitness_group(&group), vec![
    (0, 1),
    (1, 2),
    (2, 3),
    (3, 7),
    (4, 4),
    (5, 9),
    (6, 0),
    (7, 5),
    (8, 7),
    (9, 8),
].into_iter().collect::<HashMap<usize, usize>>());
group.sort_by_key(|v| scores.get(&v.get_id()).map(|&v| -(v as isize)));
assert_eq!(<IndividualFunction as SelectorIndividualTrait<8>>::selected_ids(&group, scores), Ok(vec![1, 2, 3, 4, 5, 7, 8, 9].into_iter().collect::<HashSet<usize>>()));
assert_eq!(<IndividualFunction as ReplenisherIndividualTrait<10, 8>>::replenish(&group), vec![13, 11]);

Implementations

impl<T, FI, SI, RI, const N: usize, const R: usize> GenerationIndividual<T, FI, SI, RI, N, R>

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

pub fn get_fitness_individual(&self) -> &FI

Get an individual which has methods about fitness. You can call those methods to self directly.

pub fn get_selector_individual(&self) -> &SI

Get an individual which has methods about selector. You can call those methods to self directly.

pub fn get_replenisher_individual(&self) -> &RI

Get an individual which has methods about replenisher. You can call those methods to self directly.

Trait Implementations

impl<T: Clone, FI, SI, RI, const N: usize, const R: usize> Clone for GenerationIndividual<T, FI, SI, RI, N, R>

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

fn clone(&self) -> GenerationIndividual<T, FI, SI, RI, N, R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

impl<T, FI, SI, RI, const N: usize, const R: usize> EachCrateIndividual for GenerationIndividual<T, FI, SI, RI, N, R>

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

type Item = T

fn new(individual: &Rc<Individual<T>>) -> Self

Make individual from base individual.

fn get_individual(&self) -> &Individual<T>

Get this individual.

fn get_id(&self) -> usize

Get an id of this individual.

fn get_value(&self) -> &Self::Item

Get a value of this individual.

impl<T, FI, SI, RI, const N: usize, const R: usize> FitnessIndividualTrait for GenerationIndividual<T, FI, SI, RI, N, R>

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

fn fitness(&self, other: &Self) -> usize

Calculate a fitness score to an other individual.

fn fitness_group<'a, G>(group: G) -> HashMap<usize, usize>

where G: IntoIterator<Item = &'a Self>, Self: 'a,

Calculate a fitness to a group.

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

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

fn eq(&self, other: &GenerationIndividual<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> ReplenisherIndividualTrait<N, R> for GenerationIndividual<T, FI, SI, RI, N, R>

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

fn replenish<'a, U>(group: U) -> Vec<T>

where U: IntoIterator<Item = &'a Self>, Self: 'a,

Return individuals replenishing a group with.

impl<T, FI, SI, RI, const N: usize, const R: usize> SelectorIndividualTrait<R> for GenerationIndividual<T, FI, SI, RI, N, R>

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

type Err = <SI as SelectorIndividualTrait<R>>::Err

An error of selector. This is occurred when bad scores are given to this.

fn selected_ids<'a, G>( group: G, score: HashMap<usize, usize>, ) -> Result<HashSet<usize>, Self::Err>

where G: IntoIterator<Item = &'a Self>, Self: 'a,

Select individuals. Return ids of selected individuals.

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

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

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

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