cnetworks 0.7.0

A set of tools for creating and manipulating complex networks.
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

//! Test linking/unlinking and connecting/disconnecting nodes.
use cnetworks::*;

#[test]
fn test_link() {
    let mut net = Network::new(10, Model::None, Weight::default());

    assert!(net.links().count() == 0);
    for i in net.nodes() {
        for j in net.nodes() {
            assert!(net.get_link(i, j).unwrap_or(None).is_none())
        }
    }
    for node in net.nodes() {
        assert!(net.links_of(node).unwrap().is_empty());
    }

    net.link(1, 2).unwrap();
    assert!(net.links().count() == 1);
    assert!((net.get_link(1, 2).unwrap().unwrap() - 1.0).abs() < f64::EPSILON);
    assert!((net.get_link(2, 1).unwrap().unwrap() - 1.0).abs() < f64::EPSILON);

    net.link_exact(2, 3, 0.25).unwrap();
    assert!(net.links().count() == 2);
    assert!((net.get_link(2, 3).unwrap().unwrap() - 0.25).abs() < f64::EPSILON);
    assert!((net.get_link(3, 2).unwrap().unwrap() - 0.25).abs() < f64::EPSILON);

    assert_eq!(net.link(1, 100).unwrap_err(), cn::Err::NoSuchNode(100));
    assert_eq!(net.get_link(1, 100).unwrap_err(), cn::Err::NoSuchNode(100));
    assert!(net.links().count() == 2);
}

#[test]
fn test_unlink() {
    let mut net = Network::new(3, Model::None, Weight::default());
    assert!(net.links().count() == 0);

    net.link(0, 1).unwrap();
    assert!(net.links().count() == 1);
    assert_eq!(net.unlink_safe(0, 1).unwrap(), None);
    assert!((net.unlink(0, 1).unwrap().unwrap() - 1.0).abs() < f64::EPSILON);

    assert_eq!(net.get_link(0, 1).unwrap(), None);
    assert_eq!(net.get_link(1, 0).unwrap(), None);
    assert!(net.links().count() == 0);
    assert!(!net.links().any(|(i, j)| i == 0 && j == 1 || i == 1 && j == 0));

    assert_eq!(net.unlink(0, 100).unwrap_err(), cn::Err::NoSuchNode(100));
    assert_eq!(
        net.unlink_safe(0, 100).unwrap_err(),
        cn::Err::NoSuchNode(100)
    );

    net.link(0, 1).unwrap();
    net.link(1, 2).unwrap();
    net.link(0, 2).unwrap();
    assert!(net.links().count() == 3);
    assert!((net.unlink_safe(0, 1).unwrap().unwrap() - 1.0).abs() < f64::EPSILON);

    assert_eq!(net.get_link(0, 1).unwrap(), None);
    assert_eq!(net.get_link(1, 0).unwrap(), None);
    assert!(net.links().count() == 2);
    assert!(!net.links().any(|(i, j)| i == 0 && j == 1 || i == 1 && j == 0));
}

#[test]
fn test_disconnect() {
    let mut net = Network::new(3, Model::None, Weight::default());
    let idxes: Vec<_> = net.nodes().collect();
    for &i in &idxes {
        for &j in &idxes {
            // Ignore the "self link" errors
            net.link(i, j).unwrap_or(None);
        }
    }
    assert_eq!(net.links().count(), 3);

    for (target, weight) in net.disconnect_safe(0).unwrap().unwrap() {
        assert!(vec![1, 2].contains(&target));
        assert!((weight - 1.0).abs() < f64::EPSILON);
    }
    assert_eq!(net.links().count(), 1);

    assert_eq!(net.get_link(0, 1).unwrap(), None);
    assert_eq!(net.disconnect(0).unwrap(), cn::IndexMap::default());
    assert!((net.disconnect(1).unwrap()[&2] - 1.0).abs() < f64::EPSILON);
    assert_eq!(net.disconnect(2).unwrap(), cn::IndexMap::default());
    assert_eq!(net.disconnect(100).unwrap_err(), cn::Err::NoSuchNode(100));
}

#[test]
fn test_attach_detach() {
    let mut net = Network::new(0, Model::None, Weight::default());
    assert_eq!(net.size(), 0);

    for i in [0, 1, 2] {
        net.attach(i).unwrap();
    }
    assert_eq!(net.size(), 3);
    assert_eq!(net.size_connected(), 0);

    for i in 0..3 {
        assert!(net.exists(i));
    }

    assert_eq!(net.attach(0).unwrap_err(), cn::Err::NodeExists(0));

    net.detach(2).unwrap();
    assert_eq!(net.size(), 2);
    assert_eq!(net.nodes().collect::<Vec<_>>(), vec![0, 1]);
    for i in 0..2 {
        assert!(net.exists(i));
    }
    assert!(!net.exists(2));
}