open-hypergraphs 0.3.1

Data-Parallel Algorithms for Open Hypergraphs
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

use open_hypergraphs::array::vec::*;
use open_hypergraphs::lax;
use open_hypergraphs::strict::eval::*;

use crate::theory::polycirc::*;

use crate::eval::eval::apply;

pub type LaxTerm = lax::OpenHypergraph<Obj, Arr>;

fn lax_arr(op: Arr) -> LaxTerm {
    use open_hypergraphs::strict::OpenHypergraph;
    let (a, b) = arr_type(&op);
    let f = OpenHypergraph::singleton(op, mktype(a), mktype(b));
    lax::OpenHypergraph::from_strict(f)
}

////////////////////////////////////////////////////////////////////////////////
// Test programs

// NOTE: this is really testing *composition* of lax open hypergraphs: note how lax_arr creates a
// LaxTerm, not a Term.
fn square() -> Option<Term> {
    use Arr::*;
    let lhs = lax_arr(Copy);
    let rhs = lax_arr(Mul);
    let term = (&lhs >> &rhs)?;
    Some(term.to_strict())
}

fn one_plus_one() -> Option<Term> {
    use Arr::*;
    let lhs = &lax_arr(One) | &lax_arr(One);
    let rhs = lax_arr(Add);
    let term = (&lhs >> &rhs)?;
    Some(term.to_strict())
}

////////////////////////////////////////////////////////////////////////////////
// Tests

#[test]
fn test_square() {
    let f = square().unwrap();

    assert_eq!(f.source(), mktype(1));
    assert_eq!(f.target(), mktype(1));

    let inputs = VecArray(vec![3]);
    let result = eval::<VecKind, Obj, Arr, usize>(&f, inputs, apply).expect("eval failed");

    // 3**2
    assert_eq!(result, VecArray(vec![9]));
}

#[test]
fn test_one_plus_one() {
    let f = one_plus_one().unwrap();

    assert_eq!(f.source(), mktype(0));
    assert_eq!(f.target(), mktype(1));

    let inputs = VecArray(vec![]);
    let result = eval::<VecKind, Obj, Arr, usize>(&f, inputs, apply).expect("eval failed");

    // 3**2
    assert_eq!(result, VecArray(vec![2]));
}

#[test]
fn test_one_plus_one_algebraic() {
    use Arr::*;
    let one = LaxTerm::singleton(One, vec![], vec![Obj]);
    let lhs = &one | &one;
    let rhs = LaxTerm::singleton(Add, vec![Obj, Obj], vec![Obj]);

    let f = (&lhs >> &rhs).unwrap().to_strict();

    assert_eq!(f.source(), mktype(0));
    assert_eq!(f.target(), mktype(1));

    let inputs = VecArray(vec![]);
    let result = eval::<VecKind, Obj, Arr, usize>(&f, inputs, apply).expect("eval failed");

    // 3**2
    assert_eq!(result, VecArray(vec![2]));
}

#[test]
fn test_parallel_squares() {
    // ----[square]-----
    //
    // ----[square]-----
    let f = square().unwrap();
    let g = &f | &f;

    assert_eq!(f.source(), mktype(1));
    assert_eq!(f.target(), mktype(1));

    //let (_, result) = eval_layers::<usize>(&g, vec![3, 4], &[vec![0, 2], vec![1, 3]]);
    let result =
        eval::<VecKind, Obj, Arr, usize>(&g, VecArray(vec![3, 4]), apply).expect("eval failed");

    // 3**2, 4**2
    assert_eq!(result, VecArray(vec![9, 16]));
}