Enum Termination 

#[non_exhaustive]
pub enum Termination<F: Scalar = f64> {
    Converged(Convergence<F>),
    Limit(Vec<ExecutionLimit>),
    Target {
        cost: F,
        target: F,
    },
    Stalled(Stall<F>),
    Failed(NumericalFailure<F>),
    Cancelled,
    Application(ApplicationStop),
}

A stopping decision returned with its explanation at the point of detection.

Numerical failure publishes a coherent state through Ok; typed problem callback errors remain Result::Err. Convergence describes the tested predicates and does not certify a global optimum or parameter accuracy.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Converged(Convergence<F>)

One or more numerical convergence predicates passed.

Limit(Vec<ExecutionLimit>)

All execution budgets exhausted at the observed boundary.

Target

The eligible objective incumbent reached the requested target.

Fields

cost: F

Eligible incumbent objective at the stopping boundary.

target: F

Requested objective threshold.

Stalled(Stall<F>)

A numerical safeguard or configured progress rule stopped the run.

Failed(NumericalFailure<F>)

The solver could not continue numerically.

Cancelled

The executor cancellation token requested a stop.

Application(ApplicationStop)

An application hook requested a stop.

Implementations

impl<F: Scalar> Termination<F>

pub fn native_convergence_tests(&self) -> Vec<NativeConvergenceTest>

Native identities retained for diagnostic consumers migrating from 1.x. The returned list is derived from this event, never from solver history.

pub fn converged(criterion: ConvergenceCriterion<F>) -> Self

Stop because the supplied numerical predicate passed.

pub fn is_converged(&self) -> bool

Whether this decision establishes its reported convergence predicates.

pub fn is_failure(&self) -> bool

Whether this decision reports a numerical failure.

pub fn can_continue_as_inner(&self, policy: PartialResultPolicy) -> bool

Whether an outer algorithm may consume this result under its explicit partial-result policy. Cancellation, application stops, and failures require routing rather than silently continuing.

pub fn numerical_failure(message: impl Into<String>) -> Self

Stop with a numerical failure and a published state.

pub fn numerical_stall(message: impl Into<String>) -> Self

Stop on a numerical safeguard without claiming convergence.

impl<F: Scalar> Termination<F>

pub fn upper_bound( test: ConvergenceTest, value: F, bound: F, tolerance: F, reference: Option<F>, ) -> Self

Construct a predicate report with its measured value and bound.

pub fn custom( key: impl Into<String>, definition: impl Into<String>, measurements: Vec<Measurement<F>>, ) -> Self

Construct a namespaced predicate with its definition and measurements.

pub fn code(&self) -> TerminationCode

A compact compatibility identifier. With simultaneous predicates, this identifies the first reported predicate; use the full report to inspect every condition. Its numeric value is explicitly mapped by as_u8().

Trait Implementations

impl<F: Clone + Scalar> Clone for Termination<F>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Scalar> Debug for Termination<F>

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

Formats the value using the given formatter.

impl<'de, F> Deserialize<'de> for Termination<F>

where 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<F: PartialEq + Scalar> PartialEq for Termination<F>

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

Equality operator ==.

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

Inequality operator !=.

impl<F> Serialize for Termination<F>

where 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<F: PartialEq + Scalar> StructuralPartialEq for Termination<F>