Struct Phenotype 

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

A Phenotype is a representation of an individual in the population. It contains:

• Genotype - the genetic representation of the individual
• Score - the score (fitness) of the individual as calculated by the fitness function
• Generation - the generation in which the individual was created
• id - a unique identifier for the Phenotype

The Phenotype is a wrapper around the Genotype that adds additional information about the individual. In traditional (biological) genetics, a phenotype is “the set of observable characteristics of an individual resulting from the interaction of its genotype with the environment”. As such, the Phenotype is the ‘observable’ part of the individual (Genotype) that is being evolved by the genetic algorithm, hence the Score and generation fields. This allows the Phenotype to be sorted and compared based on the fitness (Score) of the individual (Genotype)

Type Parameters

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

Implementations

impl<C> Phenotype<C>

where C: Chromosome,

pub fn genotype(&self) -> &Genotype<C>

pub fn genotype_mut(&mut self) -> &mut Genotype<C>

pub fn take_genotype(&mut self) -> Result<Genotype<C>, RadiateError>

pub fn set_genotype(&mut self, genotype: Genotype<C>)

pub fn set_score(&mut self, score: Option<Score>)

pub fn generation(&self) -> usize

pub fn score(&self) -> Option<&Score>

pub fn id(&self) -> PhenotypeId

pub fn family(&self) -> FamilyId

pub fn invalidate(&mut self, generation: usize)

pub fn age(&self, generation: usize) -> usize

Get the age of the individual in generations. The age is calculated as the difference between the given generation and the generation in which the individual was created.

Trait Implementations

impl<C> AsRef<[f32]> for Phenotype<C>

where C: Chromosome,

Implement the AsRef<[f32]> trait for the Phenotype. This allows the Phenotype to be converted to a slice of f32 which will be the Score of the Phenotype. This is used when adding a Phenotype to a pareto Front for sorting.

fn as_ref(&self) -> &[f32]

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

impl<C> Clone for Phenotype<C>

where C: Clone + Chromosome,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Debug for Phenotype<C>

where C: Debug + Chromosome,

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

Formats the value using the given formatter.

impl<C> Distance<Phenotype<C>> for DistanceDiversityAdapter<C>

where C: Chromosome,

fn distance(&self, one: &Phenotype<C>, two: &Phenotype<C>) -> f32

impl<C> From<(Genotype<C>, usize)> for Phenotype<C>

where C: Chromosome,

fn from(_: (Genotype<C>, usize)) -> Phenotype<C>

Converts to this type from the input type.

impl<C> From<(Vec<C>, usize)> for Phenotype<C>

where C: Chromosome,

This is a convenience method that allows you to create a Phenotype from a list of Chromosomes. Without it, we end up needing to create a list of Gene’s then a list of Chromosomes then a Genotype, it’s just a lot. This method allows you to create a Phenotype from a list of chromosomes directly.

fn from(_: (Vec<C>, usize)) -> Phenotype<C>

Converts to this type from the input type.

impl<C> From<Genotype<C>> for Phenotype<C>

where C: Chromosome,

fn from(genotype: Genotype<C>) -> Phenotype<C>

Converts to this type from the input type.

impl<C> From<Phenotype<C>> for Member<C>

where C: Chromosome,

fn from(p: Phenotype<C>) -> Member<C>

Converts to this type from the input type.

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> Hash for Phenotype<C>

where C: Chromosome,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<C> PartialEq for Phenotype<C>

where C: PartialEq + Chromosome,

fn eq(&self, other: &Phenotype<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> PartialOrd for Phenotype<C>

where C: Chromosome + PartialEq,

Implement the PartialOrd trait for the Phenotype. This allows the Phenotype to be compared with other Phenotype instances. The comparison is based on the Score (fitness) of the Phenotype.

fn partial_cmp(&self, other: &Phenotype<C>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<C> Scored for Phenotype<C>

where C: Chromosome,

fn score(&self) -> Option<&Score>

impl<C> Valid for Phenotype<C>

where C: Chromosome,

Implement the Valid trait for the Phenotype. This allows the Phenotype to be checked for validity. A Phenotype is valid if the Genotype is valid. The GeneticEngine checks the validity of the Phenotype and will remove any invalid individuals from the population, replacing them with new individuals at the given generation.

fn is_valid(&self) -> bool

impl<C> Eq for Phenotype<C>

where C: Chromosome + PartialEq,

impl<C> StructuralPartialEq for Phenotype<C>

where C: Chromosome,