Struct Iterative 

pub struct Iterative<E>
where
    E: IterativeEval,
{
    eval: E,
    initial: <E as IterativeEval>::Output,
    sim_step: f64,
    snapshot: RefCell<Snapshot<<E as IterativeEval>::Output>>,
}

Adapter turning an IterativeEval into the general Eval protocol.

The adapter owns the segment’s definition — the initial state, the sim_step, and the stepping closure — all immutable. The only mutation is the snapshot cache (alpha + state) behind a RefCell, so eval_alpha(target) integrates to target only when target is ahead of the snapshot, resets and replays when behind, and otherwise returns the cached state directly. Repeated queries at the same alpha are O(1).

let sim_secs = 10.0;
let animation = Iterative::from_fn(state0, move |state, _alpha, delta_alpha| {
    state.integrate(sim_secs * delta_alpha);
})
.with_steps(240)
.with_duration(sim_secs);

Fields

eval: E

initial: <E as IterativeEval>::Output

sim_step: f64

snapshot: RefCell<Snapshot<<E as IterativeEval>::Output>>

Implementations

impl<E> Iterative<E>

where E: IterativeEval, <E as IterativeEval>::Output: Clone,

pub fn new(initial: <E as IterativeEval>::Output, eval: E) -> Iterative<E>

Create an iterative segment from an initial state and a named IterativeEval implementation.

The content step defaults to 1 / 120 of normalized progress. Call with_steps to override it, e.g. .with_steps(240) for 1 / 240 progress increments.

pub fn with_steps(self, n: usize) -> Iterative<E>

Declare the content’s step count N.

The segment then integrates in uniform 1 / N progress increments, so every IterativeEval::step call receives delta_alpha = 1 / N. Without this call the default is 1 / 120 (DEFAULT_SIM_STEP).

This is the segment’s content resolution, not the render sampling rate and not the scene clock. A physical time step can be recovered as duration_secs * delta_alpha.

Iterative::from_fn(initial_state, step_function)
    .with_steps(240) // 1/240 progress per integration step
    .with_duration(10.0); // => 1/24 seconds per integration step

impl<S, F> Iterative<IterativeFn<S, F>>

where S: Clone, F: Fn(&mut S, f64, f64),

pub fn from_fn(initial: S, eval: F) -> Iterative<IterativeFn<S, F>>

Create an iterative segment from an initial state and a stepping function.

Uses the default 1 / 120 content step; call with_steps to choose another resolution.

Trait Implementations

impl<E> Eval for Iterative<E>

where E: IterativeEval, <E as IterativeEval>::Output: Clone,

type Output = <E as IterativeEval>::Output

Value produced by this evaluator.

fn sim_step(&self) -> Option<f64>

The content resolution declared by iterative segments: 1/N progress per integration step (N declared via Iterative::with_steps).

fn eval_alpha(&self, target: f64) -> <Iterative<E> as Eval>::Output

Evaluate the segment’s content at normalized progress alpha.