Struct GepStrategy 

pub struct GepStrategy<B: Backend, F: FunctionSet> { /* private fields */ }

Gene Expression Programming as a generational Strategy.

The genome is a Tensor<B, 2, Int> of shape (pop_size, head_len + tail_len). Selection is roulette-wheel (fitness-proportionate) with elitism, following Ferreira (2001): the best-so-far individual is copied unchanged into every new generation, while the rest are produced by roulette selection followed by crossover, transposition, and locus-class point mutation. All randomness is host-side via seed_stream; each operator draws from its own SeedPurpose stream.

Decoding and phenotype evaluation are not part of the strategy — they live in the BatchFitnessFn (see GepSymRegression), keeping the ask/tell loop free of program interpretation.

Implementations

impl<B: Backend, F: FunctionSet> GepStrategy<B, F>

pub fn new(alphabet: Alphabet<F>) -> Self

Builds a strategy over the given symbol alphabet.

pub fn alphabet(&self) -> &Alphabet<F>

The alphabet this strategy samples and decodes against.

Trait Implementations

impl<B: Clone + Backend, F: Clone + FunctionSet> Clone for GepStrategy<B, F>

fn clone(&self) -> GepStrategy<B, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug + Backend, F: Debug + FunctionSet> Debug for GepStrategy<B, F>

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

Formats the value using the given formatter.

impl<B: Backend, F: FunctionSet> Strategy<B> for GepStrategy<B, F>

where B::Device: Clone,

fn init( &self, params: &GepConfig, rng: &mut dyn Rng, device: &<B as BackendTypes>::Device, ) -> GepState<B>

Samples the initial population: each chromosome’s head loci hold any symbol and its tail loci hold terminals, so every individual is valid by construction.

fn ask( &self, params: &GepConfig, state: &GepState<B>, rng: &mut dyn Rng, device: &<B as BackendTypes>::Device, ) -> (Tensor<B, 2, Int>, GepState<B>)

Returns the population to evaluate this generation.

On the first call (no fitness cached yet) the initial population is returned unchanged. On subsequent calls a new generation is bred from the current one: roulette selection, then one-/two-point crossover, IS/RIS transposition, and locus-class point mutation, with the best-so-far individual copied into row 0 (elitism). Each operator draws from its own SeedPurpose stream off a single base seed.

fn tell( &self, _params: &GepConfig, population: Tensor<B, 2, Int>, fitness: Tensor<B, 1>, state: GepState<B>, _rng: &mut dyn Rng, ) -> (GepState<B>, StrategyMetrics)

Caches the evaluated population and its fitness, then updates the best-so-far record. The returned population becomes the current generation that the next ask breeds from.

type Params = GepConfig

Static parameters for a run.

type State = GepState<B>

Generation-to-generation state.

type Genome = Tensor<B, 2, Int>

Genome container produced by ask.

fn best(&self, state: &GepState<B>) -> Option<(Tensor<B, 2, Int>, f32)>

Best-so-far accessor.