Struct IntervalLowerUnboundedUpperBounded 

pub struct IntervalLowerUnboundedUpperBounded<RealType: RealScalar, UpperBoundType: BoundType> { /* private fields */ }

FINAL DOC Generic structure for intervals extending from negative infinity with finite upper bound.

The IntervalLowerUnboundedUpperBounded struct represents semi-infinite intervals that extend infinitely in the negative direction but have a finite upper bound. The upper bound can be either included (closed) or excluded (open) based on the type parameter.

Generic Parameters

• RealType: Must implement RealScalar for mathematical operations
• UpperBoundType: Either Closed or Open to specify upper boundary inclusion

Boundary Type Combinations

Upper	Notation	Mathematical Set
Closed	(-∞, b]	{x : x ≤ b}
Open	(-∞, b)	{x : x < b}

Mathematical Properties

• Infinite measure: μ(I) = +∞ for all variants
• Non-compactness: Never compact (unbounded)
• Connectedness: Always connected (no gaps)
• Lower bound: No finite lower bound (extends from -∞)
• Upper bound: Always has a finite upper bound

Type Aliases

The library provides convenient type aliases:

• IntervalLowerUnboundedUpperClosed = IntervalLowerUnboundedUpperBounded<RealType, Closed>
• IntervalLowerUnboundedUpperOpen = IntervalLowerUnboundedUpperBounded<RealType, Open>

Use Cases

• Capacity limits: Systems with maximum bounds but no minimum restrictions
• “At most” constraints: x ≤ b (closed) or x < b (open)
• Temperature limits: Physical systems with maximum safe temperatures
• Budget constraints: Financial models with spending limits
• Upper thresholds: Where values cannot exceed a certain limit

Construction

use grid1d::intervals::*;

// Using type aliases (recommended)
let upper_bounded_closed = IntervalLowerUnboundedUpperClosed::new(100.0);  // (-∞, 100]
let upper_bounded_open = IntervalLowerUnboundedUpperOpen::new(100.0);      // (-∞, 100)

assert!(upper_bounded_closed.contains_point(&100.0));   // Includes upper bound
assert!(!upper_bounded_open.contains_point(&100.0));    // Excludes upper bound

Implementations

impl<RealType: RealScalar, UpperBoundType: BoundType> IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

pub fn new(upper_bound: RealType) -> Self

Build and return a new instance of IntervalLowerUnboundedUpperBounded from the upper bound of the interval.

impl<RealType: RealScalar, UpperBoundType: BoundType> IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

pub fn upper_bound(&self) -> &UpperBound<RealType, UpperBoundType>

The upper bound of the interval, included in the interval.

This value represents the largest point contained in the interval. For a closed upper bound b], any point x in the interval satisfies x ≤ b. For an open upper bound b), any point x in the interval satisfies x < b.

Trait Implementations

impl<RealType: Clone + RealScalar, UpperBoundType: Clone + BoundType> Clone for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

fn clone(&self) -> IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<RealType: RealScalar, UpperBoundType: BoundType> Contains<RealType> for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

where Self: GetIntervalBound<BoundType = RealType>, UpperBound<RealType, UpperBoundType>: ValueWithinBound<RealType = RealType>,

fn contains_point(&self, x: &RealType) -> bool

Tests whether a point is contained within this interval.

fn contains_interval<IntervalType: IntervalTrait<RealType = RealType>>( &self, other: &IntervalType, ) -> bool

Tests whether this interval completely contains another interval.

impl<RealType: Debug + RealScalar, UpperBoundType: Debug + BoundType> Debug for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

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

Formats the value using the given formatter.

impl<'de, RealType, UpperBoundType: BoundType> Deserialize<'de> for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

where RealType: for<'a> Deserialize<'a> + RealScalar,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<RealType: RealScalar> From<IntervalLowerUnboundedUpperBounded<RealType, Closed>> for Interval<RealType>

fn from(interval: IntervalLowerUnboundedUpperClosed<RealType>) -> Self

Converts to this type from the input type.

impl<RealType: RealScalar> From<IntervalLowerUnboundedUpperBounded<RealType, Closed>> for IntervalInfiniteLength<RealType>

fn from(interval: IntervalLowerUnboundedUpperClosed<RealType>) -> Self

Converts to this type from the input type.

impl<RealType: RealScalar> From<IntervalLowerUnboundedUpperBounded<RealType, Open>> for Interval<RealType>

fn from(interval: IntervalLowerUnboundedUpperOpen<RealType>) -> Self

Converts to this type from the input type.

impl<RealType: RealScalar> From<IntervalLowerUnboundedUpperBounded<RealType, Open>> for IntervalInfiniteLength<RealType>

fn from(interval: IntervalLowerUnboundedUpperOpen<RealType>) -> Self

Converts to this type from the input type.

impl<RealType: RealScalar, UpperBoundType: BoundType> HasUpperBound for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

type UpperBoundValue = RealType

fn upper_bound_value(&self) -> &RealType

Return the upper bound of the interval.

impl<RealType: RealScalar, UpperBoundType: BoundType> IntervalOperations for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

where Self: GetIntervalBound<BoundType = RealType>,

type RealType = RealType

The scalar type used for interval bounds.

fn intersection<IntervalType: IntervalTrait<RealType = Self::RealType>>( &self, other: &IntervalType, ) -> Option<Interval<Self::RealType>>

Computes the intersection of this interval with another interval.

fn union<IntervalType: IntervalTrait<RealType = Self::RealType>>( &self, other: &IntervalType, ) -> IntervalUnion<Self::RealType>

where Interval<Self::RealType>: From<Self> + From<IntervalType>,

Computes the union of this interval with another.

impl<RealType: PartialEq + RealScalar, UpperBoundType: PartialEq + BoundType> PartialEq for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

fn eq( &self, other: &IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>, ) -> 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<RealType, UpperBoundType> Serialize for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

where RealType: Serialize + RealScalar, UpperBoundType: Serialize + BoundType,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<RealType: Eq + RealScalar, UpperBoundType: Eq + BoundType> Eq for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

impl<RealType: RealScalar, UpperBoundType: BoundType> IntervalLowerUnboundedUpperBoundedTrait for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

where Self: GetIntervalBound<BoundType = RealType>, UpperBound<RealType, UpperBoundType>: ValueWithinBound<RealType = RealType>,

impl<RealType: RealScalar, UpperBoundType: BoundType> IntervalTrait for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>

where Self: GetIntervalBound<BoundType = RealType>, UpperBound<RealType, UpperBoundType>: ValueWithinBound<RealType = RealType>,

impl<RealType: RealScalar, UpperBoundType: BoundType> StructuralPartialEq for IntervalLowerUnboundedUpperBounded<RealType, UpperBoundType>