Struct UnitInterval

Source

pub struct UnitInterval<T = f32>(/* private fields */);

Expand description

A floating-point value constrained to the closed unit interval [0, 1].

UnitInterval is useful for normalized values such as opacity, progress, ratios, blend factors, and percentages represented as fractions.

The default backing type is f32; use UnitInterval<f64> when you need a wider float.

§Examples

use unit_intervals::UnitInterval;

let progress = UnitInterval::new(0.75).unwrap();

assert_eq!(progress.get(), 0.75);
assert_eq!(UnitInterval::new(1.25), None);

Implementations§

Source §

use unit_intervals::UnitInterval;

assert_eq!(UnitInterval::<f32>::HALF.get(), 0.5);

Source

pub fn new(v: T) -> Option<Self>

Creates a value if v is inside [0, 1].

Returns None for values outside the interval and for NaN.

§Examples

use unit_intervals::UnitInterval;

assert_eq!(UnitInterval::<f32>::new(0.25).unwrap().get(), 0.25);
assert_eq!(UnitInterval::<f32>::new(-0.25), None);
assert_eq!(UnitInterval::<f32>::new(f32::NAN), None);

Source

pub const fn get(self) -> T

Returns the inner floating-point value.

§Examples

use unit_intervals::UnitInterval;

let value = UnitInterval::new(0.25).unwrap();

assert_eq!(value.get(), 0.25);

Source

pub const fn into_inner(self) -> T

Consumes the wrapper and returns the inner floating-point value.

§Examples

use unit_intervals::UnitInterval;

let value = UnitInterval::new(0.25).unwrap();

assert_eq!(value.into_inner(), 0.25);

Source

pub fn is_zero(self) -> bool

Returns whether this value is exactly zero.

§Examples

use unit_intervals::UnitInterval;

assert!(UnitInterval::<f32>::ZERO.is_zero());
assert!(!UnitInterval::<f32>::HALF.is_zero());

Source

pub fn is_one(self) -> bool

Returns whether this value is exactly one.

§Examples

use unit_intervals::UnitInterval;

assert!(UnitInterval::<f32>::ONE.is_one());
assert!(!UnitInterval::<f32>::HALF.is_one());

Source

pub fn complement(self) -> Self

Returns 1 - self.

§Examples

use unit_intervals::UnitInterval;

let value = UnitInterval::new(0.25).unwrap();

assert_eq!(value.complement().get(), 0.75);

Source

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

Returns the smaller of two unit interval values.

§Examples

use unit_intervals::UnitInterval;

let low = UnitInterval::new(0.25).unwrap();
let high = UnitInterval::new(0.75).unwrap();

assert_eq!(low.min(high), low);

Source

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

Returns the larger of two unit interval values.

§Examples

use unit_intervals::UnitInterval;

let low = UnitInterval::new(0.25).unwrap();
let high = UnitInterval::new(0.75).unwrap();

assert_eq!(low.max(high), high);

Source

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

Returns the midpoint between two unit interval values.

§Examples

use unit_intervals::UnitInterval;

let low = UnitInterval::new(0.25).unwrap();
let high = UnitInterval::new(0.75).unwrap();

assert_eq!(low.midpoint(high).get(), 0.5);

Source

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

Returns the absolute distance between two unit interval values.

§Examples

use unit_intervals::UnitInterval;

let low = UnitInterval::new(0.25).unwrap();
let high = UnitInterval::new(0.75).unwrap();

assert_eq!(low.distance_to(high).get(), 0.5);
assert_eq!(high.distance_to(low).get(), 0.5);

Source

pub fn checked_add(self, rhs: Self) -> Option<Self>

Adds two values, returning None if the result is outside [0, 1].

§Examples

use unit_intervals::UnitInterval;

let a = UnitInterval::new(0.25).unwrap();
let b = UnitInterval::new(0.75).unwrap();

assert_eq!(a.checked_add(a).unwrap().get(), 0.5);
assert_eq!(b.checked_add(b), None);

Source

pub unsafe fn add_unchecked(self, rhs: Self) -> Self

Available on crate feature unsafe only.

Available on crate feature unsafe only.

Subtracts rhs without checking that the result is inside [0, 1].

§Safety

The caller must guarantee that self - rhs is inside [0, 1] and not NaN.

Source

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

Subtracts rhs and clamps the result into [0, 1].

§Examples

use unit_intervals::UnitInterval;

let low = UnitInterval::new(0.25).unwrap();
let high = UnitInterval::new(0.75).unwrap();

assert_eq!(low.saturating_sub(high).get(), 0.0);

Source

pub fn checked_div(self, rhs: Self) -> Option<Self>

Divides by rhs, returning None if the result is outside [0, 1].

Division by zero follows the backing float semantics and produces None, because infinity is outside the unit interval.

§Examples

use unit_intervals::UnitInterval;

let low = UnitInterval::new(0.25).unwrap();
let high = UnitInterval::new(0.75).unwrap();

assert_eq!(low.checked_div(high).unwrap().get(), 1.0 / 3.0);
assert_eq!(high.checked_div(low), None);
assert_eq!(high.checked_div(UnitInterval::ZERO), None);