Struct InteractiveGA 

pub struct InteractiveGA<G, S, C, M>
where
    G: EvolutionaryGenome,
{ /* private fields */ }

Step-based Interactive Genetic Algorithm

Unlike standard GA algorithms that run to completion, InteractiveGA yields control between evaluations, allowing the caller to interact with users.

Example

use fugue_evo::interactive::prelude::*;

let mut iga = InteractiveGABuilder::<MyGenome>::new()
    .population_size(12)
    .evaluation_mode(EvaluationMode::BatchSelection)
    .build()?;

let mut rng = rand::thread_rng();

loop {
    match iga.step(&mut rng) {
        StepResult::NeedsEvaluation(request) => {
            let response = get_user_feedback(&request);
            iga.provide_response(response);
        }
        StepResult::GenerationComplete { generation, .. } => {
            println!("Generation {} complete", generation);
        }
        StepResult::Complete(result) => {
            println!("Evolution complete: {}", result.termination_reason);
            break;
        }
    }
}

Implementations

impl<G, S, C, M> InteractiveGA<G, S, C, M>

where G: EvolutionaryGenome + Clone + Send + Sync, S: SelectionOperator<G>, C: CrossoverOperator<G>, M: MutationOperator<G>,

pub fn new( config: InteractiveGAConfig, bounds: Option<MultiBounds>, selection: S, crossover: C, mutation: M, ) -> Self

Create a new InteractiveGA

pub fn from_session( session: InteractiveSession<G>, config: InteractiveGAConfig, bounds: Option<MultiBounds>, selection: S, crossover: C, mutation: M, ) -> Self

Resume from a saved session

pub fn session(&self) -> &InteractiveSession<G>

Get the current session

pub fn session_mut(&mut self) -> &mut InteractiveSession<G>

Get mutable reference to session (for custom modifications)

pub fn config(&self) -> &InteractiveGAConfig

Get the configuration

pub fn coverage_stats(&self) -> CoverageStats

Get coverage statistics

pub fn provide_response(&mut self, response: EvaluationResponse)

Provide user response to an evaluation request

pub fn step<R: Rng>(&mut self, rng: &mut R) -> StepResult<G>

where G: Serialize + for<'de> Deserialize<'de>,

Advance the algorithm one step

pub fn terminate(&mut self, reason: &str)

Manually terminate the algorithm