Struct ProbabilityInterval 

pub struct ProbabilityInterval {
    pub lower: f64,
    pub upper: f64,
}

Probability interval representing imprecise probabilities.

Represents the set [lower, upper] of possible probability values. Follows the theory of imprecise probabilities and credal sets.

Fields

lower: f64

Lower probability bound (must be in [0, 1])

upper: f64

Upper probability bound (must be in [0, 1] and >= lower)

Implementations

impl ProbabilityInterval

pub fn new(lower: f64, upper: f64) -> Option<Self>

Create a new probability interval.

Returns None if bounds are invalid (not in [0,1] or lower > upper).

pub fn precise(prob: f64) -> Option<Self>

Create a precise probability (point interval).

pub fn vacuous() -> Self

Create a vacuous interval [0, 1] (complete ignorance).

pub fn width(&self) -> f64

Width of the interval (measure of imprecision).

pub fn is_precise(&self) -> bool

Check if this is a precise probability.

pub fn is_vacuous(&self) -> bool

Check if the interval is vacuous (completely imprecise).

pub fn complement(&self) -> Self

Complement: P(¬A) given P(A).

pub fn and(&self, other: &Self) -> Self

Conjunction bounds: P(A ∧ B) given P(A) and P(B).

Uses Fréchet bounds: max(0, P(A) + P(B) - 1) ≤ P(A ∧ B) ≤ min(P(A), P(B))

pub fn or(&self, other: &Self) -> Self

Disjunction bounds: P(A ∨ B) given P(A) and P(B).

Uses Fréchet bounds: max(P(A), P(B)) ≤ P(A ∨ B) ≤ min(1, P(A) + P(B))

pub fn implies(&self, other: &Self) -> Self

Implication bounds: P(A → B) given P(A) and P(B).

A → B ≡ ¬A ∨ B, so use complement and disjunction.

pub fn conditional(&self, joint: &Self) -> Option<Self>

Conditional probability bounds: P(B|A) given P(A) and P(A ∧ B).

If P(A) > 0, returns P(A ∧ B) / P(A). Uses interval division: [a,b] / [c,d] = [a/d, b/c] for positive intervals.

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

Intersection of two probability intervals.

Returns None if intervals don’t overlap.

pub fn convex_combine(&self, other: &Self, weight: f64) -> Option<Self>

Convex combination of two intervals.

Useful for averaging or mixing probability assessments.

Trait Implementations

impl Clone for ProbabilityInterval

fn clone(&self) -> ProbabilityInterval

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ProbabilityInterval

impl Debug for ProbabilityInterval

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

Formats the value using the given formatter.

impl PartialEq for ProbabilityInterval

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