holos-tda 0.9.0

Vietoris-Rips persistence and checked degree-Rips modules
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
143
144
145
146
147
148
149
150
151

use super::*;

fn column(terms: &[(usize, u32)]) -> Vec<ZigzagTerm> {
    terms
        .iter()
        .map(|&(target, coefficient)| ZigzagTerm {
            target,
            coefficient,
        })
        .collect()
}

#[test]
fn identity_chain_is_one_complete_interval() {
    let module = ZigzagModule::new(
        3,
        vec![1, 1, 1],
        vec![
            ZigzagMap::new(ZigzagDirection::Forward, vec![column(&[(0, 1)])]),
            ZigzagMap::new(ZigzagDirection::Forward, vec![column(&[(0, 1)])]),
        ],
        ZigzagLimits::default(),
    )
    .unwrap();
    let barcode = module.decompose().unwrap();
    assert_eq!(barcode.rank(0, 2), Some(1));
    assert_eq!(barcode.intervals.len(), 1);
    assert_eq!(barcode.intervals[0].start, 0);
    assert_eq!(barcode.intervals[0].end, 2);
    assert_eq!(barcode.intervals[0].multiplicity, 1);
}

#[test]
fn zero_map_splits_two_point_intervals() {
    let module = ZigzagModule::new(
        5,
        vec![1, 1],
        vec![ZigzagMap::new(ZigzagDirection::Forward, vec![vec![]])],
        ZigzagLimits::default(),
    )
    .unwrap();
    let intervals = module.decompose().unwrap().intervals;
    assert_eq!(
        intervals
            .iter()
            .map(|interval| (interval.start, interval.end, interval.multiplicity))
            .collect::<Vec<_>>(),
        vec![(0, 0, 1), (1, 1, 1)]
    );
}

#[test]
fn fork_distinguishes_shared_and_independent_event_classes() {
    let shared = ZigzagModule::new(
        3,
        vec![1, 2, 1],
        vec![
            ZigzagMap::new(ZigzagDirection::Backward, vec![column(&[(0, 1)]), vec![]]),
            ZigzagMap::new(ZigzagDirection::Forward, vec![column(&[(0, 1)]), vec![]]),
        ],
        ZigzagLimits::default(),
    )
    .unwrap()
    .decompose()
    .unwrap();
    assert!(
        shared
            .intervals
            .iter()
            .any(|item| item.start == 0 && item.end == 2)
    );

    let independent = ZigzagModule::new(
        3,
        vec![1, 2, 1],
        vec![
            ZigzagMap::new(ZigzagDirection::Backward, vec![column(&[(0, 1)]), vec![]]),
            ZigzagMap::new(ZigzagDirection::Forward, vec![vec![], column(&[(0, 1)])]),
        ],
        ZigzagLimits::default(),
    )
    .unwrap()
    .decompose()
    .unwrap();
    assert_eq!(independent.rank(0, 2), Some(0));
    assert_eq!(
        independent
            .intervals
            .iter()
            .map(|item| (item.start, item.end, item.multiplicity))
            .collect::<Vec<_>>(),
        vec![(0, 1, 1), (1, 2, 1)]
    );
}

#[test]
fn every_orientation_recovers_direct_sum_multiplicities() {
    let expected = vec![(0, 2, 2), (0, 4, 1), (1, 3, 1), (2, 2, 1), (4, 4, 2)];
    let copies = expected
        .iter()
        .flat_map(|&(start, end, multiplicity)| std::iter::repeat_n((start, end), multiplicity))
        .collect::<Vec<_>>();
    let bases = (0..5)
        .map(|node| {
            copies
                .iter()
                .enumerate()
                .filter_map(|(copy, &(start, end))| (start <= node && node <= end).then_some(copy))
                .collect::<Vec<_>>()
        })
        .collect::<Vec<_>>();
    let dimensions = bases.iter().map(Vec::len).collect::<Vec<_>>();

    for modulus in [2, 3, 5] {
        for directions in 0..16 {
            let maps = (0..4)
                .map(|position| {
                    let direction = if directions & (1 << position) == 0 {
                        ZigzagDirection::Forward
                    } else {
                        ZigzagDirection::Backward
                    };
                    let (source, target) = match direction {
                        ZigzagDirection::Forward => (&bases[position], &bases[position + 1]),
                        ZigzagDirection::Backward => (&bases[position + 1], &bases[position]),
                    };
                    let columns = source
                        .iter()
                        .map(|copy| {
                            target
                                .iter()
                                .position(|candidate| candidate == copy)
                                .map_or_else(Vec::new, |target| column(&[(target, 1)]))
                        })
                        .collect();
                    ZigzagMap::new(direction, columns)
                })
                .collect();
            let actual =
                ZigzagModule::new(modulus, dimensions.clone(), maps, ZigzagLimits::default())
                    .unwrap()
                    .decompose()
                    .unwrap()
                    .intervals
                    .iter()
                    .map(|interval| (interval.start, interval.end, interval.multiplicity))
                    .collect::<Vec<_>>();
            assert_eq!(actual, expected, "modulus {modulus}, mask {directions}");
        }
    }
}