Struct CuckooSearch 

pub struct CuckooSearch<B: Backend> { /* private fields */ }

Cuckoo Search strategy.

Example

use burn::backend::Flex;
use rlevo_evolution::algorithms::metaheuristic::cuckoo::{CuckooConfig, CuckooSearch};

let strategy = CuckooSearch::<Flex>::new();
let params = CuckooConfig::default_for(30, 10);
let _ = (strategy, params);

Implementations

impl<B: Backend> CuckooSearch<B>

pub fn new() -> Self

Builds a new (stateless) strategy object.

Trait Implementations

impl<B: Clone + Backend> Clone for CuckooSearch<B>

fn clone(&self) -> CuckooSearch<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Copy + Backend> Copy for CuckooSearch<B>

impl<B: Debug + Backend> Debug for CuckooSearch<B>

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

Formats the value using the given formatter.

impl<B: Default + Backend> Default for CuckooSearch<B>

fn default() -> CuckooSearch<B>

Returns the “default value” for a type.

impl<B: Backend> Strategy<B> for CuckooSearch<B>

where B::Device: Clone,

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

Build the initial nest population by host-sampling pop_size positions uniformly in [bounds.lo, bounds.hi].

The fitness field is left empty so the first ask → tell pair bootstraps the fitness cache before any greedy acceptance or abandonment logic runs. Positions are drawn from a deterministic seed_stream; the process-wide Flex RNG is never touched.

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

Propose new egg positions via Mantegna’s Lévy-stable step.

On the first call (state.fitness is empty) returns the initial nests unchanged so the caller can evaluate generation zero.

On subsequent calls, samples u ∼ N(0, σ_u²) and v ∼ N(0, 1) host-side from a deterministic seed_stream, then forms step = u / |v|^(1/β) and proposes x'_i = x_i + α · step, clipped to params.bounds.

fn tell( &self, params: &CuckooConfig, population: Tensor<B, 2>, fitness: Tensor<B, 1>, state: CuckooState<B>, rng: &mut dyn Rng, ) -> (CuckooState<B>, StrategyMetrics)

Ingest egg fitness values, apply greedy per-slot acceptance, abandon the worst nests, and advance the generation counter.

On the first call (generation zero bootstrap) all eggs are unconditionally accepted and nest abandonment is skipped.

On subsequent calls:

1. Greedy accept — egg i replaces nest i iff fitness[i] ≤ state.fitness[i].
2. Abandonment — the ⌊p_a · pop_size⌋ worst nests are re-initialized from bounds via seed_stream; abandoned slots carry sentinel +∞ fitness so the next generation’s Lévy proposal always lands on them.

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

Returns the best-so-far (genome, fitness) pair, or None before the first tell call.

type Params = CuckooConfig

Static parameters for a run.

type State = CuckooState<B>

Generation-to-generation state.

type Genome = Tensor<B, 2>

Genome container produced by ask.