Enum StationarityStandard 

pub enum StationarityStandard {
    Measured {
        bound: f64,
        rung: StationarityRung,
    },
    NoComparison,
}

What a non-convergence refusal was decided against (#2458/#2465).

A verdict is only falsifiable from the run record if it carries the quantity it was decided against, and for a stationarity refusal that quantity is two facts travelling together: the bound, and the rung that produced it. They used to be two independent fields — stationarity_bound: f64 beside stationarity_bound_rung: Option<StationarityRung> — and the Option was a hole any call site with a number to hand could take. Twenty of the outer runner’s thirty refusal paths took it.

Bundling the pair was not the whole defect. Most of those twenty refuse before any stationarity comparison exists: a failed terminal evaluation, a malformed gradient, a non-converged inner state. They reported the raw configured tolerance — a constant the point was never weighed against — in a sentence reading “projected gradient norm … against stationarity bound …”, asserting a pairing the code does not have. Naming that constant with a rung makes the sentence more confident, not more honest; the fix is to report no bound, because none was applied.

Self::Measured therefore means something specific and checkable: the bound is a property of this point, derived from its own evidence by the named rung, and the reported residual is the quantity weighed against it.

Variants

Measured

A stationarity residual measured at this point was weighed against bound, which rung derived from this point’s own evidence.

Fields

bound: f64

rung: StationarityRung

NoComparison

The refusal was decided without any stationarity comparison — the terminal evidence was rejected before a residual existed, or the predicate was an identity/existence check rather than a bound test. The refusal’s reason carries the basis; no bound is reported because none was applied.

Implementations

impl StationarityStandard

pub fn bound(&self) -> Option<f64>

The bound, when one was applied.

pub fn rung(&self) -> Option<StationarityRung>

The rung that produced the bound, when one was applied.

Trait Implementations

impl Clone for StationarityStandard

fn clone(&self) -> StationarityStandard

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StationarityStandard

impl Debug for StationarityStandard

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StationarityStandard

where 'de: 'static,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for StationarityStandard

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

Formats the value using the given formatter.

impl PartialEq for StationarityStandard

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for StationarityStandard

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for StationarityStandard