Struct Candidate 

pub struct Candidate<G>
where
    G: EvolutionaryGenome,
{
    pub id: CandidateId,
    pub genome: G,
    pub fitness_estimate: Option<f64>,
    pub fitness_with_uncertainty: Option<FitnessEstimate>,
    pub birth_generation: usize,
    pub evaluation_count: usize,
}

A candidate presented for user evaluation

Wraps a genome with its unique identifier and current fitness estimate. The fitness estimate is updated as user feedback is received and aggregated.

Fields

id: CandidateId

Unique identifier for this candidate

genome: G

The genome of this candidate

fitness_estimate: Option<f64>

Current fitness estimate (updated as feedback arrives)

fitness_with_uncertainty: Option<FitnessEstimate>

Full fitness estimate with uncertainty quantification

birth_generation: usize

Generation when this candidate was created

evaluation_count: usize

Number of times this candidate has been evaluated

Implementations

impl<G> Candidate<G>

where G: EvolutionaryGenome,

pub fn new(id: CandidateId, genome: G) -> Self

Create a new candidate with the given ID and genome

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

Create a new candidate with birth generation

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

Set the fitness estimate (point estimate only)

pub fn set_fitness_with_uncertainty(&mut self, estimate: FitnessEstimate)

Set the full fitness estimate with uncertainty

pub fn fitness(&self) -> Option<f64>

Get the fitness estimate (point estimate), if available

pub fn fitness_uncertainty(&self) -> Option<&FitnessEstimate>

Get the full fitness estimate with uncertainty, if available

pub fn fitness_variance(&self) -> Option<f64>

Get the variance of the fitness estimate, if available

pub fn is_evaluated(&self) -> bool

Check if this candidate has been evaluated at least once

pub fn record_evaluation(&mut self)

Increment the evaluation count

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

Get the age of this candidate (generations since birth)

pub fn is_uncertain(&self, min_observations: usize) -> bool

Check if this candidate has high uncertainty (needs more evaluation)

Returns true if variance is infinite or observation count is below threshold.

Trait Implementations

impl<G> Clone for Candidate<G>

where G: EvolutionaryGenome + Clone,

fn clone(&self) -> Candidate<G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G> Debug for Candidate<G>

where G: EvolutionaryGenome + Debug,

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

Formats the value using the given formatter.

impl<'de, G> Deserialize<'de> for Candidate<G>

where G: EvolutionaryGenome + Serialize + for<'a> Deserialize<'a>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<G> Hash for Candidate<G>

where G: EvolutionaryGenome,

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

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<G> PartialEq for Candidate<G>

where G: EvolutionaryGenome,

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

where G: EvolutionaryGenome + Serialize + for<'a> Deserialize<'a>,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<G> Eq for Candidate<G>

where G: EvolutionaryGenome,