modppl 0.3.0

a experimental library for probabilistic programming in Rust.
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use modppl::Trie;


// inserting a trie into a root and then removing it should yield the previous tries
#[test]
pub fn test_add_remove_inverse() {
    let mut root = Trie::<i32>::new();

    let mut subin = Trie::<i32>::new();
    subin.w_observe("mother", 1, 2.);
    subin.w_observe("world", 2, 1.14);
    
    let root_before = root.clone();

    root.insert("hello", subin.clone());
    let subout = root.remove("hello");
    assert_eq!(subin, subout.unwrap());

    assert_eq!(root_before, root);
}

// searching the address of a observed weighted value should yield the leaf trie
#[test]
pub fn test_search_w_observed_value() {
    let mut root = Trie::<i32>::new();

    root.w_observe("test", 2, -3.4);
    let leaf = Trie::leaf(2, -3.4);
    let found = root.search("test").expect("oberved weighted value not found.");
    assert_eq!(*found, leaf);

    root.w_observe("test/deep/nested", 5, -1.2);
    let found = root.search("test/deep/nested").expect("observed weighted value not found.");
    let leaf = Trie::leaf(5, -1.2);
    assert_eq!(*found, leaf);
}

// searching the address of an inserted subtrie should yield the subtrie
#[test]
pub fn test_search_inserted_subtrie() {
    let mut root = Trie::<i32>::new();
    let mut subin = Trie::<i32>::new();

    subin.w_observe("a", 3, -3.1);
    subin.w_observe("b", 1, -0.1);

    root.insert("child", subin.clone());
    let found = root.search("child").expect("inserted subtrie not found.");
    assert_eq!(*found, subin);

    root.insert("great/grand/child", subin.clone());
    let found = root.search("great/grand/child").expect("inserted subtrie not found.");
    assert_eq!(*found, subin);
}

// taking the difference of measured weights before and after
// w_observeing a value should yield the weight of the w_observe
#[test]
pub fn test_weighted_observation() {
    let mut root = Trie::<i32>::new();
    root.w_observe("test", 0, -1.3);
    let w_before= root.weight();
    let w_sub = -5.3;
    root.w_observe("test/deep/nested", 3, w_sub);
    let w_after = root.weight();
    assert_eq!(w_after - w_before, w_sub)
}

// taking the difference of measured weights before and after
// inserting a subtrie should yield the weight of the subtrie
#[test]
pub fn test_weighted_subtrie() {
    let mut root = Trie::<i32>::new();
    let mut sub = Trie::leaf(6, -0.4);
    sub.w_observe("deep/nested", -4, 0.4);
    let w_sub = sub.weight();
    let w_before = root.weight();
    root.insert("test", sub);
    let w_after = root.weight();
    assert_eq!(w_after - w_before, w_sub);
}

// w_observeing an occupied address should panic
#[test]
#[should_panic]
pub fn test_insert_into_occupied_panic() {
    let mut root = Trie::<(i32,u8)>::new();
    root.w_observe("some/address", (-10431451, 200), -0.5);
    root.w_observe("some/address", (-1,0), 0.);
}

// unwrapping the inner value from an empty trie should panic
#[test]
#[should_panic]
pub fn test_unwrap_inner_unchecked_panic() {
    let root = Trie::<u8>::new();
    root.expect_inner("failed");
}

// taking the inner value from an empty trie should panic
#[test]
#[should_panic]
pub fn test_take_inner_unchecked_panic() {
    let root = Trie::<u8>::new();
    root.expect_inner("failed");
}

// an assortment of different tests of Trie
#[test]
pub fn test_trie_extended_example() {
    let mut trie = Trie::new();
    trie.w_observe("hello / world", 1.2, 1.5);
    trie.w_observe("hello / mom", 1.0, 1.5);
    trie.w_observe("hello / world / player", 1.0, 1.5);
    let t = trie.search("hello / world");
    assert_eq!(t.unwrap().weight(), 3.0);
    assert_eq!(trie.weight(), 4.5);

    let mut sub = Trie::new();
    sub.w_observe("test", 1.0, 1.5);
    sub.w_observe("test / leaf", 1.0, 2.0);
    trie.insert("other", sub);

    assert_eq!(trie.weight(), 8.0);

    let helloworld = trie.remove("hello / world").unwrap();

    assert_eq!(helloworld.weight(), 3.0);
    assert_eq!(trie.weight(), 8.0 - 3.0);

    let mut hw_dup = Trie::leaf(1.1, 1.5);
    hw_dup.w_observe("player", 1.0, 1.5);
    assert_ne!(helloworld, hw_dup);
    let v = hw_dup.take_inner().unwrap();
    hw_dup.replace_inner(v+0.1_f32);
    assert_eq!(helloworld, hw_dup);

    let l = helloworld.search("player").unwrap();
    assert!(l.is_leaf());
    let v = l.clone().take_inner().unwrap();
    assert_eq!(v, 1.0);
}