Struct Stepper 

pub struct Stepper<P, S, So> { /* private fields */ }

Drive a solver one iteration at a time.

Owns the problem, state, solver and termination criteria, runs solver.init exactly once on construction, and exposes step / run_to_end so callers can interleave their own work between iterations — recording trajectories, animating from a UI, pausing on a button press, evaluating a custom budget, etc.

Executor::run is self.into_stepper().run_to_end(); the stepper is the building block, the executor is the convenience wrapper.

Example

let mut stepper = Executor::new(problem, solver, state)
    .max_iter(100)
    .terminate_on(GradientTolerance(1e-6))
    .into_stepper();

let reason = loop {
    match stepper.step() {
        StepOutcome::Continue => { /* observe `stepper.state()` */ }
        StepOutcome::Stopped(reason) => break reason,
    }
};

Implementations

impl<P, S, So> Stepper<P, S, So>

where S: State, So: Solver<P, S>,

pub fn state(&self) -> &S

Read-only access to the current state, between steps.

pub fn finished(&self) -> Option<&TerminationReason>

Termination reason if the stepper has stopped, else None.

pub fn iter(&self) -> u64

Total iterations that have completed so far. Convenience read equivalent to self.state().iter().

pub fn step(&mut self) -> StepOutcome

Advance one iteration. Once a Stopped outcome has been returned the stepper is sticky: subsequent calls keep returning the same Stopped(reason) without touching the state or solver.

pub fn run_to_end(self) -> OptimizationResult<S>

Drive step to completion and return an OptimizationResult.

pub fn into_state(self) -> S

Consume the stepper and return the final state.