unit-intervals 0.1.0

Constrained f32/f64 wrapper types for normalized [0, 1] and [-1, 1] values.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

use unit_intervals::{SignedUnitInterval, UnitInterval};

#[test]
fn unit_interval_core_float_methods_are_available_without_std() {
    let half = UnitInterval::<f64>::HALF;

    let abs: UnitInterval<f64> = half.abs();
    let signum: f64 = half.signum();
    let copysign: f64 = half.copysign(-1.0);
    let recip: f64 = half.recip();

    assert_eq!(abs.get(), 0.5_f64.abs());
    assert_eq!(signum, 1.0);
    assert_eq!(copysign, -0.5);
    assert_eq!(recip, 2.0);
    assert!(half.is_sign_positive());
    assert!(!half.is_sign_negative());
    assert!(half.is_finite());
    assert!(!half.is_infinite());
    assert!(!half.is_nan());
}

#[test]
fn signed_unit_interval_core_float_methods_are_available_without_std() {
    let negative = SignedUnitInterval::<f32>::new(-0.5).unwrap();

    let absolute: UnitInterval = negative.abs();
    let signum: SignedUnitInterval = negative.signum();
    let copysign: SignedUnitInterval = negative.copysign(1.0);
    let recip: f32 = negative.recip();

    assert_eq!(absolute.get(), 0.5);
    assert_eq!(signum.get(), -1.0);
    assert_eq!(copysign.get(), 0.5);
    assert_eq!(recip, -2.0);
    assert!(!negative.is_sign_positive());
    assert!(negative.is_sign_negative());
    assert!(negative.is_finite());
    assert!(!negative.is_infinite());
    assert!(!negative.is_nan());
}