Struct EngineProblem 

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

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 {
    codec: Arc::new(FloatCodec::vector(5, 0.0..1.0)),
    fitness_fn,
};

Thread Safety

This struct is marked as Send + Sync to ensure it can be safely shared across multiple threads during parallel fitness evaluation.

Performance Characteristics

• Individual Evaluation: Each individual is evaluated separately
• Memory Usage: Lower memory overhead per evaluation
• Flexibility: Easy to implement custom fitness logic
• Parallelization: Can utilize multiple threads through the executor

Fields

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

fitness_fn: Arc<dyn Fn(T) -> 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>) -> Score

Evaluates the fitness of a single individual.

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

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>