Struct Population 

pub struct Population<C>
where
    C: Chromosome,
{ /* private fields */ }

A Population is a collection of Phenotype instances.

This struct is the core collection of individuals being evolved by the GeneticEngine. It can be thought of as a Vec of Phenotypes and is essentially a light wrapper around such a Vec. The Population struct, however, has some additional functionality that allows for sorting and iteration over the individuals in the population.

Note: Although the Population offers mut methods to mut the individuals in the population, the Population itself offers no way to increase or decrease the number of individuals in the population. As such, the Population should be thought of as an ‘immutable’ data structure. If you need to add or remove individuals from the population, you should create a new Population instance with the new individuals. To further facilitate this way of thinking, the Population struct and everything it contains implements the Clone trait.

Note

A raw call to clone of the population will NOT clone the individuals themselves, but rather the references to them. This means that if you mutate an individual in one population, the change will be reflected in the other population as well. To deep clone a population, you must clone each individual within it. The simplest way to do this is by:

let deep_cloned_population = Population::from(&original_population);

Type Parameters

• C: The type of chromosome used in the genotype, which must implement the Chromosome trait.

Implementations

impl<C> Population<C>

where C: Chromosome,

pub fn new(individuals: Vec<Phenotype<C>>) -> Population<C>

pub fn members(&self) -> &[Member<C>]

pub fn get(&self, index: usize) -> Option<&Phenotype<C>>

pub fn get_mut(&mut self, index: usize) -> Option<&mut Phenotype<C>>

pub fn get_cell_mut(&mut self, index: usize) -> Option<&mut Member<C>>

pub fn get_cell(&self, index: usize) -> Option<&Member<C>>

pub fn push(&mut self, individual: impl Into<Member<C>>)

pub fn iter(&self) -> impl Iterator<Item = &Phenotype<C>>

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Phenotype<C>>

pub fn len(&self) -> usize

pub fn clear(&mut self)

pub fn is_empty(&self) -> bool

pub fn get_scores(&self) -> Vec<&Score>

pub fn get_pair_mut( &mut self, first: usize, second: usize, ) -> Option<(&mut Phenotype<C>, &mut Phenotype<C>)>

Trait Implementations

impl<C> AsMut<[Member<C>]> for Population<C>

where C: Chromosome,

fn as_mut(&mut self) -> &mut [Member<C>]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C> AsRef<[Member<C>]> for Population<C>

where C: Chromosome,

fn as_ref(&self) -> &[Member<C>]

Converts this type into a shared reference of the (usually inferred) input type.

impl<C> Clone for Population<C>

where C: Clone + Chromosome,

fn clone(&self) -> Population<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Debug for Population<C>

where C: Chromosome + Debug,

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

Formats the value using the given formatter.

impl<C> Default for Population<C>

where C: Default + Chromosome,

fn default() -> Population<C>

Returns the “default value” for a type.

impl<C> From<&Population<C>> for Population<C>

where C: Chromosome + Clone,

fn from(population: &Population<C>) -> Population<C>

Converts to this type from the input type.

impl<C, F> From<(usize, F)> for Population<C>

where C: Chromosome, F: Fn() -> Phenotype<C>,

Create a new instance of the Population from the given size and closure. This will iterate the given closure size times and collect the results into a Vec of new individuals.

fn from(_: (usize, F)) -> Population<C>

Converts to this type from the input type.

impl<C> From<Vec<Member<C>>> for Population<C>

where C: Chromosome,

fn from(individuals: Vec<Member<C>>) -> Population<C>

Converts to this type from the input type.

impl<C> From<Vec<Phenotype<C>>> for Population<C>

where C: Chromosome,

fn from(individuals: Vec<Phenotype<C>>) -> Population<C>

Converts to this type from the input type.

impl<C> FromIterator<Member<C>> for Population<C>

where C: Chromosome,

fn from_iter<I>(iter: I) -> Population<C>

where I: IntoIterator<Item = Member<C>>,

Creates a value from an iterator.

impl<C> FromIterator<Phenotype<C>> for Population<C>

where C: Chromosome,

fn from_iter<I>(iter: I) -> Population<C>

where I: IntoIterator<Item = Phenotype<C>>,

Creates a value from an iterator.

impl<C> Index<Range<usize>> for Population<C>

where C: Chromosome,

type Output = [Member<C>]

The returned type after indexing.

fn index( &self, index: Range<usize>, ) -> &<Population<C> as Index<Range<usize>>>::Output

Performs the indexing (container[index]) operation.

impl<C> Index<usize> for Population<C>

where C: Chromosome,

type Output = Phenotype<C>

The returned type after indexing.

fn index(&self, index: usize) -> &<Population<C> as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl<C> IndexMut<usize> for Population<C>

where C: Chromosome,

fn index_mut( &mut self, index: usize, ) -> &mut <Population<C> as Index<usize>>::Output

Performs the mutable indexing (container[index]) operation.

impl<C> IntoIterator for Population<C>

where C: Chromosome + Clone,

type Item = Phenotype<C>

The type of the elements being iterated over.

type IntoIter = IntoIter<Phenotype<C>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Population<C> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<C> PartialEq for Population<C>

where C: PartialEq + Chromosome,

fn eq(&self, other: &Population<C>) -> 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<C> StructuralPartialEq for Population<C>

where C: Chromosome,