int internal_kin(deque<set<int> > & E, const deque<deque<int> > & member_list, int i) { int var_mate2=0; for(set<int>::iterator itss= E[i].begin(); itss!=E[i].end(); itss++) if(they_are_mate(i, *itss, member_list)) var_mate2++; return var_mate2; }
int cclu(deque<set<int>> &en, const deque<deque<int>> &member_list, const deque<deque<int>> &member_matrix, double ca) { double cc0 = compute_cc(en); cout << "Average Clustering coefficient... " << cc0 << " trying to reach " << ca << endl; deque<double> ccs; for (int i = 0; i < en.size(); i++) ccs.push_back(compute_cc(en, i)); double min_relative_inc = 1e-6; //int number_of_triangles=compute_tot_t(en); int num_p = min(int(en.size() / 10), 5); while (cc0 < ca) { double ccold = cc0; for (int y = 0; y < num_p; y++) for (int Ai = 0; Ai < en.size(); Ai++) { // ************************************************ rewiring while (true) { int random_node = irand(en.size() - 1); int a = random_from_set(en[random_node]); deque<int> not_ra; for (set<int>::iterator it_est = en[random_node].begin(); it_est != en[random_node].end(); it_est++) if (en[a].find(*it_est) == en[a].end() && *it_est != a) not_ra.push_back(*it_est); if (not_ra.size() == 0) break; int random_mate = not_ra[irand(not_ra.size() - 1)]; bool b1 = they_are_mate(a, random_mate, member_list); deque<int> out_nodes; for (set<int>::iterator it_est = en[a].begin(); it_est != en[a].end(); it_est++) if (they_are_mate(a, *it_est, member_list) == b1) out_nodes.push_back(*it_est); if (out_nodes.size() == 0) break; int t1; int old_node = choose_the_least(en, out_nodes, a, t1); //int old_node=out_nodes[irand(out_nodes.size()-1)]; deque<int> not_common; for (set<int>::iterator it_est = en[random_mate].begin(); it_est != en[random_mate].end(); it_est++) if ((old_node != (*it_est)) && (en[old_node].find(*it_est) == en[old_node].end())) if (they_are_mate(*it_est, random_mate, member_list) == b1 && they_are_mate(*it_est, old_node, member_list) == b1) not_common.push_back(*it_est); if (not_common.size() == 0) break; //int node_h=not_common[irand(not_common.size()-1)]; int t2; int node_h = choose_the_least(en, not_common, random_mate, t2); //double c1=common_neighbors(a, old_node, en) + common_neighbors(random_mate, node_h, en); double c1 = t1 + t2; en[a].erase(old_node); en[a].insert(random_mate); en[old_node].erase(a); en[old_node].insert(node_h); en[random_mate].erase(node_h); en[random_mate].insert(a); en[node_h].erase(random_mate); en[node_h].insert(old_node); double c2 = common_neighbors(a, random_mate, en) + common_neighbors(old_node, node_h, en); if (c1 > c2) { en[a].insert(old_node); en[a].erase(random_mate); en[old_node].insert(a); en[old_node].erase(node_h); en[random_mate].insert(node_h); en[random_mate].erase(a); en[node_h].insert(random_mate); en[node_h].erase(old_node); } break; } // ************************************************ rewiring } cc0 = compute_cc(en); if (cc0 - ccold < min_relative_inc * cc0) { cout << "It seems I cannot reach the wished value. I'll stop here..." << endl; break; } num_p = cast_int((ca - cc0) / (cc0 - ccold)) * num_p; if (num_p <= 0) num_p = 1; if (num_p > 50) num_p = 50; cout << "Average Clustering coefficient... " << cc0 << " trying to reach " << ca << "\t\t expected " << num_p << " more step(s) " << endl; } return 0; }
int erase_links(deque<set<int> > & E, const deque<deque<int> > & member_list, const bool excess, const bool defect, const double mixing_parameter) { int num_nodes= member_list.size(); int eras_add_times=0; if (excess) { for (int i=0; i<num_nodes; i++) { while ( (E[i].size()>1) && double(internal_kin(E, member_list, i))/E[i].size() < 1 - mixing_parameter) { //--------------------------------------------------------------------------------- cout<<"degree sequence changed to respect the option -sup ... "<<++eras_add_times<<endl; deque<int> deqar; for (set<int>::iterator it_est=E[i].begin(); it_est!=E[i].end(); it_est++) if (!they_are_mate(i, *it_est, member_list)) deqar.push_back(*it_est); if(deqar.size()==E[i].size()) { // this shouldn't happen... cerr<<"sorry, something went wrong: there is a node which does not respect the constraints. (option -sup)"<<endl; return -1; } int random_mate=deqar[irand(deqar.size()-1)]; E[i].erase(random_mate); E[random_mate].erase(i); } } } if (defect) { for (int i=0; i<num_nodes; i++) while ( (E[i].size()<E.size()) && double(internal_kin(E, member_list, i))/E[i].size() > 1 - mixing_parameter) { //--------------------------------------------------------------------------------- cout<<"degree sequence changed to respect the option -inf ... "<<++eras_add_times<<endl; int stopper_here=num_nodes; int stopper_=0; int random_mate=irand(num_nodes-1); while ( ( (they_are_mate(i, random_mate, member_list)) || E[i].find(random_mate)!=E[i].end()) && (stopper_<stopper_here) ) { random_mate=irand(num_nodes-1); stopper_++; } if(stopper_==stopper_here) { // this shouldn't happen... cerr<<"sorry, something went wrong: there is a node which does not respect the constraints. (option -inf)"<<endl; return -1; } E[i].insert(random_mate); E[random_mate].insert(i); } } //------------------------------------ Erasing links ------------------------------------------------------ return 0; }
int connect_all_the_parts(deque<set<int> > & E, const deque<deque<int> > & member_list, const deque<deque<int> > & link_list) { deque<int> degrees; for(int i=0; i<link_list.size(); i++) degrees.push_back(link_list[i][link_list[i].size()-1]); deque<set<int> > en; // this is the en of the subgraph { set<int> first; for(int i=0; i<member_list.size(); i++) en.push_back(first); } multimap <int, int> degree_node; for(int i=0; i<degrees.size(); i++) degree_node.insert(degree_node.end(), make_pair(degrees[i], i)); int var=0; while (degree_node.size() > 0) { multimap<int, int>::iterator itlast= degree_node.end(); itlast--; multimap <int, int>::iterator itit= itlast; deque <multimap<int, int>::iterator> erasenda; int inserted=0; for (int i=0; i<itlast->first; i++) { if(itit!=degree_node.begin()) { itit--; en[itlast->second].insert(itit->second); en[itit->second].insert(itlast->second); inserted++; erasenda.push_back(itit); } else break; } for (int i=0; i<erasenda.size(); i++) { if(erasenda[i]->first>1) degree_node.insert(make_pair(erasenda[i]->first - 1, erasenda[i]->second)); degree_node.erase(erasenda[i]); } var+= itlast->first - inserted; degree_node.erase(itlast); } // this is to randomize the subgraph ------------------------------------------------------------------- // ---------------------------------------------------------- deque<int> degree_list; for(int kk=0; kk<degrees.size(); kk++) for(int k2=0; k2<degrees[kk]; k2++) degree_list.push_back(kk); for(int run=0; run<10; run++) for(int node_a=0; node_a<degrees.size(); node_a++) for(int krm=0; krm<en[node_a].size(); krm++) { int random_mate=degree_list[irand(degree_list.size()-1)]; while (random_mate==node_a) random_mate=degree_list[irand(degree_list.size()-1)]; if (en[node_a].insert(random_mate).second) { deque <int> out_nodes; for (set<int>::iterator it_est=en[node_a].begin(); it_est!=en[node_a].end(); it_est++) if ((*it_est)!=random_mate) out_nodes.push_back(*it_est); int old_node=out_nodes[irand(out_nodes.size()-1)]; en[node_a].erase(old_node); en[random_mate].insert(node_a); en[old_node].erase(node_a); deque <int> not_common; for (set<int>::iterator it_est=en[random_mate].begin(); it_est!=en[random_mate].end(); it_est++) if ((old_node!=(*it_est)) && (en[old_node].find(*it_est)==en[old_node].end())) not_common.push_back(*it_est); int node_h=not_common[irand(not_common.size()-1)]; en[random_mate].erase(node_h); en[node_h].erase(random_mate); en[node_h].insert(old_node); en[old_node].insert(node_h); } } // now there is a rewiring process to avoid "mate nodes" (nodes with al least one membership in common) to link each other int var_mate=0; for(int i=0; i<degrees.size(); i++) for(set<int>::iterator itss= en[i].begin(); itss!=en[i].end(); itss++) if(they_are_mate(i, *itss, member_list)) { var_mate++; } //cout<<"var mate = "<<var_mate<<endl; int stopper_mate=0; int mate_trooper=10; while(var_mate>0) { //cout<<"var mate = "<<var_mate<<endl; int best_var_mate=var_mate; // ************************************************ rewiring for(int a=0; a<degrees.size(); a++) for(set<int>::iterator its= en[a].begin(); its!=en[a].end(); its++) if(they_are_mate(a, *its, member_list)) { int b=*its; int stopper_m=0; while (true) { stopper_m++; int random_mate = degree_list[irand(degree_list.size()-1)]; while (random_mate==a || random_mate==b) random_mate = degree_list[irand(degree_list.size()-1)]; if(!(they_are_mate(a, random_mate, member_list)) && (en[a].find(random_mate)==en[a].end())) { deque <int> not_common; for (set<int>::iterator it_est=en[random_mate].begin(); it_est!=en[random_mate].end(); it_est++) if ((b!=(*it_est)) && (en[b].find(*it_est)==en[b].end())) not_common.push_back(*it_est); if(not_common.size()>0) { int node_h=not_common[irand(not_common.size()-1)]; en[random_mate].erase(node_h); en[random_mate].insert(a); en[node_h].erase(random_mate); en[node_h].insert(b); en[b].erase(a); en[b].insert(node_h); en[a].insert(random_mate); en[a].erase(b); if(!they_are_mate(b, node_h, member_list)) var_mate-=2; if(they_are_mate(random_mate, node_h, member_list)) var_mate-=2; break; } } if(stopper_m==en[a].size()) break; } break; // this break is done because if you erased some link you have to stop this loop (en[i] changed) } // ************************************************ rewiring if(var_mate==best_var_mate) { stopper_mate++; if(stopper_mate==mate_trooper) break; } else stopper_mate=0; //cout<<"var mate = "<<var_mate<<endl; } //cout<<"var mate = "<<var_mate<<endl; for (int i=0; i<en.size(); i++) { for(set<int>::iterator its=en[i].begin(); its!=en[i].end(); its++) if(i<*its) { E[i].insert(*its); E[*its].insert(i); } } return 0; }
int propagate(deque<map <int, double > > & neigh_weigh, const deque<deque<int> > & member_list, deque<deque<double> > & wished, deque<deque<double> > & factual, int i, double & tot_var, double *strs, const deque<int> & internal_kin_top) { { // in this case I rewire the idle strength double change=factual[i][2]/neigh_weigh[i].size(); double oldpartvar=0; for(map<int, double>::iterator itm=neigh_weigh[i].begin(); itm!=neigh_weigh[i].end(); itm++) if(itm->second + change > 0) for (int bw=0; bw<3; bw++) oldpartvar+= (factual[itm->first][bw] - wished[itm->first][bw]) * (factual[itm->first][bw] - wished[itm->first][bw]); for (int bw=0; bw<3; bw++) oldpartvar+= (factual[i][bw] - wished[i][bw]) * (factual[i][bw] - wished[i][bw]); double newpartvar=0; for(map<int, double>::iterator itm=neigh_weigh[i].begin(); itm!=neigh_weigh[i].end(); itm++) if(itm->second + change > 0) { if (they_are_mate(i, itm->first, member_list)) { factual[itm->first][0]+=change; factual[itm->first][2]-=change; factual[i][0]+=change; factual[i][2]-=change; } else { factual[itm->first][1]+=change; factual[itm->first][2]-=change; factual[i][1]+=change; factual[i][2]-=change; } for (int bw=0; bw<3; bw++) newpartvar+= (factual[itm->first][bw] - wished[itm->first][bw]) * (factual[itm->first][bw] - wished[itm->first][bw]); itm->second+= change; neigh_weigh[itm->first][i]+=change; } for (int bw=0; bw<3; bw++) newpartvar+= (factual[i][bw] - wished[i][bw]) * (factual[i][bw] - wished[i][bw]); tot_var+= newpartvar - oldpartvar; } int internal_neigh=internal_kin_top[i]; if(internal_neigh!=0) { // in this case I rewire the difference strength double changenn=(factual[i][0] - wished[i][0]); double oldpartvar=0; for(map<int, double>::iterator itm=neigh_weigh[i].begin(); itm!=neigh_weigh[i].end(); itm++) { if(they_are_mate(i, itm->first, member_list)) { double change = changenn/internal_neigh; if(itm->second - change > 0) for (int bw=0; bw<3; bw++) oldpartvar+= (factual[itm->first][bw] - wished[itm->first][bw]) * (factual[itm->first][bw] - wished[itm->first][bw]); } else { double change = changenn/(neigh_weigh[i].size() - internal_neigh); if(itm->second + change > 0) for (int bw=0; bw<3; bw++) oldpartvar+= (factual[itm->first][bw] - wished[itm->first][bw]) * (factual[itm->first][bw] - wished[itm->first][bw]); } } for (int bw=0; bw<3; bw++) oldpartvar+= (factual[i][bw] - wished[i][bw]) * (factual[i][bw] - wished[i][bw]); double newpartvar=0; for(map<int, double>::iterator itm=neigh_weigh[i].begin(); itm!=neigh_weigh[i].end(); itm++) { if (they_are_mate(i, itm->first, member_list)) { double change = changenn/internal_neigh; if(itm->second - change > 0) { factual[itm->first][0]-=change; factual[itm->first][2]+=change; factual[i][0]-=change; factual[i][2]+=change; for (int bw=0; bw<3; bw++) newpartvar+= (factual[itm->first][bw] - wished[itm->first][bw]) * (factual[itm->first][bw] - wished[itm->first][bw]); itm->second-= change; neigh_weigh[itm->first][i]-=change; } } else { double change = changenn/(neigh_weigh[i].size() - internal_neigh); if(itm->second + change > 0) { factual[itm->first][1]+=change; factual[itm->first][2]-=change; factual[i][1]+=change; factual[i][2]-=change; for (int bw=0; bw<3; bw++) newpartvar+= (factual[itm->first][bw] - wished[itm->first][bw]) * (factual[itm->first][bw] - wished[itm->first][bw]); itm->second+= change; neigh_weigh[itm->first][i]+=change; } } } for (int bw=0; bw<3; bw++) newpartvar+= (factual[i][bw] - wished[i][bw]) * (factual[i][bw] - wished[i][bw]); tot_var+=newpartvar - oldpartvar; } //check_weights(neigh_weigh, member_list, wished, factual, tot_var, strs); return 0; }
//* int check_weights(deque<map <int, double > > & neigh_weigh, const deque<deque<int> > & member_list, deque<deque<double> > & wished, deque<deque<double> > & factual, const double tot_var, double *strs) { double d1t=0; double d2t=0; double d3t=0; double var_check=0; for (int k=0; k<member_list.size(); k++) { double in_s=0; double out_s=0; for(map<int, double>::iterator itm=neigh_weigh[k].begin(); itm!=neigh_weigh[k].end(); itm++) { if(itm->second<0) cherr(333); if(fabs(itm->second - neigh_weigh[itm->first][k]) > 1e-7) cherr(111); if (they_are_mate(k, itm->first, member_list)) in_s+=itm->second; else out_s+=itm->second; } if (fabs(in_s - factual[k][0]) > 1e-7) cherr(in_s - factual[k][0]); //cout<<"ok1"<<endl; if (fabs(out_s - factual[k][1]) > 1e-7) cherr(out_s - factual[k][1]); //cout<<"ok2"<<endl; if (fabs(in_s + out_s + factual[k][2] - strs[k]) > 1e-7) cherr(in_s + out_s + factual[k][2] - strs[k]); //cout<<"ok3"<<endl; double d1=(in_s - wished[k][0]); double d2=(out_s - wished[k][1]); double d3=(strs[k] - in_s - out_s); var_check+= d1*d1 + d2*d2 + d3*d3; d1t+=d1*d1; d2t+=d2*d2; d3t+=d3*d3; } cout<<"tot_var "<<tot_var<<"\td1t "<<d1t<<"\td2t "<<d2t<<"\td3t "<<d3t<<endl; if (fabs(var_check - tot_var) > 1e-5) cerr<<"found this difference in check "<<fabs(var_check - tot_var)<<endl; else cout<<"ok: check passed"<<endl; // ----------------------------------------------------------------------- CHECK ----------------------------------------------- // ----------------------------------------------------------------------- CHECK ----------------------------------------------- return 0; }
int print_network(deque<set<int> > & E, const deque<deque<int> > & member_list, const deque<deque<int> > & member_matrix, deque<int> & num_seq, deque<map <int, double > > & neigh_weigh, double beta, double mu, double mu0) { int edges=0; int num_nodes=member_list.size(); deque<double> double_mixing; for (int i=0; i<E.size(); i++) { double one_minus_mu = double(internal_kin(E, member_list, i))/E[i].size(); double_mixing.push_back(1.- one_minus_mu); edges+=E[i].size(); } //cout<<"\n----------------------------------------------------------"<<endl; //cout<<endl; double density=0; double sparsity=0; for (int i=0; i<member_matrix.size(); i++) { double media_int=0; double media_est=0; for (int j=0; j<member_matrix[i].size(); j++) { double kinj = double(internal_kin_only_one(E[member_matrix[i][j]], member_matrix[i])); media_int+= kinj; media_est+=E[member_matrix[i][j]].size() - double(internal_kin_only_one(E[member_matrix[i][j]], member_matrix[i])); } double pair_num=(member_matrix[i].size()*(member_matrix[i].size()-1)); double pair_num_e=((num_nodes-member_matrix[i].size())*(member_matrix[i].size())); if(pair_num!=0) density+=media_int/pair_num; if(pair_num_e!=0) sparsity+=media_est/pair_num_e; } density=density/member_matrix.size(); sparsity=sparsity/member_matrix.size(); ofstream out1("network.dat"); for (int u=0; u<E.size(); u++) { set<int>::iterator itb=E[u].begin(); while (itb!=E[u].end()) out1<<u+1<<"\t"<<*(itb++)+1<<"\t"<<neigh_weigh[u][*(itb)]<<endl; } ofstream out2("community.dat"); for (int i=0; i<member_list.size(); i++) { out2<<i+1<<"\t"; for (int j=0; j<member_list[i].size(); j++) out2<<member_list[i][j]+1<<" "; out2<<endl; } cout<<"\n\n---------------------------------------------------------------------------"<<endl; cout<<"network of "<<num_nodes<<" vertices and "<<edges/2<<" edges"<<";\t average degree = "<<double(edges)/num_nodes<<endl; cout<<"\naverage mixing parameter (topology): "<< average_func(double_mixing)<<" +/- "<<sqrt(variance_func(double_mixing))<<endl; cout<<"p_in: "<<density<<"\tp_out: "<<sparsity<<endl; ofstream statout("statistics.dat"); deque<int> degree_seq; for (int i=0; i<E.size(); i++) degree_seq.push_back(E[i].size()); statout<<"degree distribution (probability density function of the degree in logarithmic bins) "<<endl; log_histogram(degree_seq, statout, 10); statout<<"\ndegree distribution (degree-occurrences) "<<endl; int_histogram(degree_seq, statout); statout<<endl<<"--------------------------------------"<<endl; statout<<"community distribution (size-occurrences)"<<endl; int_histogram(num_seq, statout); statout<<endl<<"--------------------------------------"<<endl; statout<<"mixing parameter (topology)"<<endl; not_norm_histogram(double_mixing, statout, 20, 0, 0); statout<<endl<<"--------------------------------------"<<endl; //* deque<double> inwij; deque<double> outwij; //deque<double> inkij; //deque<double> outkij; double csi=(1. - mu) / (1. - mu0); double csi2=mu /mu0; double tstrength=0; deque<double> one_minus_mu2; for(int i=0; i<neigh_weigh.size(); i++) { double internal_strength_i=0; double strength_i=0; for(map<int, double>::iterator itm = neigh_weigh[i].begin(); itm!=neigh_weigh[i].end(); itm++) { if(they_are_mate(i, itm->first, member_list)) { inwij.push_back(itm->second); //inkij.push_back(csi * pow(E[i].size(), beta-1)); internal_strength_i+=itm->second; } else { outwij.push_back(itm->second); //outkij.push_back(csi2 * pow(E[i].size(), beta-1)); } tstrength+=itm->second; strength_i+=itm->second; } one_minus_mu2.push_back(1 - internal_strength_i/strength_i); } //cout<<"average strength "<<tstrength / E.size()<<"\taverage internal strenght: "<<average_internal_strenght<<endl; cout<<"\naverage mixing parameter (weights): "<<average_func(one_minus_mu2)<<" +/- "<<sqrt(variance_func(one_minus_mu2))<<endl; statout<<"mixing parameter (weights)"<<endl; not_norm_histogram(one_minus_mu2, statout, 20, 0, 0); statout<<endl<<"--------------------------------------"<<endl; //cout<<" expected internal "<<tstrength * (1 - mu) / E.size()<<endl; //cout<<"internal links: "<<inwij.size()<<" external: "<<outwij.size()<<endl; /* ofstream hout1("inwij.dat"); not_norm_histogram(inwij, hout1, 20, 0, 0); ofstream hout2("outwij.dat"); not_norm_histogram(outwij, hout2, 20, 0, 0); ofstream hout3("corrin.dat"); not_norm_histogram_correlated(inkij, inwij, hout3, 20, 0, 0); ofstream hout4("corrout.dat"); not_norm_histogram_correlated(outkij, outwij, hout4, 20, 0, 0); //*/ //*/ cout<<"average weight of an internal link "<<average_func(inwij)<<" +/- "<<sqrt(variance_func(inwij))<<endl; cout<<"average weight of an external link "<<average_func(outwij)<<" +/- "<<sqrt(variance_func(outwij))<<endl; //cout<<"average weight of an internal link expected "<<tstrength / edges * (1. - mu) / (1. - mu0)<<endl; //cout<<"average weight of an external link expected "<<tstrength / edges * (mu) / (mu0)<<endl; statout<<"internal weights (weight-occurrences)"<<endl; not_norm_histogram(inwij, statout, 20, 0, 0); statout<<endl<<"--------------------------------------"<<endl; statout<<"external weights (weight-occurrences)"<<endl; not_norm_histogram(outwij, statout, 20, 0, 0); cout<<endl<<endl; return 0; }