hypergraphx 0.0.5

A hypergraph library for Rust, based on the Python library of the same name.
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

#![allow(unused)]
use std::rc::Rc;

use super::{MultiplexBase, MultiplexNode, weak_layers::WeakLayer};

mod directed;
mod undirected;

pub use directed::DirectedLayer;
pub use undirected::UndirectedLayer;

#[derive(Clone, PartialEq, Eq)]
pub enum Layer<N, L> {
    Undirected(UndirectedLayer<N, L>),
    Directed(DirectedLayer<N, L>),
}

impl<N, L> Layer<N, L>
where
    N: Clone,
    L: Clone,
{
    pub(crate) fn rebase(&mut self, nodes: Rc<MultiplexBase<N>>) {
        match self {
            Layer::Undirected(ul) => ul.nodes = nodes.clone(),
            Layer::Directed(dl) => dl.nodes = nodes.clone(),
        }
    }

    fn rebase_with<F, N2>(&self, nodes: Rc<MultiplexBase<N>>, f: F) -> Layer<N2, L>
    where
        F: Fn(&MultiplexNode<N>) -> N2,
        N2: Clone,
        L: Clone,
        N: Clone,
    {
        match self {
            Layer::Undirected(ul) => Layer::Undirected({
                let u = Rc::as_ref(&nodes).iter().map(|n| f(n));

                let new_base = MultiplexBase::new(u);

                UndirectedLayer {
                    edges: ul.edges.clone(),
                    weight: ul.weight.clone(),
                    edge_type: ul.edge_type,
                    nodes: new_base,
                    incidence: ul.incidence.clone(),
                }
            }),
            Layer::Directed(dl) => Layer::Directed({
                let u = Rc::as_ref(&nodes).iter().map(|n| f(n));

                let new_base = MultiplexBase::new(u);

                DirectedLayer {
                    edges: dl.edges.clone(),
                    weight: dl.weight.clone(),
                    edge_type: dl.edge_type,
                    nodes: new_base,
                    incidence: dl.incidence.clone(),
                }
            }),
        }
    }

    pub(crate) fn restrict_to(&self, node_map: &Vec<Option<usize>>) -> Layer<N, L>
    where
        L: Clone,
    {
        match self {
            Layer::Undirected(ul) => Layer::Undirected(ul.restrict_to(node_map)),
            Layer::Directed(dl) => Layer::Directed(dl.restrict_to(node_map)),
        }
    }

    pub(crate) fn weaken(self) -> WeakLayer<L>
    where
        L: Clone,
    {
        match self {
            Layer::Undirected(ul) => WeakLayer::Undirected(ul.weaken()),
            Layer::Directed(dl) => WeakLayer::Directed(dl.weaken()),
        }
    }
}