Struct SelectedFirstOrderState 

pub struct SelectedFirstOrderState<V, F: Scalar = f64> { /* private fields */ }

Solver-selected constrained progress with a matching objective gradient.

Construction provides an unevaluated seed. replace checks point and gradient dimensions before publishing a complete current record, while select_current explicitly chooses an incumbent. Selection can increase the objective to improve feasibility, so this state does not implement super::ObjectiveIncumbentState. The solver supplies a ViolationReport describing the measure, scaling, and transformation, and defines its eligibility rules.

Current records contain a point, objective, gradient, and violation. Best records contain the selected point, objective, and violation; their raw counts and iteration are stamped by the executor at publication. Selection events follow SelectedState, including preservation when current progress changes before publication. Derivatives are advertised only for current evaluated progress. All six evaluation categories retain their raw values.

Fresh initialization calls reset and reevaluates the seed. Exact continuation retains the solver and state together. With serde, serialization is available when V and F support it.

Backends

Vec<F>, nalgebra DVector<F>, ndarray Array1<F>, and faer Col<F>, for F = f64 (default) or f32. Replacement requires VectorLen; state capabilities require only V: Clone.

use basin::{RunControl, SelectedFirstOrderState};
let _ = RunControl::<SelectedFirstOrderState<Vec<f64>>>::new().target_objective(0.0);

Implementations

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

pub fn new(param: V) -> Self

Construct an unevaluated seed with no selected incumbent.

pub fn reset(&mut self)

Clear records and bookkeeping, retaining the parameter as a fresh seed.

pub fn current(&self) -> Option<(&V, F, &V, &ViolationReport<F>)>

Matching point, objective, gradient, and violation report, or None for a seed.

pub fn best(&self) -> Option<(&V, F, &ViolationReport<F>)>

Selected point, objective, and violation report, or None before selection.

pub fn counts(&self) -> &EvalCounts

All six raw evaluation categories at the current publication boundary.

pub fn best_counts(&self) -> Option<&EvalCounts>

Raw counts recorded when the selected incumbent was published.

impl<V: VectorLen, F: Scalar> SelectedFirstOrderState<V, F>

pub fn replace( &mut self, param: V, cost: F, gradient: V, violation: ViolationReport<F>, ) -> Result<(), GradientDimensionMismatch>

Replace current progress atomically, preserving any pending selection. A dimension mismatch leaves every record and counter unchanged.

impl<V: Clone, F: Scalar> SelectedFirstOrderState<V, F>

pub fn select_current(&mut self) -> bool

Select the current evaluated record for the next publication boundary. Returns false for an unevaluated seed. Repeated observation does not refresh the selected record’s metadata.

Trait Implementations

impl<V: Clone, F: Clone + Scalar> Clone for SelectedFirstOrderState<V, F>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Clone, F: Scalar> ConstraintViolationState for SelectedFirstOrderState<V, F>

fn current_violation(&self) -> Option<&ViolationReport<F>>

Borrow the report matching the current evaluated point, or None.

fn incumbent_violation(&self) -> Option<&ViolationReport<F>>

Borrow the report matching the selected incumbent, or None.

impl<V: Clone, F: Scalar> CountsMirror for SelectedFirstOrderState<V, F>

