Struct AntColonyReal 

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

Ant Colony Optimization (continuous domains).

The archive_size >= 2 (the σ computation needs at least two archive solutions to take a pairwise distance) and m >= 1 invariants are enforced by Validate::validate at the harness chokepoint.

Example

use burn::backend::Flex;
use rlevo_evolution::algorithms::metaheuristic::aco_r::{AcoRConfig, AntColonyReal};

let strategy = AntColonyReal::<Flex>::new();
let params = AcoRConfig::default_for(50, 10, 10);
let _ = (strategy, params);

Implementations

impl<B: Backend> AntColonyReal<B>

pub fn new() -> Self

Builds a new (stateless) strategy object.

Trait Implementations

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

fn clone(&self) -> AntColonyReal<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 AntColonyReal<B>

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

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

Formats the value using the given formatter.

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

fn default() -> AntColonyReal<B>

Returns the “default value” for a type.

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

where B::Device: Clone,

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

Initialises the archive by host-sampling archive_size × genome_dim values uniformly from params.bounds.

All random draws go through seed_stream derived from rng rather than B::seed + Tensor::random; this keeps draws reproducible across thread schedules when multiple tests or harnesses share the same process-wide Burn RNG state.

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

Proposes the next population.

First call (state.archive_fitness.is_empty()): returns the initial archive as-is so the harness scores it before any generation update occurs.

Subsequent calls: draws m offspring by, for each dimension d of each offspring i:

1. Selecting an archive index l by CDF-weighted roulette from state.weights (host-side, via seed_stream).
2. Computing σ_{l,d} = ξ · mean_e |archive_{e,d} − archive_{l,d}| on-device.
3. Sampling x_{i,d} ~ N(archive_{l,d}, σ_{l,d}) host-side via rand_distr::Normal and a second seed_stream.

Offspring are clamped to params.bounds before upload to the device. The returned state is the same object passed in (no mutation occurs in ask; all state changes are deferred to tell).

fn tell( &self, params: &AcoRConfig, population: Tensor<B, 2>, fitness: Tensor<B, 1>, state: AcoRState<B>, _rng: &mut dyn Rng, ) -> (AcoRState<B>, StrategyMetrics)

Merges population with the current archive and updates state.

First tell (state.archive_fitness.is_empty()): population is the initial archive returned verbatim by the first ask; this call sorts it by fitness and records best_genome and best_fitness.

Steady-state tell: concatenates state.archive (shape (k, D)) with population (shape (m, D)), sorts the combined k + m rows by fitness, and retains only the top k. Updates best_genome if the new archive leader improves on state.best_fitness.

Returns the updated state and a StrategyMetrics snapshot built from fitness (the offspring scores, not the full archive).

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

Returns the best genome seen across all generations, or None before the first tell call.

The returned tensor has shape (1, genome_dim).

type Params = AcoRConfig

Static parameters for a run.

type State = AcoRState<B>

Generation-to-generation state.

type Genome = Tensor<B, 2>

Genome container produced by ask.