long degree(MultilayerNetwork& mnet, std::string vertex, std::set<std::string> active_networks) {
int tmp_degree = 0;
for (std::set<std::string>::iterator net=active_networks.begin(); net!=active_networks.end(); ++net) {
tmp_degree += mnet.getNetwork(*net)->getDegree(mnet.getLocalVertexName(vertex,*net));
}
return tmp_degree;
}
long in_degree(MultilayerNetwork& mnet, vertex_id vertex, std::set<network_id> active_networks) {
int tmp_degree = 0;
for (std::set<network_id>::iterator net=active_networks.begin(); net!=active_networks.end(); ++net) {
tmp_degree += mnet.getNetwork(*net)->getInDegree(mnet.getLocalVertexId(vertex,*net));
}
return tmp_degree;
}
void BAEvolutionModel::evolution_step(MultilayerNetwork& mnet, network_id net) {
Random rand;
std::set<intralayer_edge_id> universe;
mnet.getVertexes(universe);
std::set<intralayer_edge_id> choice;
rand.getKElements(universe,choice,1);
intralayer_edge_id new_global_vertex = *choice.begin();
std::cout << "BA add " << new_global_vertex << std::endl;
// Randomly select m nodes with probability proportional to their degree
/*
set<vertex_id> target_nodes;
ba_choice(mnet->getNetwork(net),num_of_neighbors,target_nodes);
// Add a new node to this network, taken from the Universe
vertex_id new_vertex = mnet.getNetwork(net)->addVertex();
mnet.map(global_vertex,new_vertex,net);
//mnet->
for (set<vertex_id>::iterator node=target_nodes.begin(); node!=target_nodes.end(); ++node) {
mnet.getNetwork(layer)->addEdge(new_vertex,*node);
}
*/
}
// Only for named networks
void flatten(MultilayerNetwork& mnet, MNET_FLATTENING_ALGORITHM algorithm,
Network& net) {
std::set<intralayer_edge_id> vertexes;
mnet.getVertexes(vertexes);
std::set<intralayer_edge_id>::const_iterator v_it;
for (v_it = vertexes.begin(); v_it != vertexes.end(); ++v_it) {
net.addVertex(mnet.getVertexName(*v_it));
}
std::set<intralayer_edge_id> edges;
mnet.getEdges(edges);
std::set<intralayer_edge_id>::const_iterator e_it;
for (e_it = edges.begin(); e_it != edges.end(); ++e_it) {
if (! net.containsEdge(mnet.getVertexName((*e_it).v1),mnet.getVertexName((*e_it).v2)))
net.addEdge(mnet.getVertexName((*e_it).v1),mnet.getVertexName((*e_it).v2));
}
}
long degree(MultilayerNetwork& mnet, std::string vertex, std::string network_name) {
return mnet.getNetwork(network_name)->getDegree(mnet.getLocalVertexName(vertex,network_name));
}
long degree(MultilayerNetwork& mnet, vertex_id vertex, network_id network) {
return mnet.getNetwork(network)->getDegree(mnet.getLocalVertexId(vertex,network));
}
void testMultilayerNetwork() {
log("**************************************************************");
log("TESTING basic multilayer network components (global_vertex_id, global_edge_id, network_id)...",false);
/*
* these are normally automatically created
* by functions of the MultilayerNetwork class.
* However, here we test them by directly manipulating them.
*/
network_id nid1 = 0;
network_id nid2 = 1;
vertex_id vid1 = 0;
vertex_id vid2 = 1;
vertex_id vid3 = 0;
global_vertex_id gvid1(vid1,nid1);
global_vertex_id gvid2(vid2,nid1);
global_vertex_id gvid3(vid3,nid2);
// a directed edge
global_edge_id e1(vid1,vid2,nid1,true);
// another directed edge
global_edge_id e2(vid2,vid1,nid1,true);
// a third directed edge
global_edge_id e3(vid2,vid1,nid1,true);
// an undirected edge
global_edge_id e4(vid1,vid2,nid1,false);
// another undirected edge
global_edge_id e5(vid2,vid1,nid1,false);
if (e1==e2) throw FailedUnitTestException("Wrong edge_id comparison");
if (e2!=e3) throw FailedUnitTestException("Wrong edge_id comparison");
if (e4!=e5) throw FailedUnitTestException("Wrong edge_id comparison");
log("done!");
log("******************************************");
log("TESTING MultilayerNetwork");
log("REQUIRES Network class having been tested");
log("Creating an empty multiple network...",false);
MultilayerNetwork mnet;
log("done!");
log("Creating and adding three anonymous undirected and directed networks...",false);
// Network 1
Network net1(false,false,false);
vertex_id n1v0 = net1.addVertex();
vertex_id n1v1 = net1.addVertex();
/*vertex_id n1v2 = */net1.addVertex();
// Network 2
Network net2(false,true,false);
vertex_id n2v0 = net2.addVertex();
vertex_id n2v1 = net2.addVertex();
vertex_id n2v2 = net2.addVertex();
// Network 3
Network net3(false,true,false);
vertex_id n3v0 = net3.addVertex();
vertex_id n3v1 = net3.addVertex();
vertex_id n3v2 = net3.addVertex();
network_id n1 = mnet.addNetwork(net1);
network_id n2 = mnet.addNetwork(net2);
network_id n3 = mnet.addNetwork(net3);
if (mnet.getNumNetworks()!=3) throw FailedUnitTestException("Wrong number of networks");
log("done!");
// TODO Check named networks
log("Adding five edges...",false); // they can also be added directly to the single networks
mnet.getNetwork(n1).addEdge(n1v0,n1v1);
mnet.getNetwork(n2).addEdge(n2v0,n2v1);
mnet.getNetwork(n2).addEdge(n2v1,n2v2);
mnet.getNetwork(n3).addEdge(n3v0,n3v2);
mnet.getNetwork(n3).addEdge(n3v1,n3v2);
if (mnet.getNumEdges()!=5) throw FailedUnitTestException("Wrong number of global edges");
log("done!");
// Iterating through global edges and vertexes
std::set<global_vertex_id> vertexes;
std::set<global_edge_id> edges;
log("TEST SUCCESSFULLY COMPLETED (MultilayerNetwork class - numeric identifiers)");
log("Printing final multiple network information:");
print(mnet);
}
double modularity(MultilayerNetwork& mnet,
std::map<network_id,std::map<vertex_id,long> >& groups, double c) {
double res = 0;
double mu2 = 0;
std::set<network_id> networks;
mnet.getNetworks(networks);
std::set<network_id>::iterator network_iterator;
for (network_iterator=networks.begin(); network_iterator!=networks.end(); network_iterator++) {
network_id net = *network_iterator;
double m_net = 2*mnet.getNetwork(net)->getNumEdges();
mu2 += m_net;
// FIX TO THE ORIGINAL EQUATION WHEN THERE ARE NO EDGES
if (m_net == 0)
continue;
std::set<vertex_id> vertexes;
mnet.getNetwork(net)->getVertexes(vertexes);
for (std::set<vertex_id>::iterator v_i = vertexes.begin();
v_i != vertexes.end(); v_i++) {
for (std::set<vertex_id>::iterator v_j = vertexes.begin();
v_j != vertexes.end(); v_j++) {
// if (*v_i==*v_j) continue; SEEMS REASONABLE, BUT NOT IN DEFINITION...
vertex_id global_v_i = mnet.getGlobalVertexId(*v_i, net);
vertex_id global_v_j = mnet.getGlobalVertexId(*v_j, net);
//std::cout << global_v_i << " " << global_v_j << std::endl;
if (groups[net][global_v_i] == groups[net][global_v_j]) {
//std::cout << "Same group!" << std::endl;
//if (mnet.getNetwork(net)->containsEdge(*v_i,*v_j))
// std::cout << "Edge" << std::endl;
long k_i = degree(mnet, global_v_i, net);
long k_j = degree(mnet, global_v_j, net);
int a_ij =
mnet.getNetwork(net)->containsEdge(
*v_i,
*v_j) ? 1.0 : 0.0;
res += a_ij - k_i * k_j / (2 * m_net);
//std::cout << global_v_i << " " << global_v_j << " " << (a_ij - k_i * k_j / (2 * m_net)) << std::endl;
//std::cout << "->" << res << std::endl;
}
}
}
std::cout << "->" << m_net << std::endl;
}
double mod = res;
std::set<network_id>::iterator network_iterator1, network_iterator2;
std::set<vertex_id>::iterator vertex_iterator;
std::set<vertex_id> vertexes;
mnet.getVertexes(vertexes);
for (network_iterator1=networks.begin(); network_iterator1!=networks.end(); ++network_iterator1) {
network_id net1 = *network_iterator1;
for (network_iterator2=networks.begin(); network_iterator2!=networks.end(); ++network_iterator2) {
network_id net2 = *network_iterator2;
if (net1==net2) continue;
for (vertex_iterator=vertexes.begin(); vertex_iterator!=vertexes.end(); ++vertex_iterator) {
vertex_id v = *vertex_iterator;
if (mnet.containsVertex(v,net1) &&
mnet.containsVertex(v,net2)) {
mu2+=c;
if (groups[net1][v] == groups[net2][v]) {
res += c; // or omega
}
}
}
}
}
std::cout << "->" << mod << " " << (res-mod) << "-" << mu2 << std::endl;
return 1 / (mu2) * res;
}
