spaces 6.0.0

Set/space primitives for defining machine learning problems.
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::prelude::*;
use std::ops::Range;

impl Space for Range<usize> {
    const DIM: usize = 1;

    type Value = usize;

    fn card(&self) -> Card {
        // TODO: when the Step trait drops, we can replace this with a direct call to
        // Step::steps_between.
        //      See https://github.com/rust-lang/rust/issues/42168
        Card::Finite(self.len())
    }

    fn contains(&self, val: &usize) -> bool { Range::contains(&self, val) }
}

impl OrderedSpace for Range<usize> {
    fn min(&self) -> Option<usize> { Some(self.start) }

    fn max(&self) -> Option<usize> { Some(self.end - 1) }
}

impl FiniteSpace for Range<usize> {
    fn to_ordinal(&self) -> Range<Self::Value> { self.clone() }
}

impl Union for Range<usize> {
    fn union(self, other: &Range<usize>) -> Range<usize> {
        Range {
            start: self.start.min(other.start),
            end: self.end.max(other.end)
        }
    }
}

impl Intersect for Range<usize> {
    fn intersect(self, other: &Range<usize>) -> Range<usize> {
        Range {
            start: self.start.max(other.start),
            end: self.end.min(other.end)
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[cfg(feature = "serialize")]
    extern crate serde_test;
    #[cfg(feature = "serialize")]
    use self::serde_test::{assert_tokens, Token};

    #[test]
    fn test_card() {
        fn check(size: usize) {
            let d = 0..size;

            assert_eq!(d.card(), Card::Finite(size));
        }

        check(5);
        check(10);
        check(100);
    }

    #[test]
    fn test_bounds() {
        fn check(size: usize) {
            let d = 0..size;

            assert_eq!(d.inf().unwrap(), 0);
            assert_eq!(d.sup().unwrap(), size - 1);

            assert!(d.contains(&0));
            assert!(d.contains(&(size - 1)));
            assert!(!d.contains(&size));
        }

        check(5);
        check(10);
        check(100);
    }

    #[test]
    fn test_to_ordinal() {
        assert_eq!((0..1).to_ordinal(), 0..1);
        assert_eq!((0..5).to_ordinal(), 0..5);
        assert_eq!((0..10).to_ordinal(), 0..10);
    }

    #[cfg(feature = "serialize")]
    #[test]
    fn test_serialisation() {
        fn check(size: usize) {
            let d = Ordinal::new(size);

            assert_tokens(
                &d,
                &[
                    Token::NewtypeStruct { name: "Ordinal", },
                    Token::U64(size as u64),
                ],
            );
        }

        check(5);
        check(10);
        check(100);
    }
}