icentral-alg 0.1.0

A Rust crate for incremental and parallel betweenness centrality algorithms.
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
152
153
154
155
156
157
158
159
160
161
162
163

crate::ix!();

pub fn icentral_iter_insertion(
    subgraph_len:          usize,
    delta_bc_of_vertices:  &mut BetweennessScores,
    component:             &mut Component,
    s:                     NodeId,
    edge:                  Edge,
    workspace:             &mut ICentralWorkspace,
    dd:                    f64,
    use_d_1:               bool,
    op:                    Operation) 
-> Result<(),BetweennessCentralityError>  
{
    bbfs(
        None,
        workspace, 
        component, 
        s
    );

    rbfs(
        delta_bc_of_vertices, 
        component, 
        s, 
        workspace, 
        Some(RbfsOperation::Subtraction),
    );

    partial_bbfs_addition(
        workspace, 
        component, 
        s, 
        edge
    );

    rbfs(
        delta_bc_of_vertices,
        component, 
        s, 
        workspace, 
        Some(RbfsOperation::Addition),
    );

    Ok(())
}

pub fn icentral_iter_deletion(
    delta_bc_of_vertices: &mut BetweennessScores,
    component:            &mut Component,
    s:                    NodeId,
    edge:                 Edge,
    workspace:            &mut ICentralWorkspace) 
-> Result<(),BetweennessCentralityError>  
{
    bbfs(
        None,
        workspace, 
        component, 
        s
    );

    rbfs(
        delta_bc_of_vertices, 
        component, 
        s, 
        workspace, 
        Some(RbfsOperation::Subtraction),
    );

    partial_bbfs_deletion(
        workspace, 
        component, 
        s, 
        &edge
    );

    rbfs(
        delta_bc_of_vertices, 
        component, 
        s, 
        workspace, 
        Some(RbfsOperation::Addition),
    );

    Ok(())
}

/**
  | Computes the increments/decrements
  | to BC of a subgraph in @component
  | 
  | This function deals with nodes indexed
  | from 0 to N-1 in the passed subgraph and
  | knows nothing about the original graph,
  | the caller must add the deltas to the
  | BC vector of the original graph
  |
  */
pub fn icentral_iter(

    delta_bc_of_vertices:   &mut BetweennessScores,

    // component could be BiconnectedComponents,
    // MinimumUnionCycle, or just a graph
    component: &mut Component,

    // source of the iteration
    s:         NodeId,

    // inserted edge
    edge:      Edge,

    //TODO to be used later?
    workspace: &mut ICentralWorkspace,

    dd:        Option<f64>,
    use_d_1:   Option<bool>,
    op:        Option<Operation>) 
-> Result<(),BetweennessCentralityError>  
{
    let mut dd:   f64 = dd.unwrap_or(-1.0);

    let edge = match dd > 0.0 {
        true  => edge.reversed(),
        false => edge
    };

    dd = dd.abs();

    let use_d_1: bool = use_d_1.unwrap_or(true);

    let op: Operation = op.unwrap_or(Operation::Insertion);

    let len = component.num_nodes();

    workspace.init_all(len);

    match op {

        Operation::Insertion => icentral_iter_insertion(
            len,
            delta_bc_of_vertices, 
            component, 
            s, 
            edge, 
            workspace, 
            dd, 
            use_d_1, 
            op
        )?,

        Operation::Deletion  => icentral_iter_deletion(
            delta_bc_of_vertices, 
            component, 
            s, 
            edge, 
            workspace
        )?,
    }

    Ok(())
}