maryada 0.2.1

No-std binary64 real interval arithmetic conforming to IEEE 1788.1
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Tests for the sealed real-interval convenience trait.

#![allow(clippy::arithmetic_side_effects)]

use core::fmt::Debug;

use maryada::{
    DecoratedInterval, Decoration, EnclosureOps, Interval, IntervalOps, add, decoration_part,
    set_dec, sqr,
};

fn exercise_common_api<T>()
where
    T: IntervalOps + Debug + PartialEq,
{
    let x = T::new(1.0, 2.0);
    let y = T::new(3.0, 4.0);

    assert_eq!(T::ZERO.bounds(), (0.0, 0.0));
    assert_eq!(T::ONE.bounds(), (1.0, 1.0));
    assert!(T::EMPTY.is_empty());
    assert!(T::ENTIRE.is_entire());
    assert_eq!(T::singleton(2.0).bounds(), (2.0, 2.0));

    assert_eq!((x + y).bounds(), (4.0, 6.0));
    assert_eq!((y - x).bounds(), (1.0, 3.0));
    assert_eq!((x * y).bounds(), (3.0, 8.0));
    assert_eq!((y / x).bounds(), (1.5, 4.0));
    assert_eq!((-x).bounds(), (-2.0, -1.0));

    let mut assigned = T::from(8.0);
    assigned += T::from(2.0);
    assert_eq!(assigned.bounds(), (10.0, 10.0));
    assigned -= T::from(2.0);
    assert_eq!(assigned.bounds(), (8.0, 8.0));
    assigned *= T::from(2.0);
    assert_eq!(assigned.bounds(), (16.0, 16.0));
    assigned /= T::from(2.0);
    assert_eq!(assigned.bounds(), (8.0, 8.0));
    assigned += 2.0;
    assigned -= 2.0;
    assigned *= 2.0;
    assigned /= 2.0;
    assert_eq!(assigned.bounds(), (8.0, 8.0));

    assert_eq!(x.sqr(), sqr(x));
    assert_eq!(x.powi(2), x.sqr());
    assert_eq!(x.mul_add(y, T::ONE), x * y + T::ONE);
    assert_eq!(x.hypot(T::ZERO), x.abs());
    assert_eq!(x.inner_rad(), 0.5);
    assert!(x.equal(T::new(1.0, 2.0)));
    assert!(x.subset(x.convex_hull(y)));
    assert_eq!(x.hull_value(4.0).bounds(), (1.0, 4.0));
    assert!(x.contains(1.5));
    assert!(T::ONE.is_singleton());
    assert!(x.is_bounded());
    assert!(x.intersects(y.convex_hull(x)));

    let (left, right) = x.bisect();
    assert_eq!(left.bounds(), (1.0, 1.5));
    assert_eq!(right.bounds(), (1.5, 2.0));
}

#[test]
fn common_api_is_generic_over_bare_and_decorated_intervals() {
    exercise_common_api::<Interval>();
    exercise_common_api::<DecoratedInterval>();
}

#[test]
fn methods_match_standard_free_functions() {
    let x = Interval::new(1.0, 2.0);
    let y = Interval::new(3.0, 4.0);

    assert_eq!(x + y, add(x, y));
    assert_eq!(x.sqr(), sqr(x));
    assert_eq!(x.mid_rad(), maryada::mid_rad(x));
    assert_eq!(x.cancel_plus(y), maryada::cancel_plus(x, y));
}

#[test]
fn decorated_methods_preserve_nai_and_decorations() {
    let nai = DecoratedInterval::NAI;
    assert!(nai.is_nai());
    assert!(nai.sqr().is_nai());
    assert!(!nai.intersects(DecoratedInterval::ENTIRE));
    let (left, right) = nai.bisect();
    assert!(left.is_nai());
    assert!(right.is_nai());

    let value = set_dec(Interval::new(1.0, 3.0), Decoration::Def);
    assert_eq!(decoration_part(value.sqr()), Decoration::Def);
    let (left, right) = value.bisect();
    assert_eq!(decoration_part(left), Decoration::Def);
    assert_eq!(decoration_part(right), Decoration::Def);
}