Struct BatchEngineProblem 

pub struct BatchEngineProblem<C, T>
where
    C: Chromosome,
{
    pub codec: Arc<dyn Codec<C, T>>,
    pub batch_fitness_fn: Arc<dyn Fn(&[T]) -> Vec<Score> + Send + Sync>,
}

A specialized implementation of the Problem trait optimized for batch evaluation.

BatchEngineProblem is designed for problems where batch fitness evaluation is significantly more efficient than individual evaluation. It uses a batch fitness function that can process multiple phenotypes at once, potentially leveraging vectorization, shared computations, or parallel processing.

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 batch_fitness_fn = Arc::new(|phenotypes: &[Vec<f32>]| {
    phenotypes.iter().map(|p| {
        Score::from(p.iter().cloned().fold(0.0, f32::max))
    }).collect()
});

let problem = BatchEngineProblem {
    codec: Arc::new(FloatCodec::vector(5, 0.0..1.0)),
    batch_fitness_fn,
};

Use Cases

Use BatchEngineProblem when:

• Your fitness function can benefit from vectorization
• There are shared computations between multiple individuals
• The problem domain supports efficient batch processing
• You’re evaluating large populations where batch overhead is amortized
• You need parts or the whole of a population to be evaluated together

Fields

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

batch_fitness_fn: Arc<dyn Fn(&[T]) -> Vec<Score> + Send + Sync>

Trait Implementations

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

Implementation of Problem for BatchEngineProblem.

This implementation provides both individual and batch evaluation methods. The individual evaluation method (eval) is implemented by wrapping the phenotype in a single-element slice and calling the batch function, then extracting the first result. This ensures consistency between individual and batch evaluation while maintaining the benefits of batch processing.

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 BatchEngineProblem<C, T>

Mark BatchEngineProblem 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]) -> Vec<Score> + Send + Sync> is Send + Sync by construction
• The struct contains no interior mutability
• Batch operations are designed to be thread-safe

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