fn mirror(&mut self, counts: &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: Debug, F: Debug + Scalar> Debug for SelectedFirstOrderState<V, F>

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

Formats the value using the given formatter.

impl<'de, V, F> Deserialize<'de> for SelectedFirstOrderState<V, F>

where V: Deserialize<'de>, F: Deserialize<'de> + Scalar,

Available on crate feature serde only.

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<V: Clone, F: Scalar> EvaluatedGradientState for SelectedFirstOrderState<V, F>

fn current_gradient_record(&self) -> Option<(&V, F, &V)>

Borrow the matching point, cost, and gradient, or None for a seed.

impl<V: Clone, F: Scalar> EvaluatedState for SelectedFirstOrderState<V, F>

fn current_record(&self) -> Option<(&V, F)>

Borrow the complete current record’s point and cost, if available.

impl<V: Clone, F: Scalar> GradientState for SelectedFirstOrderState<V, F>

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

Gradient at the current param, if populated.

fn gradient_evals(&self) -> u64

Cumulative derivative work under the state’s CountsMirror mapping. In Basin 1.x this can include Jacobian, Hessian, and Hessian-product evaluations as well as gradient calls.

fn best_gradient_evals(&self) -> u64

gradient_evals at the publication boundary that recorded the incumbent, the companion to State::best_cost_evals. This is not necessarily the count at the precise evaluation that found the point.

impl<V: Clone, F: Scalar> IncumbentState for SelectedFirstOrderState<V, F>

fn incumbent_record(&self) -> Option<IncumbentRef<'_, V, F>>

Borrow the selected record, if one has been established.

impl<V: PartialEq, F: PartialEq + Scalar> PartialEq for SelectedFirstOrderState<V, F>

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

Equality operator ==.

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

Inequality operator !=.

impl<V: Clone, F: Scalar> RawEvaluationState for SelectedFirstOrderState<V, F>

fn raw_counts(&self) -> &EvalCounts

All six raw categories, without folding or reconstruction.

impl<V, F> Serialize for SelectedFirstOrderState<V, F>

where V: Serialize, F: Serialize + Scalar,

Available on crate feature serde only.

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<P, V, F> Solver<P, SelectedFirstOrderState<V, F>> for Slsqp<F>

where F: Scalar, P: CostFunction<Param = V, Output = F> + Gradient<Gradient = V>, P::Constraints: SlsqpSet<P, V, F>, V: Clone + VectorLen + VectorIndex<F>,

type Error = ConstraintSolveError<<P as CostFunction>::Error>

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

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

One-time setup before the iteration loop.

fn next_iter( &mut self, problem: &mut Problem<P>, state: SelectedFirstOrderState<V, F>, ) -> Result<SolverStep<SelectedFirstOrderState<V, F>>, ConstraintSolveError<P::Error>>

Advance one iteration.

fn terminate( &self, _state: &SelectedFirstOrderState<V, F>, ) -> Option<Termination<F>>

Optional pre-iteration solver-specific termination test.

fn reset_convergence(&mut self)

Reset per-run convergence history without changing algorithm state.

fn should_check_iterate_change(&self) -> bool

Whether the current boundary can enter cost- and step-change checks.

fn check_convergence( &mut self, _problem: &Problem<P>, state: &S, ) -> Option<Termination<S::Float>>

Check convergence at an initialized iteration boundary.

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

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, such as f64 or f32.

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 param(&self) -> &V

Current iterate. Stable between Solver::next_iter calls; available after successful initialization, including iter 0. Some constructors supply it immediately, while an empty population such as PopulationProgress::empty must first be initialized.

fn cost(&self) -> F

Cost at the current param.

fn cost_evals(&self) -> u64

Cumulative evaluation work under the state’s CountsMirror mapping. Every shipped shared state reports only raw cost-function calls. Custom states define their mapping through CountsMirror. 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 best_param(&self) -> &V

Selected incumbent under this state’s best-tracking rule.

fn best_cost(&self) -> F

Cost of the selected incumbent. This is the historical minimum for objective-ordered states, but can increase under constrained incumbent selection.

fn best_iter(&self) -> u64

Iteration recorded by the most recent incumbent update. Objective- ordered states record strict improvements; states that mirror a solver-selected incumbent may refresh this on every publication.

fn best_cost_evals(&self) -> u64

cost_evals at the publication boundary that recorded the incumbent. This need not be the precise evaluation that found the point.

fn update_best(&mut self)

Refresh the incumbent using this state’s selection rule. Most states retain strict objective improvements; population states can also consider exposed samples, and constrained states can mirror the solver’s selected incumbent.

fn reset_best(&mut self)

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

impl<V: PartialEq, F: PartialEq + Scalar> StructuralPartialEq for SelectedFirstOrderState<V, F>