Struct UnitIntervalUpperOpen 

pub struct UnitIntervalUpperOpen;

Marker type enforcing that a value lies in the right-open unit interval: 0 ≤ x < 1.

Requires T: UnitBounds. We provide UnitBounds implementations for f32, f64, and uom::si::f64::Ratio.

You can construct a value constrained to [0, 1) using either the generic Constrained::new method or the convenient UnitIntervalUpperOpen::new associated function.

Examples

Using with f64:

use twine_models::support::constraint::{Constrained, UnitIntervalUpperOpen};

// Generic constructor:
let a = Constrained::<_, UnitIntervalUpperOpen>::new(0.25).unwrap();
assert_eq!(a.into_inner(), 0.25);

// Associated constructor:
let b = UnitIntervalUpperOpen::new(0.0).unwrap();
assert_eq!(b.as_ref(), &0.0);

// Endpoint:
let z = UnitIntervalUpperOpen::zero::<f64>();
assert_eq!(z.into_inner(), 0.0);

// Error cases:
assert!(UnitIntervalUpperOpen::new(1.0).is_err());
assert!(UnitIntervalUpperOpen::new(1.5).is_err());
assert!(UnitIntervalUpperOpen::new(f64::NAN).is_err());

Using with uom::si::f64::Ratio:

use twine_models::support::constraint::{Constrained, UnitIntervalUpperOpen};
use uom::si::{f64::Ratio, ratio::{ratio, percent}};

let r = Constrained::<Ratio, UnitIntervalUpperOpen>::new(Ratio::new::<ratio>(0.42)).unwrap();
assert_eq!(r.as_ref().get::<percent>(), 42.0);

let z = UnitIntervalUpperOpen::zero::<Ratio>();
assert_eq!(z.into_inner().get::<percent>(), 0.0);

Implementations

impl UnitIntervalUpperOpen

pub fn new<T: UnitBounds>( value: T, ) -> Result<Constrained<T, UnitIntervalUpperOpen>, ConstraintError>

Constructs Constrained<T, UnitIntervalUpperOpen> if 0 ≤ value < 1.

Errors

Fails if the value is outside the upper-open unit interval:

• ConstraintError::BelowMinimum if less than zero.
• ConstraintError::AboveMaximum if greater than or equal to one.
• ConstraintError::NotANumber if comparison is undefined (e.g., NaN).

pub fn zero<T: UnitBounds>() -> Constrained<T, UnitIntervalUpperOpen>

Returns the lower bound (zero) as a constrained value.

Trait Implementations

impl Clone for UnitIntervalUpperOpen

fn clone(&self) -> UnitIntervalUpperOpen

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: UnitBounds> Constraint<T> for UnitIntervalUpperOpen

fn check(value: &T) -> Result<(), ConstraintError>

Checks that the given value satisfies this constraint.

impl Debug for UnitIntervalUpperOpen

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

Formats the value using the given formatter.

impl Ord for UnitIntervalUpperOpen

fn cmp(&self, other: &UnitIntervalUpperOpen) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for UnitIntervalUpperOpen

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

fn partial_cmp(&self, other: &UnitIntervalUpperOpen) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for UnitIntervalUpperOpen

impl Eq for UnitIntervalUpperOpen

impl StructuralPartialEq for UnitIntervalUpperOpen