Struct ScalInF64 

pub struct ScalInF64 {
    pub lo: f64,
    pub hi: f64,
}

Interval f64 scalar: [lo, hi] with outward-rounded arithmetic.

Fields

lo: f64

hi: f64

Implementations

impl ScalInF64

pub fn new(lo: f64, hi: f64) -> Self

Create a proper interval. Panics in debug if lo > hi.

pub fn degenerate(v: f64) -> Self

Degenerate (point) interval.

Trait Implementations

impl Add for ScalInF64

type Output = ScalInF64

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl Clone for ScalInF64

fn clone(&self) -> ScalInF64

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ScalInF64

impl Debug for ScalInF64

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

Formats the value using the given formatter.

impl Default for ScalInF64

fn default() -> Self

Returns the “default value” for a type.

impl Display for ScalInF64

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

Formats the value using the given formatter.

impl Field for ScalInF64

fn div(self, other: Self) -> GeopResult<Self>

impl From<f64> for ScalInF64

fn from(v: f64) -> Self

Converts to this type from the input type.

impl From<i64> for ScalInF64

fn from(v: i64) -> Self

Converts to this type from the input type.

impl Mul for ScalInF64

type Output = ScalInF64

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl Neg for ScalInF64

type Output = ScalInF64

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for ScalInF64

fn eq(&self, other: &ScalInF64) -> 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 Ring for ScalInF64

fn add(self, other: Self) -> Self

fn sub(self, other: Self) -> Self

fn mul(self, other: Self) -> Self

fn neg(self) -> Self

impl Scalar for ScalInF64

const ZERO: Self

const ONE: Self

const TWO: Self

const PI: Self

const E: Self

const INFINITY: Self

Saturation sentinel — set on overflow.

const ENTIRE: Self

The “entire” interval (-inf, inf) — the top element of the interval lattice. could_be_equal/could_be_greater/could_be_less against it are always true, and it never satisfies definitely_*. Used to represent a value or a whole curve/surface whose position is not yet known — an unsharp placeholder that automatically passes any overlap/equality check made against it.

fn from_i64(v: i64) -> Self

fn from_f64(v: f64) -> Self

fn from_ratio(num: i64, den: i64) -> GeopResult<Self>

fn abs(self) -> Self

fn sqrt(self) -> GeopResult<Self>

fn sin(self) -> Self

Outward-rounded enclosure of sin/cos over the whole interval (radians). Total — never fails, even for Scalar::ENTIRE or an Scalar::INFINITY-adjacent value, which just widen to [-1, 1].

fn cos(self) -> Self

fn could_be_equal(self, other: Self) -> bool

fn definitely_not_equal(self, other: Self) -> bool

fn could_be_greater(self, other: Self) -> bool

fn definitely_greater(self, other: Self) -> bool

fn could_be_less(self, other: Self) -> bool

fn definitely_less(self, other: Self) -> bool

fn is_infinite(self) -> bool

fn is_finite(self) -> bool

fn midpoint(self) -> Self

fn is_sharp(self) -> bool

True iff this value carries no width — it’s a single, exactly-known point, not a genuine range of possibility.

fn lower(self) -> Self

The sharp lower / upper endpoint of this enclosure. Every value self could be is >= lower() and <= upper(), so these are the outer bounds to cut at when a search restricts a domain to an enclosure of its answer: a cut there never loses a solution (unlike Scalar::sharpen, which would cut through the enclosure).

fn upper(self) -> Self

fn width(self) -> Self

How much possibility this enclosure carries: hi - lo, as a sharp, non-negative value. Zero exactly when Scalar::is_sharp.

fn intersect(self, other: Self) -> Self

The largest value contained in both self and other — the dual of Scalar::union. Callers must only intersect two enclosures of the same underlying exact value (as Scalar::interpolate does); given that, the result is still an honest enclosure, just a tighter one. Implementations may return either input if the two somehow don’t overlap, rather than fabricating an empty/inverted interval.

fn to_f64(self) -> f64

Approximate f64 midpoint. For point scalars returns the value; for interval scalars returns (lo + hi) / 2. Used only for rendering/debugging.

fn union(self, other: Self) -> Self

The smallest value definitely containing both self and other — the scalar-level analog of Set::union.

fn is_subset_of(self, other: Self) -> bool

True iff self is contained in other as sets: other.lo <= self.lo and self.hi <= other.hi. This is the rigorous existence/uniqueness test a Krawczyk-style contraction relies on (K(X) ⊆ X) — distinct from Scalar::could_be_equal, which only asks whether the two enclosures overlap. self.intersect(other).could_be_equal(self) would answer the same question but at the cost of rebuilding an enclosure just to throw it away; implementations should compare bounds directly.

fn sharpen(self) -> Self

Collapse to a single representative point (currently the midpoint, like Scalar::midpoint, but named for its distinct purpose: use this only when you are free to pick any value within self and don’t need to preserve which one — e.g. choosing where to place a new knot when subdividing a curve at an arbitrary interior point. Never use this to compress a value that represents a genuinely uncertain physical quantity (a search’s converged bound, a measured position) — that would silently discard real uncertainty rather than making an arbitrary, harmless choice.

fn interpolate(a: Self, b: Self, alpha: Self) -> Self

Point a fraction alpha of the way from a to b: a at alpha=0, b at alpha=1.

impl StructuralPartialEq for ScalInF64

impl Sub for ScalInF64

type Output = ScalInF64

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.