Enum Certified

#[non_exhaustive]
pub enum Certified {
    Certain {
        sign: Sign,
        precision: Precision,
    },
    Uncertain {
        attempted: Precision,
    },
}

A predicate evaluation that may or may not be trustworthy.

Uncertain is deliberately not a sign: it carries no Sign payload, so a caller cannot accidentally read a value out of it. The only way to obtain a Sign is to handle the uncertain case explicitly.

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.

Certain

The sign is proven at the reported precision.

Fields

sign: Sign

The proven sign.

precision: Precision

Precision tier at which the proof was obtained.

Uncertain

The computed value was within its own error bound of zero, so the sign could not be determined at this precision. Escalate.

Fields

attempted: Precision

Precision tier that failed to decide.

Implementations

impl Certified

pub fn from_filter( value: f64, error_bound: f64, precision: Precision, ) -> Certified

Certify a value against a filter’s absolute error bound.

The bound is the maximum absolute error the computation may carry. If zero lies inside value +- bound the sign is not decidable here, which is the whole point of a filtered predicate: it reports failure instead of guessing. A non-finite value or bound is never certifiable.

pub const fn exact_sign(sign: Sign) -> Certified

Certify an exact computation. Only valid where no rounding occurred.

An exact zero is a certain answer – the configuration is genuinely degenerate – which is different from being unable to decide. A sign established by exact arithmetic, where no integer value exists.

An exact predicate cascade produces a proven sign without producing a representable magnitude: the determinant lives in a multi-term expansion, not one i64. Without this constructor such a result could only be reported as Uncertain, which would discard the very proof the exact path was paid for.

pub const fn exact(value: i64) -> Certified

pub const fn sign(self) -> Option<Sign>

The proven sign, or None when escalation is required.

pub const fn is_certain(self) -> bool

Whether this result is safe to drive a topology decision.

Trait Implementations

impl Clone for Certified

fn clone(&self) -> Certified

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Certified

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

Formats the value using the given formatter.

impl Hash for Certified

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Certified

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Certified

impl Eq for Certified

impl StructuralPartialEq for Certified