Struct EngineProblem 

pub struct EngineProblem<C, T>
where
    C: Chromosome,
{
    pub objective: Objective,
    pub codec: Arc<dyn Codec<C, T>>,
    pub fitness_fn: Option<Arc<dyn Fn(T) -> Score + Send + Sync>>,
    pub raw_fitness_fn: Option<Arc<dyn Fn(&Genotype<C>) -> Score + Send + Sync>>,
}

A standard implementation of the Problem trait for general use. EngineProblem is a generic, base level concrete implementation of the Problem trait that is the default problem used by the engine if none other is specified during building.

We take the Codec and the fitness function from the user and simply wrap them into this struct.

Generic Parameters

• C: The Chromosome type that represents the genetic material
• T: The phenotype type that represents the decoded individual

Examples

use radiate_core::*;
use std::sync::Arc;

// Create a simple fitness function
let fitness_fn = Arc::new(|phenotype: Vec<f32>| {
    Score::from(phenotype.iter().cloned().fold(0.0, f32::max))
});

let problem = EngineProblem {
    objective: Objective::Single(Optimize::Maximize),
    codec: Arc::new(FloatCodec::vector(5, 0.0..1.0)),
    fitness_fn: Some(fitness_fn),
    raw_fitness_fn: None,
};

Fields

objective: Objective

codec: Arc<dyn Codec<C, T>>

fitness_fn: Option<Arc<dyn Fn(T) -> Score + Send + Sync>>

raw_fitness_fn: Option<Arc<dyn Fn(&Genotype<C>) -> Score + Send + Sync>>

Trait Implementations

impl<C: Chromosome, T> Problem<C, T> for EngineProblem<C, T>

Implementation of Problem for EngineProblem.

This implementation delegates to the contained codec and fitness function, providing a clean separation of concerns between encoding/decoding logic and fitness evaluation.

fn encode(&self) -> Genotype<C>

Creates a new Genotype representing the initial state of the problem. The returned Genotype should represent a valid starting point for evolution.

fn decode(&self, genotype: &Genotype<C>) -> T

Converts a Genotype into its corresponding phenotype.

fn eval(&self, individual: &Genotype<C>) -> RadiateResult<Score>

Evaluates the fitness of a single individual.

fn eval_batch( &self, individuals: &[Genotype<C>], ) -> Result<Vec<Score>, RadiateError>

Evaluates the fitness of multiple individuals in a batch.

impl<C: Chromosome, T> Send for EngineProblem<C, T>

Mark EngineProblem as thread-safe for parallel execution.

This implementation is safe because:

• Arc<dyn Codec<C, T>> is Send + Sync when C and T are Send + Sync
• Arc<dyn Fn(T) -> Score + Send + Sync> is Send + Sync by construction
• The struct contains no interior mutability

impl<C: Chromosome, T> Sync for EngineProblem<C, T>