Enum LearningCurve 

pub enum LearningCurve {
    Saturating {
        asymptote: f64,
        rate: f64,
        floor: f64,
        noise: f64,
    },
    Table {
        points: Vec<(u64, f64)>,
    },
}

A synthetic learning curve: a deterministic value at each resource step.

Build one with a named constructor and read it with value_at. Every constructor is const-friendly data, and the value is a pure function of the step (and, for the noisy family, a seed), so a curve is trivially reproducible and cheap to evaluate inside the objective’s inner loop.

Variants

Saturating

The monotone-saturating trend floor + (asymptote − floor)·(1 − e^(−rate·t)), plus deterministic noise of amplitude noise (zero for a smooth curve).

rate controls how fast the curve approaches asymptote: large rate saturates almost immediately (a fast learner), small rate climbs slowly (a slow starter). With asymptote == floor the trend is flat at that level, which — with a non-zero noise — is a pure-noise curve.

Fields

asymptote: f64

The value the trend approaches as the step grows.

rate: f64

The saturation rate; larger climbs faster.

floor: f64

The value at step zero (the trend’s floor).

noise: f64

The amplitude of the deterministic wobble added to the trend.

Table

An explicit (step, value) table — the most knowable curve of all, for hand-verified oracle scenarios.

The points must be in ascending step order. A query lands on the value of the largest listed step that is <= step (a right-continuous step function); a query below the first listed step returns the first value; an empty table is NaN everywhere.

Fields

points: Vec<(u64, f64)>

The (step, value) knots, ascending by step.

Implementations

impl LearningCurve

pub const fn saturating(asymptote: f64, rate: f64) -> Self

A smooth monotone-saturating curve rising from 0 toward asymptote.

pub const fn noisy(asymptote: f64, rate: f64, noise: f64) -> Self

A saturating trend with a bounded deterministic wobble of amplitude noise (in the same units as the value).

pub const fn noisy_flat(level: f64, noise: f64) -> Self

A flat trend at level plus deterministic noise of amplitude noise.

A set of these with distinct per-trial seeds differs only by its noise — the fixture the variance-aware pruner must not prune.

pub const fn deceptive(plateau: f64) -> Self

The deceptive family: rises fast (high rate) to a low plateau.

Best early, mediocre late — the shape a myopic pruner is tempted to promote and a good one eventually catches once the late bloomers overtake it. A convenience wrapper over saturating.

pub const fn slow_starter(asymptote: f64) -> Self

The slow-starter family: rises slowly (low rate) to a high asymptote.

Worst early, best late — the trial a pruner must not cut so long as it is above the pruning bar at the rungs it passes.

pub fn table<I>(points: I) -> Self

where I: IntoIterator<Item = (u64, f64)>,

An explicit (step, value) table (see Table).

pub fn value_at(&self, step: u64, seed: u64) -> f64

The curve’s value at step, under the noise realization keyed by seed.

seed is consulted only by the noisy family; a smooth curve or a table ignores it, so its value depends on the step alone.

Trait Implementations

impl Clone for LearningCurve

fn clone(&self) -> LearningCurve

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LearningCurve

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

Formats the value using the given formatter.

impl PartialEq for LearningCurve

fn eq(&self, other: &LearningCurve) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for LearningCurve