dorset 0.1.0

A rust implementation of Stan Math automatic differentiation library.
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

//! Operation subtraction.
use super::*;
pub use std::ops::Sub;

fn chain_subtraction(vi: &Vari) {
    let adj = vi.adj();
    match (vi.a.clone(), vi.b.clone()) {
        (Operand::Vari(ptr), Operand::Data(_)) => {
            let avi: &mut Vari = ptr.clone().into();
            let avi_adj = avi.adj();
            avi.set_adj(avi_adj + adj);
        }
        (Operand::Data(_), Operand::Vari(ptr)) => {
            let bvi: &mut Vari = ptr.clone().into();
            let bvi_adj = bvi.adj();
            bvi.set_adj(bvi_adj - adj);
        }
        (Operand::Vari(ap), Operand::Vari(bp)) => {
            let avi: &mut Vari = ap.clone().into();
            let avi_adj = avi.adj();
            let bvi: &mut Vari = bp.clone().into();
            let bvi_adj = bvi.adj();
            avi.set_adj(avi_adj + adj);
            bvi.set_adj(bvi_adj - adj);
        }
        _ => {}
    }
}

binop!(impl Sub, sub
       for Var, Real, |x, y| x - y,
       for Real, Var, |x, y| x - y,
       for Var, Var, |x, y| x - y,
       chain Fn = chain_subtraction);

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

    #[test]
    fn sub() {
        let mut x: Real = 3.6;
        let mut y: Real = 3.0;
        let stack = Rc::new(RefCell::new(ChainStack::new()));
        let vx = var!(stack, x);
        let vy = var!(stack, y);
        let mut v = &vx - &vy;
        v.grad();
        assert_eq!(v.val(), x - y);
        assert_eq!(vx.adj(), 1.0);
        assert_eq!(vy.adj(), -1.0);

        v.set_zero_all_adjoints();
        y = 8.9;
        v = &vx - &y;
        v.grad();
        assert_eq!(v.val(), x - y);
        assert_eq!(vx.adj(), 1.0);
        assert_eq!(vy.adj(), 0.0);

        v.set_zero_all_adjoints();
        x = 83.1;
        v = &x - &vy;
        v.grad();
        assert_eq!(v.val(), x - vy.val());
        assert_eq!(vx.adj(), 0.0);
        assert_eq!(vy.adj(), -1.0);
    }
}