Struct UnitIntervalLowerOpen 

pub struct UnitIntervalLowerOpen;

Marker type enforcing that a value lies in the left-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 UnitIntervalLowerOpen::new associated function.

Examples

Using with f64:

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

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

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

// Endpoint:
let o = UnitIntervalLowerOpen::one::<f64>();
assert_eq!(o.into_inner(), 1.0);

// Error cases:
assert!(UnitIntervalLowerOpen::new(0.0).is_err());
assert!(UnitIntervalLowerOpen::new(-0.5).is_err());
assert!(UnitIntervalLowerOpen::new(f64::NAN).is_err());

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

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

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

let o = UnitIntervalLowerOpen::one::<Ratio>();
assert_eq!(o.into_inner().get::<percent>(), 100.0);

Implementations

impl UnitIntervalLowerOpen

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

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

Errors

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

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

pub fn one<T: UnitBounds>() -> Constrained<T, UnitIntervalLowerOpen>

Returns the upper bound (one) as a constrained value.

Trait Implementations

impl Clone for UnitIntervalLowerOpen

fn clone(&self) -> UnitIntervalLowerOpen

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Checks that the given value satisfies this constraint.

impl Debug for UnitIntervalLowerOpen

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

Formats the value using the given formatter.

impl Ord for UnitIntervalLowerOpen

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

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

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

impl Eq for UnitIntervalLowerOpen

impl StructuralPartialEq for UnitIntervalLowerOpen