Struct Interval 

pub struct Interval {
    pub lo: Number,
    pub hi: Number,
}

Closed interval [lo, hi] with outward rounding on operations.

EMPTY is encoded as lo > hi (specifically lo = +∞, hi = -∞). ENTIRE is (-∞, +∞). Construction helpers normalize these for you.

Fields

lo: Number

hi: Number

Implementations

impl Interval

pub const ENTIRE: Interval

[-∞, +∞] — represents “no information”.

pub const EMPTY: Interval

∅ — empty set; sentinel for infeasibility.

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

Closed interval [lo, hi]. NaN endpoints or lo > hi collapse to Self::EMPTY so downstream rules don’t have to special- case malformed input.

pub fn point(x: Number) -> Self

Degenerate interval [x, x]. NaN collapses to EMPTY.

pub fn is_empty(&self) -> bool

pub fn is_entire(&self) -> bool

pub fn contains(&self, x: Number) -> bool

true iff x ∈ [lo, hi].

pub fn contains_zero(&self) -> bool

pub fn width(&self) -> Number

hi - lo, or 0 for empty. May be +∞.

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

[max(self.lo, other.lo), min(self.hi, other.hi)]. Empty if the result is malformed — this is the right semantics for FBBT’s “narrow against the constraint” step.

pub fn hull(self, other: Self) -> Self

Convex hull [min(lo, lo), max(hi, hi)]. Empty if both inputs are empty.

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

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

pub fn neg(self) -> Self

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

Interval multiplication — the classic four-corner formula.

pub fn div(self, rhs: Self) -> Self

Division — returns ENTIRE (rather than a split / extended interval) when 0 ∈ rhs, since FBBT’s reverse rules elsewhere can recover useful information without the union-of-intervals complexity here.

pub fn pow_uint(self, n: u32) -> Self

[lo, hi]^n for non-negative integer n. Handles the non-monotone case n even, 0 ∈ self correctly.

pub fn sqrt(self) -> Self

√[lo, hi]. Negative lo clipped to 0 (matches mathematical domain). Empty input or fully-negative interval → EMPTY.

pub fn exp(self) -> Self

exp([lo, hi]) — monotone increasing.

pub fn ln(self) -> Self

ln([lo, hi]) — monotone increasing on x > 0. lo ≤ 0 is clipped to the smallest positive finite (return -∞ on the low side). Fully-non-positive intervals → EMPTY.

pub fn abs(self) -> Self

|[lo, hi]|.

pub fn sin(self) -> Self

sin([lo, hi]). When the interval is wider than 2π or wraps over both a peak and a trough we return [-1, 1]; otherwise we test against the local extrema. A loose-but-sound choice.

pub fn cos(self) -> Self

cos([lo, hi]).

pub fn min(self, other: Self) -> Self

Element-wise min(self, other).

pub fn max(self, other: Self) -> Self

Element-wise max(self, other).

Trait Implementations

impl Clone for Interval

fn clone(&self) -> Interval

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Interval

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

Formats the value using the given formatter.

impl PartialEq for Interval

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

impl StructuralPartialEq for Interval