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

use super::*;

#[test]
fn random_fixed_envelope_versions_match_clean_reduction() {
    let mut state = 0x9e37_79b9_7f4a_7c15u64;
    for case in 0..48 {
        let vertices = 4 + case % 5;
        let mut initial_triplets = Vec::new();
        let mut updated_triplets = Vec::new();
        for v in 1..vertices {
            for u in 0..v {
                state ^= state << 13;
                state ^= state >> 7;
                state ^= state << 17;
                if state % 4 == 0 {
                    continue;
                }
                let first = 0.25 * (1 + state % 12) as f64;
                state ^= state << 13;
                state ^= state >> 7;
                state ^= state << 17;
                let second = 0.25 * (1 + state % 12) as f64;
                initial_triplets.push((u, v, first));
                updated_triplets.push((u, v, second));
            }
        }
        let initial = SparseDistanceMatrix::from_triplets(vertices, &initial_triplets).unwrap();
        let updated = SparseDistanceMatrix::from_triplets(vertices, &updated_triplets).unwrap();
        for modulus in [2, 3, 5] {
            let mut params = RipsParams::new(case % 3).with_modulus(modulus);
            params.threshold = (case % 2 == 0).then_some(2.0);
            let index = PersistenceIndex::compile(
                &initial,
                &params,
                IndexParams::default(),
                CertificateLimits::default(),
            )
            .unwrap();
            assert_eq!(
                index.diagram().bars,
                rips_persistence_sparse(&initial, &params).unwrap().bars,
                "initial case {case}, modulus {modulus}, edges {:?}, interfaces {:?}",
                initial.edges().collect::<Vec<_>>(),
                index.interfaces(),
            );
            let transition = index.transition(&updated).unwrap();
            assert_eq!(
                transition.index.diagram().bars,
                rips_persistence_sparse(&updated, &params).unwrap().bars,
                "updated case {case}, modulus {modulus}, edges {:?}, interfaces {:?}",
                updated.edges().collect::<Vec<_>>(),
                transition.index.interfaces(),
            );
        }
    }
}

#[test]
fn relative_index_keeps_ancestor_separators_and_updates_one_route() {
    let graph = SparseDistanceMatrix::from_triplets(
        7,
        &[
            (0, 1, 0.75),
            (0, 3, 0.5),
            (0, 5, 2.5),
            (0, 6, 1.75),
            (1, 2, 3.0),
            (1, 3, 2.5),
            (1, 4, 1.5),
            (1, 5, 3.0),
            (2, 3, 1.0),
            (2, 4, 0.75),
            (2, 5, 0.5),
            (2, 6, 0.5),
            (3, 4, 2.75),
            (3, 5, 2.75),
            (4, 5, 3.0),
            (4, 6, 0.5),
            (5, 6, 2.0),
        ],
    )
    .unwrap();
    let mut params = RipsParams::new(2).with_modulus(3);
    params.threshold = Some(2.0);
    let index = PersistenceIndex::compile(
        &graph,
        &params,
        IndexParams::default(),
        CertificateLimits::default(),
    )
    .unwrap();
    assert_eq!(index.interfaces()[0].mode, InterfaceMode::Relative);
    assert_eq!(
        index.diagram().bars,
        rips_persistence_sparse(&graph, &params).unwrap().bars
    );
    let root_separator = index.interfaces()[0].separator.clone();
    for interface in index.interfaces().into_iter().skip(1) {
        for vertex in &root_separator {
            if interface.vertices.contains(vertex) {
                assert!(interface.protected_vertices.contains(vertex));
            }
        }
    }

    let transition = index
        .transition_edits(&[IndexEdit::set_weight(0, 1, 0.8)])
        .unwrap();
    assert_eq!(transition.mode, IndexUpdateMode::Relative);
    assert!(transition.work.relative_nodes_rebuilt > 0);
    assert!(transition.work.relative_nodes_composed > 0);
    assert!(transition.work.nodes_shared > 0);
    assert_eq!(
        transition.index.diagram().bars,
        rips_persistence_sparse(transition.index.graph(), &params)
            .unwrap()
            .bars
    );
}