Struct RungLadder 

pub struct RungLadder { /* private fields */ }

A geometric ladder of resource levels a successive-halving scheduler gates trials at.

The rungs are min_resource · reduction_factorⁱ for i = 0, 1, … while the level stays strictly below max_resource — a trial that reaches max_resource has finished and needs no promotion decision, and gating it there would replace its true objective value with a mid-run report. A ladder whose min_resource == max_resource therefore has no rungs at all: there is no fidelity to trade, so nothing is ever pruned (a clean degenerate case, not an error).

use atune_core::scheduler::RungLadder;

// η = 3, from 1 up to 27: gating rungs are 1, 3, 9 (27 is the finish line).
let ladder = RungLadder::new(1, 27, 3)?;
assert_eq!(ladder.rungs(), [1, 3, 9]);
assert_eq!(ladder.rung_at_step(9), Some(2));
assert_eq!(ladder.rung_at_step(5), None); // between rungs
assert_eq!(ladder.rung_at_step(27), None); // the finish line is not a rung

Implementations

impl RungLadder

pub fn new( min_resource: u64, max_resource: u64, reduction_factor: u32, ) -> Result<Self>

Builds the ladder for (min_resource, max_resource, reduction_factor).

Errors

Error::InvalidSpace if min_resource is 0, if max_resource < min_resource, or if reduction_factor < MIN_REDUCTION_FACTOR — none of which describe a usable ladder, and each of which is reported rather than clamped so the caller learns its schedule was nonsense.

pub fn rungs(&self) -> &[u64]

The gating resource levels, ascending.

pub const fn min_resource(&self) -> u64

The first rung’s resource level.

pub const fn max_resource(&self) -> u64

The finish line — the resource a promoted trial runs to.

pub const fn reduction_factor(&self) -> u32

The geometric factor between consecutive rungs.

pub fn len(&self) -> usize

The number of gating rungs.

pub fn is_empty(&self) -> bool

true when there is nothing to gate — the single-fidelity degenerate case min_resource == max_resource.

pub fn rung_at_step(&self, step: u64) -> Option<usize>

The index of the rung a report at step lands exactly on, if any.

A promotion decision is made only at a report whose step equals a rung level, so that the value being judged is the trial’s value at that resource — the same resource every competitor is judged at. A report between rungs (or at the finish line max_resource) returns None and is not gated. A trial whose reporting cadence never lands on a rung level is simply never gated at it — a safe omission (it is never wrongly pruned), documented on AshaPruner.

pub fn resource_at(&self, index: usize) -> Option<u64>

The resource level of rung index, if it exists.

Trait Implementations

impl Clone for RungLadder

fn clone(&self) -> RungLadder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RungLadder

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RungLadder

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RungLadder

impl PartialEq for RungLadder

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RungLadder

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RungLadder