Struct Individual 

pub struct Individual<G, F = f64>
where
    G: EvolutionaryGenome,
    F: FitnessValue,
{
    pub genome: G,
    pub fitness: Option<F>,
    pub birth_generation: usize,
    pub offspring_count: usize,
}

An individual in the population

Wraps a genome with its computed fitness value and additional metadata.

Fields

genome: G

The genome of this individual

fitness: Option<F>

The fitness value (None if not yet evaluated)

birth_generation: usize

Generation when this individual was created

offspring_count: usize

Number of offspring produced by this individual

Implementations

impl<G, F> Individual<G, F>

where G: EvolutionaryGenome, F: FitnessValue,

pub fn new(genome: G) -> Self

Create a new individual with an unevaluated genome

pub fn with_fitness(genome: G, fitness: F) -> Self

Create a new individual with a known fitness

pub fn with_generation(genome: G, generation: usize) -> Self

Create a new individual with birth generation

pub fn is_evaluated(&self) -> bool

Check if this individual has been evaluated

pub fn fitness_value(&self) -> &F

Get the fitness value, panicking if not evaluated

pub fn fitness_f64(&self) -> f64

Get the fitness as f64

pub fn set_fitness(&mut self, fitness: F)

Set the fitness value

Panics

Panics if the fitness is non-finite (NaN). A NaN fitness is always a bug in the fitness function (e.g. a division by zero or log of a negative number) and silently corrupts every downstream comparison (best/worst/sort_by_fitness), so it is rejected at the source rather than propagated (EV-07). Infinities are permitted (e.g. ParetoFitness uses +inf crowding distances).

pub fn into_genome(self) -> G

Take the genome out of this individual

pub fn genome(&self) -> &G

Get a reference to the genome

pub fn genome_mut(&mut self) -> &mut G

Get a mutable reference to the genome

Mutating the genome invalidates any cached fitness (EV-28): the stored value was computed for the previous genome, so this clears self.fitness and resets the evaluated flag. Callers that only need read access should use genome to preserve the cache.

Note: the genome field is public for backwards compatibility; direct assignment (individual.genome = ...) bypasses this invalidation, so prefer genome_mut or set_genome.

pub fn set_genome(&mut self, genome: G)

Replace the genome, clearing any cached fitness

Like genome_mut, this invalidates the cached fitness so the new genome is re-evaluated (EV-28).

pub fn is_better_than(&self, other: &Self) -> bool

Check if this individual is better than another

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

Age of this individual (generations since birth)

Trait Implementations

impl<G, F> Clone for Individual<G, F>

where G: EvolutionaryGenome + Clone, F: FitnessValue + Clone,

fn clone(&self) -> Individual<G, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G, F> Debug for Individual<G, F>

where G: EvolutionaryGenome + Debug, F: FitnessValue + Debug,

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

Formats the value using the given formatter.

impl<'de, G, F> Deserialize<'de> for Individual<G, F>

where G: EvolutionaryGenome, F: FitnessValue,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<G, F> FromIterator<Individual<G, F>> for Population<G, F>

where G: EvolutionaryGenome, F: FitnessValue,

fn from_iter<I: IntoIterator<Item = Individual<G, F>>>(iter: I) -> Self

Creates a value from an iterator.

impl<G, F> PartialEq for Individual<G, F>

where G: EvolutionaryGenome + PartialEq, F: FitnessValue + PartialEq,

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<G, F> PartialOrd for Individual<G, F>

where G: EvolutionaryGenome + PartialEq, F: FitnessValue + PartialEq,

fn partial_cmp(&self, other: &Self) -> 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<G, F> Serialize for Individual<G, F>

where G: EvolutionaryGenome, F: FitnessValue,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.