Struct SimulatedAnnealingState 

pub struct SimulatedAnnealingState<P, N, F = f64, R = ChaCha8Rng> { /* private fields */ }

State for SimulatedAnnealing.

This type stores every evolving component of the Markov chain: the stateful neighbor, RNG, cooling phase, reannealing progress, incumbent, best-so-far history, and counters. With the serde feature, serializing this state and passing the restored value to Executor::resume continues the same chain. Solver-aware ExactCheckpoint snapshots remain available through Executor::resume_from_checkpoint.

Implementations

impl<P, N, F, R> SimulatedAnnealingState<P, N, F, R>

where F: Scalar,

pub fn temperature(&self) -> F

Temperature that will be used for the next proposal.

pub fn accepted_moves(&self) -> u64

Number of accepted proposals.

pub fn rejected_moves(&self) -> u64

Number of rejected proposals.

pub fn reannealings(&self) -> u64

Number of completed schedule restarts.

pub fn last_accepted_iter(&self) -> u64

Absolute iteration of the most recently accepted proposal.

Trait Implementations

impl<P, N, F, R> AcceptanceState for SimulatedAnnealingState<P, N, F, R>

where SimulatedAnnealingState<P, N, F, R>: State,

fn last_accepted_iter(&self) -> u64

Absolute iteration of the most recently accepted proposal.

fn accepted_moves(&self) -> u64

Cumulative number of accepted proposals.

fn rejected_moves(&self) -> u64

Cumulative number of rejected proposals.

impl<P: Clone, N: Clone, F: Clone, R: Clone> Clone for SimulatedAnnealingState<P, N, F, R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P, N, F, R> CountsMirror for SimulatedAnnealingState<P, N, F, R>

where SimulatedAnnealingState<P, N, F, R>: State,

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<P: Debug, N: Debug, F: Debug, R: Debug> Debug for SimulatedAnnealingState<P, N, F, R>

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

Formats the value using the given formatter.

impl<'de, P, N, F, R> Deserialize<'de> for SimulatedAnnealingState<P, N, F, R>

where P: Deserialize<'de>, N: Deserialize<'de>, F: Deserialize<'de>, R: Deserialize<'de>,

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<P, N, F, R> ExactResumeState for SimulatedAnnealingState<P, N, F, R>

where SimulatedAnnealingState<P, N, F, R>: State,

fn resume_counts(&self) -> EvalCounts

Complete evaluation counts at the point represented by this snapshot.

impl<P, N, F, R> Serialize for SimulatedAnnealingState<P, N, F, R>

where P: Serialize, N: Serialize, F: Serialize, R: Serialize,

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, N, F, R> Solver<P, SimulatedAnnealingState<V, N, F, R>> for SimulatedAnnealing<N, F, R>

where P: CostFunction<Param = V, Output = F>, V: Clone, N: Neighbor<V, F, R, Error = P::Error>, F: Scalar, R: Rng,

type Error = <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: SimulatedAnnealingState<V, N, F, R>, ) -> Result<SimulatedAnnealingState<V, N, F, R>, Self::Error>

One-time setup before the iteration loop.

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

Advance one iteration.

fn terminate( &self, state: &SimulatedAnnealingState<V, N, F, R>, ) -> Option<TerminationReason>

Optional pre-iteration solver-specific termination test.

fn reset_convergence(&mut self)

Reset per-run convergence history without changing algorithm state.

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

Check convergence at an initialized iteration boundary.

impl<P, N, F, R> State for SimulatedAnnealingState<P, N, F, R>

where P: Clone, F: Scalar,

type Param = P

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 cost_evals(&self) -> u64

Cumulative evaluation work under the state’s CountsMirror mapping. In Basin 1.x this can include residual or derivative work as well as cost-function calls; it is not uniformly the raw cost-call count. 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) -> &P

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 BasicPopulationState::with_size must first be initialized.

fn cost(&self) -> F

Cost at the current param.

fn best_param(&self) -> &P

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