Struct SolisWetsState 

pub struct SolisWetsState<V, F = f64> { /* private fields */ }

Solver state for SolisWets.

Construct with new (bias b = 0, zeroed streak counters). The solver evaluates the start point’s cost once in Solver::init.

The Solis-Wets iteration only ever accepts improvements, so the current iterate is also the best evaluated point: State::param/State::cost and State::best_param/State::best_cost coincide at all times.

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

Implementations

impl<V, F> SolisWetsState<V, F>

where V: Clone + VectorLen + ScaleInPlace<F>, F: Scalar,

pub fn new(x: V, rho: F) -> Self

Build an initial Solis-Wets state at x with step size rho. The bias starts at 0 and both streak counters at zero; the solver evaluates f(x) in Solver::init.

Panics

Panics if rho ≤ 0 or x is empty.

impl<V, F: Scalar> SolisWetsState<V, F>

pub fn rho(&self) -> F

The current step size ρ (per-coordinate standard deviation of the sampling noise). Same value the RhoTolerance criterion reads through RhoState.

pub fn bias(&self) -> &V

The current bias vector b (search momentum).

pub fn success_count(&self) -> u32

Successive successes recorded since the last failure or step-size expansion.

pub fn failure_count(&self) -> u32

Successive failures recorded since the last success or step-size contraction.

Trait Implementations

impl<V, F> CountsMirror for SolisWetsState<V, F>

where SolisWetsState<V, 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<V: Clone, F: Scalar> RhoState for SolisWetsState<V, F>

fn rho(&self) -> F

For Solis-Wets, ρ is the mutation standard deviation rather than a trust-region radius; the criterion semantics are the same (ρ at its floor ⇒ converged at that resolution).

impl<P, V, F> Solver<P, SolisWetsState<V, F>> for SolisWets<F>

where F: Scalar, P: CostFunction<Param = V, Output = F>, V: Clone + SampleStandardNormal + ScaledAdd<F> + ScaleInPlace<F>,

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

Evaluate the start point once. Resume-idempotent: a resumed chain state arrives with cost already populated and passes through untouched (bias, ρ, and counters are never reset here).

type Error = <P as CostFunction>::Error

Hard-abort error type, mirroring the underlying problem’s type Error. See the trait docs.

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

Advance one iteration.

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

Optional pre-iteration solver-specific termination test.

impl<V: Clone, F: Scalar> State for SolisWetsState<V, F>

fn cost(&self) -> F

Cost at the current iterate, f(x).

Panics

Panics if read before Solver::init has evaluated the start point. By contract the executor calls init before any termination check, so reads from criteria and from OptimizationResult are safe.

type Param = V

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) -> &V

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

fn best_param(&self) -> &V

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).