Struct ScalarGradientState 

pub struct ScalarGradientState<F = f64> { /* private fields */ }

State for one-dimensional solvers that carry a first derivative (BrentDerivative): a scalar param, an optional cached cost, an optional cached gradient f'(x), and cost/gradient evaluation counters. Param and Float are the same scalar F.

It is the gradient-carrying sibling of ScalarState: same scalar single-iterate shape, but it does impl GradientState (its gradient is the scalar f'(x)), so first-order termination criteria such as GradientTolerance work on a 1D solver — the natural “stop when |f'(x)| ≤ tol” test. A scalar gradient satisfies the criteria’s norm bounds directly (f64::norm_squared() is f' · f').

best_param tracks the lowest-cost probe, which for a bracketing search can differ from the final iterate.

The scalar F defaults to f64 so ScalarGradientState call sites resolve unchanged.

Implementations

impl<F: Scalar> ScalarGradientState<F>

pub fn new(param: F) -> Self

Build a state at the given starting point. The cost and gradient are filled in by Solver::init.

Trait Implementations

impl<F> CountsMirror for ScalarGradientState<F>

where ScalarGradientState<F>: State,

fn mirror(&mut self, delta: &EvalCounts)

Overwrite the state’s counters from the per-run wrapper delta. Called by the executor after every successful Solver::init / Solver::next_iter.

impl<F: Scalar> GradientState for ScalarGradientState<F>

fn gradient(&self) -> Option<&F>

Gradient at the current param, if populated.

fn gradient_evals(&self) -> u64

Cumulative count of gradient evaluations performed so far. Lives on GradientState rather than State so derivative-free states don’t carry a counter they can never increment.

fn best_gradient_evals(&self) -> u64

Cumulative gradient evaluations at the moment the current best was found — companion to State::best_cost_evals. Useful for benchmarking first-order solvers (“how many gradient calls until the solver hit its best?”).

impl<P, F> Solver<P, ScalarGradientState<F>> for BrentDerivative<F>

where F: Scalar, P: CostFunction<Param = F, Output = F> + Gradient<Gradient = F> + BoxConstraints,

type Error = <P as CostFunction>::Error

Hard-abort error type — mirrors the underlying problem’s type Error. See the trait docs.

fn init( &mut self, problem: &mut Problem<P>, state: ScalarGradientState<F>, ) -> Result<ScalarGradientState<F>, Self::Error>

One-time setup before the iteration loop.

fn next_iter( &mut self, problem: &mut Problem<P>, state: ScalarGradientState<F>, ) -> Result<(ScalarGradientState<F>, Option<TerminationReason>), Self::Error>

Advance one iteration.

fn terminate( &self, _state: &ScalarGradientState<F>, ) -> Option<TerminationReason>

Optional pre-iteration solver-specific termination test.

impl<F: Scalar> State for ScalarGradientState<F>

fn cost(&self) -> F

Reads the cost cached at the current param.

Panics

Panics if accessed before Solver::init has populated the cached cost. By contract, Executor calls init before any termination-criterion check, so reads from inside criteria and from OptimizationResult are safe.

type Param = F

The parameter type the solver iterates over (e.g. Vec<f64>, nalgebra::DVector<f64>).

type Float = F

The scalar type of the objective. In practice always f64 (see the module docs).

fn iter(&self) -> u64

Number of fully completed iterations. A Solver::next_iter that bails mid-iteration with Some(reason) does not increment this counter — see the executor module for the exact ordering.

fn increment_iter(&mut self)

Increment iter by one. Called by the executor after a successful Solver::next_iter.

fn cost_evals(&self) -> u64

Cumulative count of cost-function evaluations performed so far. Diverges from iter() whenever a single iteration evaluates the cost more than once (line searches, Nelder-Mead shrinks, etc.) — this is what users actually budget against.

fn param(&self) -> &F

Current iterate. Stable between Solver::next_iter calls; safe to read at any iteration including iter 0.

fn best_param(&self) -> &F

Best param ever observed by the executor’s best-tracking on this state.

fn best_cost(&self) -> F

Cost at best_param — the lowest cost ever observed on this state.

fn best_iter(&self) -> u64

Iteration at which the current best was found. 0 before the first update_best call; thereafter, the value of iter at the moment of the last strict improvement in best_cost().

fn best_cost_evals(&self) -> u64

Cumulative cost evaluations at the moment the current best was found — useful for benchmarking (“how many evals until the solver hit its best?”).

fn update_best(&mut self)

Refresh the best-so-far slots from the current iterate, if cost strictly improves on best_cost.

fn reset_best(&mut self)

Reset the best-so-far slots to their pre-init defaults (best_cost = +∞, all best counters zero).