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;
}
