int main(int argc, char* argv[]) {
#if 0
if( argc < 2) {
cout << "usage: " << argv[0] << " packagefile" << endl;
return 0;
}
DebianDependencyNetwork my_net(argv[1]);
cout << "#read debian package: " << argv[1] << endl;
/*
map<int, int> in_deg_dist = my_net.getOutDegreeDist();
map<int, int>::iterator deg_it = in_deg_dist.begin();
cout << "#printing out degree distribution" << endl;
while( deg_it != in_deg_dist.end() ) {
cout << deg_it->first << " " << deg_it->second << endl;
deg_it++;
}
//cout << "#cluster coeff: " << my_net.getClusterCoefficient() << endl;
*/
Network deb_undir;
cerr << "#about to move into an undirected network" << endl;
my_net.moveIntoUndirectedNetwork(deb_undir);
cerr << "#converted to undirected" << endl;
set<Node*>::iterator n = nodes.begin();
for(; n != nodes.end(); n++) {
cout << deb_undir.getDegree( *n ) << " "
<< deb_undir.getClusterCoefficient( *n ) << endl;
}
/*
map<int, int> deg_dist = deb_undir.getDegreeDist();
map<int, int>::iterator deg_it = deg_dist.begin();
cout << "#printing out degree distribution" << endl;
for(; deg_it != deg_dist.end(); deg_it++ ) {
cout << deg_it->first << " " << deg_it->second << endl;
}
cout << "#cluster coeff: " << deb_undir.getClusterCoefficient() << endl;
cout << "#edges: " << deb_undir.getEdges().size() << endl;
cout << "#nodes: " << deb_undir.getNodes().size() << endl;
*/
//Delete the allocated memory (nodes)
deb_undir.clear();
#endif
#if 0
set<Node*> all_nodes;
Network my_net;
//Make all the nodes:
for(int i = 0; i < 100; i++) {
all_nodes.insert( new Node() );
}
//Make a network:
set<Node*>::iterator n_it = all_nodes.begin();
Node* last_node = 0;
while(n_it != all_nodes.end()) {
if(last_node) {
my_net.add( Edge(last_node, *n_it) );
}
last_node = *n_it;
n_it++;
}
#endif
#if 0
/**
* Test transitivity calculation:
*/
Network* my_net;
Ran1Random my_rand;
double p = 0.1;
int n = 100;
while(p < 1.0) {
my_net = new RandomNetwork(n, p, my_rand);
cout << p << " " << my_net->getTransitivity() << endl;
p += 0.1;
}
#endif
#if 0
//Verify the assortativity calculation on a known case:
/**
* the callaway network should have assortativity p/(1+2p)
*/
DynamicNetwork* my_net = 0;
Ran1Random my_rand;
double p = 0.0;
cout << "#c <k> clustercoeff assort n" << endl;
while( p < 1.0 ) {
//my_net = new CallawayNetwork(10000, p, my_rand);
my_net = new PrefDelCompNetwork(RandomNetwork(20, 0.5, my_rand),
my_rand,
p,
1,
0.75); //Only restore connections with q=0.75
while( my_net->getNodes().size() < 20000) {
my_net->incrementTime(1);
}
cout << p << " "
<< my_net->getAverageDegree() << " "
<< my_net->getClusterCoefficient() << " "
<< my_net->getAssortativity() << " "
<< my_net->getNodes().size() << endl;
my_net->clear();
delete my_net;
p += 0.1;
}
#endif
#if 0
//Test the edge betweenness calculation for some small graphs
//Using the examples from page 5 of cond-mat/0308217
vector<Node*> nodes;
//This is the first example:
Network net;
stringstream node_name;
for(int i = 0; i < 7; i++) {
node_name.str("");
node_name << i;
nodes.push_back(new Node( node_name.str() ));
net.add( nodes.back() );
}
//Add the edges:
net.add( Edge(nodes[0], nodes[1]) );
net.add( Edge(nodes[0], nodes[2]) );
net.add( Edge(nodes[1], nodes[3]) );
net.add( Edge(nodes[2], nodes[4]) );
net.add( Edge(nodes[2], nodes[5]) );
net.add( Edge(nodes[5], nodes[6]) );
map<Edge*, double> betweenness;
Edge* max_edge = net.getEdgeBetweennessFor(nodes[0], betweenness);
cout << "Max Edge: " << max_edge->toString() << endl;
map<Edge*, double>::iterator betit;
for(betit = betweenness.begin(); betit != betweenness.end(); betit++) {
cout << betit->first->toString() << " bet: " << betit->second << endl;
}
//This is the second example:
net.clear();
nodes.clear();
for(int i = 0; i < 7; i++) {
node_name.str("");
node_name << i;
nodes.push_back( new Node(node_name.str()) );
net.add( nodes.back() );
}
//Add the edges:
net.add( Edge(nodes[0], nodes[1]) );
net.add( Edge(nodes[0], nodes[2]) );
net.add( Edge(nodes[1], nodes[3]) );
net.add( Edge(nodes[2], nodes[3]) );
net.add( Edge(nodes[2], nodes[4]) );
net.add( Edge(nodes[3], nodes[5]) );
net.add( Edge(nodes[4], nodes[5]) );
net.add( Edge(nodes[4], nodes[6]) );
betweenness.clear();
max_edge = net.getEdgeBetweennessFor(nodes[0], betweenness);
cout << "Max Edge: " << max_edge->toString() << endl;
for(betit = betweenness.begin(); betit != betweenness.end(); betit++) {
cout << betit->first->toString() << " bet: " << betit->second << endl;
}
//Try a circle:
net.clear();
nodes.clear();
for(int i = 0; i < 10; i++) {
node_name.str("");
node_name << i;
nodes.push_back( new Node(node_name.str()) );
net.add( nodes.back() );
}
//connect each node to the next:
for(int i = 0; i < nodes.size(); i++) {
net.add( Edge( nodes[i], nodes[ (i + 1) % nodes.size() ] ) );
}
betweenness.clear();
max_edge = net.getEdgeBetweennessFor(nodes[0], betweenness);
cout << "Max Edge: " << max_edge->toString() << endl;
for(betit = betweenness.begin(); betit != betweenness.end(); betit++) {
cout << betit->first->toString() << " bet: " << betit->second << endl;
}
betweenness.clear();
max_edge = net.getEdgeBetweenness(betweenness);
cout << "Max Edge: " << max_edge->toString() << endl;
for(betit = betweenness.begin(); betit != betweenness.end(); betit++) {
cout << betit->first->toString() << " bet: " << betit->second << endl;
}
//Here is a line:
net.clear();
nodes.clear();
for(int i = 0; i < 10; i++) {
node_name.str("");
node_name << i;
nodes.push_back( new Node(node_name.str()) );
net.add( nodes.back() );
}
//connect each node to the next:
for(int i = 0; i < nodes.size() - 1; i++) {
net.add( Edge( nodes[i], nodes[ i + 1] ) );
}
betweenness.clear();
max_edge = net.getEdgeBetweennessFor(nodes[0], betweenness);
cout << "Max Edge: " << max_edge->toString() << endl;
for(betit = betweenness.begin(); betit != betweenness.end(); betit++) {
cout << betit->first->toString() << " bet: " << betit->second << endl;
}
betweenness.clear();
max_edge = net.getEdgeBetweenness(betweenness);
cout << "Max Edge: " << max_edge->toString() << endl;
for(betit = betweenness.begin(); betit != betweenness.end(); betit++) {
cout << betit->first->toString() << " bet: " << betit->second << endl;
}
//A star network:
net.clear();
nodes.clear();
for(int i = 0; i < 20; i++) {
node_name.str("");
node_name << i;
nodes.push_back( new Node(node_name.str()) );
net.add( nodes.back() );
}
//connect each node to the center:
for(int i = 1; i < nodes.size(); i++) {
net.add( Edge( nodes[0], nodes[ i ] ) );
}
betweenness.clear();
max_edge = net.getEdgeBetweennessFor(nodes[1], betweenness);
cout << "Max Edge: " << max_edge->toString() << endl;
for(betit = betweenness.begin(); betit != betweenness.end(); betit++) {
cout << betit->first->toString() << " bet: " << betit->second << endl;
}
betweenness.clear();
max_edge = net.getEdgeBetweenness(betweenness);
cout << "Max Edge: " << max_edge->toString() << endl;
for(betit = betweenness.begin(); betit != betweenness.end(); betit++) {
cout << betit->first->toString() << " bet: " << betit->second << endl;
}
#endif
#if 1
//Make a network:
int i_nodes;
if( argc > 1) {
i_nodes = atoi(argv[1]);
}
else {
i_nodes = 10;
}
cout << "working" <<endl;
// return 1;
Ran1Random my_rand, my_rand2(-100), my_rand3(-1000);
//RandomNetwork my_net(i_nodes, 0.005, my_rand);
//RandomDirectedNetwork my_net(1000, 0.005, my_rand);
//PolyPreference my_p;
//ExpPreference my_p(1.0);
//DoublePrefAtNetwork my_net(RandomNetwork(10,0.5,my_rand), my_rand, 2);
//PrefAtNetwork my_net(RandomNetwork(3,1,my_rand),my_rand,1);
//my_net.incrementTime(i_nodes-3);
/*
PrefDelCompNetwork my_net(RandomNetwork(i_nodes, 1.0, my_rand),
my_rand,
0.7,
1);
//make sure we have 20,000 nodes;
while( my_net.getNodes().size() < 2000) {
//cerr << "edges: " << my_net.getEdges().size() << endl;
my_net.incrementTime(1);
}
*/
//ifstream content_crawl(argv[2]);
//Network my_net(cin);
//UniformAttachNet my_net(RandomNetwork(7, 0.5, my_rand), my_rand, 2);
//my_net.incrementTime(i_nodes - 7);
//GnutellaFileSpaceNetwork my_net( std::cin, 100000);
//CallawayNetwork my_net(1000, 0.2, my_rand);
SmallWorldNetwork my_net(30, 0.1, my_rand);
//NoisyStarDNet my_net(0.0,my_rand, 0.0, 1.0);
//my_net.incrementTime(50000);
//SimkinNetwork my_net(2000,10,0.75,my_rand);
//VazquezDirectedNetwork my_net(200,0.3,my_rand);
//PowerLawProbabilityFunction pl(-2.0,2,sqrt(i_nodes));
//ExpProbabilityFunction expl(2.0/3.0,2, i_nodes);
//DegreeLawRandomNetwork my_net(i_nodes,expl,my_rand,true);
//SpatialNetwork my_net(i_nodes,my_rand,3,2);
// PercolationMessage my_mes(my_rand,0.9,2);
//AnycastMessage my_mes(my_rand, 1, 5);
// BroadcastMessage my_mes(2);
AmnesiacMessage my_mes(my_rand,5);
cout << "1111" <<endl;
//MagnetMessage my_mes(my_rand,0.0,5);
//MessageBuiltNetwork my_net(5000, my_mes, my_rand2,3);
//DoubleMBNet my_net(RandomNetwork(3, 1.0, my_rand), my_mes, my_rand2, 2);
// DoublePrefAtNetwork my_net(RandomNetwork(3,1.0,my_rand), my_rand2, 2);
cout << "2222" <<endl;
// my_net.incrementTime(5000 - 3);
cout << "3333" <<endl;
//DebianDependencyNetwork deb_net(argv[1]);
//DebianDependencyNetwork my_net(argv[1]);
//Network my_net;
//cout << "#read debian package: " << argv[1] << endl;
//my_net.reverseEdges();
//cout << "#reversed edges" << endl;
//deb_net.moveIntoUndirectedNetwork( my_net );
//cout << "#converted to undirected networks" << endl;
//GnutellaNetwork my_net(argv[1],"ripeanu");
//GnutellaNetwork my_net(argv[1],"limecrawler");
//vector<double> netp_v;
//netp_v.push_back(tp);
//ER graph mixing
#if 0
int increments = 1;
int net_num = increments;
int netn= (int)pow(2.0,9.0);
double lp = 1/netn;
double hp = 50/netn;
double incrp = (hp-lp)/((double)increments);
double tp = lp;
while (net_num-- > 0)
{
double ave_d = tp*netn;
RandomNetwork ert(netn,.5,my_rand);
//RandomNetwork ert(netn,tp,my_rand);
cout<<ert.getNodes().size()<<endl;
set<Network> er_components = ert.getComponents();
cout <<"Components: "<< er_components.size()<<endl;
set<Network>::iterator comp_it_big = er_components.begin();
set<Network>::iterator comp_it_biggest;
int biggest_size = 0;
int tmp_size = 0;
for ( comp_it_big = er_components.begin();
comp_it_big != er_components.end();
comp_it_big++)
{
tmp_size = comp_it_big->getNodes().size();
if ( biggest_size < tmp_size )
{
cout<<"csize "<<tmp_size<<" "<<biggest_size<<endl;
biggest_size = tmp_size;
comp_it_biggest = comp_it_big;
}
}
cout << comp_it_biggest->getNodes().size()<<endl;
vector<Node*> node_v;
set<Node*>::iterator node_it;
for (node_it = comp_it_biggest->getNodes().begin();
node_it != comp_it_biggest->getNodes().end();
node_it++ )
{
node_v.push_back( *node_it);
}
GraphMatrix g_matrix(*comp_it_biggest);
stringstream num_string;
num_string <<"er_trans_matrix_"<<ave_d<<".dat";
g_matrix.transitionProbabilityMatrixToAsciiFiles(
num_string.str(),node_v);
tp += incrp;
}
#endif
// write out various matrices associated with the graph
#if 0
vector<Node*> node_v;
set<Node*>::iterator node_it;
for (node_it = my_net.getNodes().begin();
node_it != my_net.getNodes().end();
node_it++ )
{
node_v.push_back( *node_it);
}
GraphMatrix g_matrix(my_net);
g_matrix.unitSquareIncidenceMatrixToAsciiFile(
string("new_incid.txt"),node_v);
g_matrix.transitionProbabilityMatrixToAsciiFiles(
string("new_trans_matrix.txt"),node_v);
#endif
#if 1
IntStats ns(true);
cout << "4444" <<endl;
auto_ptr<NodeIterator> ni( my_net.getNodeIterator() );
cout << "5555" <<endl;
ns.collect((Network*)&my_net,&Network::getDegree, ni.get());
cout << "6666" <<endl;
ns.collectByEdge(&my_net, &Network::getDegree);
cout << "7777" <<endl;
cout << "#loaded network" << endl;
cout << "#assortativity: " << ns.getEdgeCorrelation() << endl
<< "#cluster coeff: " << my_net.getClusterCoefficient() << endl
<< "#transitivity: " << my_net.getTransitivity() << endl
<< "#nodes: " << my_net.getNodeSize() << endl
<< "#edges: " << my_net.getEdgeSize() << endl
<< "#<k>: " << ns.getAverage() << endl
<< "#<k^2>: " << ns.getMoment(2) << endl
<< "#H(degs): " << ns.getEntropy() << endl
<< "#EdgeMI: " << ns.getEdgeMutualInfo() << endl;
cout << "8888" <<endl;
#endif
//Some stats for GnutellaFileSpaceNetworks:
#if 0
cout << "#queries: " << my_net.getNodes(
GnutellaFileSpaceNetwork::query_type).size() << endl
<< "#contents: " << my_net.getNodes(
GnutellaFileSpaceNetwork::content_type).size() << endl
<< "#peers: " << my_net.getNodes(
GnutellaFileSpaceNetwork::node_type).size() << endl;
#endif
//These are valid for debian networks:
//cout << "#size assortativity: " << my_net.getSizeAssortativity() << endl
// << "#lib assortativity: " << my_net.getLibAssortativity() << endl;
#if 0
//Look at the number of n-th neighbors:
map<int, int> nth_n(my_net.getNthNeighborDist(2));
map<int, int>::const_iterator nth_it;
ofstream nth_nf("last.nth_n");
for(nth_it = nth_n.begin(); nth_it != nth_n.end(); nth_it++) {
nth_nf << nth_it->first << " " << nth_it->second << endl;
}
#endif
#if 0
//Look at degree-cluser coeff. correlations
ofstream deg_cc("last.deg_cc");
map<int, double> deg_cc_m = my_net.getCCvsDegree();
map<int, double>::const_iterator dcc_it;
for(dcc_it = deg_cc_m.begin(); dcc_it != deg_cc_m.end(); dcc_it++) {
deg_cc << dcc_it->first << " "
<< dcc_it->second << endl;
}
#endif
#if 0
//Look at all cc, degree pairs:
ofstream cc_deg_all("last.cc_deg_pairs");
Network::NodePSet cda_nodes = my_net.getNodes();
Network::NodePSet::iterator n_ita;
for(n_ita = cda_nodes.begin(); n_ita != cda_nodes.end(); n_ita++) {
cc_deg_all
<< my_net.getDegree( *n_ita )
<< " "
<< my_net.getClusterCoefficient( *n_ita )
<< endl;
}
#endif
#if 0
//Look at a histogram of the cc:
vector<int> hist = my_net.getCCHist(100);
ofstream cc_hist("last.cc_hist");
for(unsigned int hi = 0; hi < hist.size(); hi++) {
cc_hist << hi << " " << hist[hi] << endl;
}
#endif
#if 0
//This is the email graph cutter:
//Do the recursive cut on all the components until each
//have cc = 0, or cc > 0.4
set<Network> components = my_net.getComponents();
int size = my_net.getNodes().size();
set<Network>::iterator comp_it;
ofstream spam_graphs("spam.graph");
ofstream ham_graphs("ham.graph");
Edge* cut_edge = 0;
while( components.size() > 0 ) {
//Choose the biggest graph
comp_it = components.begin();
//Only pay attention to big graphs
if( comp_it->getNodes().size() >= size/100 ) {
if( comp_it->getClusterCoefficient() == 0.0 ) {
//cout << "Printing spam graph" << endl;
//comp_it->printTo(spam_graphs);
}
else if( comp_it->getClusterCoefficient() > 0.4 ) {
//cout << "Printing ham graph" << endl;
vector< pair<int, int> > joins;
vector<double> q_t;
int step = comp_it->getCommunities(q_t,joins);
set<Network> coms = comp_it->getCommunity(step, joins);
set<Network>::iterator comit;
int community = 0;
for(comit = coms.begin(); comit != coms.end(); comit++) {
stringstream comname;
comname << "community_" << community++ << ".graph";
ofstream comstream( comname.str().c_str() );
comit->printTo( comstream );
}
//comp_it->printTo(ham_graphs);
}
else {
//This is a graph that needs to be split
cout << "Splitting Graph of size: "
<< comp_it->getNodes().size() << endl;
map<Edge*, double> bet;
set<Network> split;
cut_edge = comp_it->getEdgeBetweenness(bet);
//Remove both nodes at either ends of this edge
Network tmp = *comp_it;
tmp.remove( cut_edge->first );
tmp.remove( cut_edge->second );
split = tmp.getComponents();
components.insert( split.begin(), split.end() );
}
}
else {
//cout << "Skipping graph" << endl;
}
//cout << "graphs: " << components.size() << endl;
components.erase( comp_it );
}
#endif
#if 0
//Look on components:
set<Network> components = my_net.getComponents();
set<Network>::const_reverse_iterator comp_it = components.rbegin();
stringstream outname;
cout << "#components: " << components.size() << endl;
for(int c_count = 0;comp_it != components.rend(); comp_it++) {
double exp_cc = comp_it->getExpectedTransitivity();
double cc = comp_it->getTransitivity();
int wedges = comp_it->getWedgeCount();
Network::NodePSet::const_iterator n_it;
int kmax = 0;
for(n_it = comp_it->getNodes().begin();
n_it != comp_it->getNodes().end();
n_it++) {
if( kmax < comp_it->getDegree( *n_it ) ) {
kmax = comp_it->getDegree( *n_it );
}
}
cout << "#comp(" << ++c_count
<< ") size=" << comp_it->getNodes().size()
<< " kmax=" << kmax
<< " kmax+1/size="
<< (double)(kmax+1)/(double)comp_it->getNodes().size()
<< " CC=" << comp_it->getClusterCoefficient()
//<< " CCV=" << comp_it->getCCStdErr()
<< " exp_c=" << exp_cc
<< " c=" << cc
<< " ratio=" << (cc/exp_cc)
//<< " variance=" << sqrt( exp_cc * (1.0-exp_cc)/(double)wedges )
<< endl;
/*
<< "<k^2> = " << k2 << " "
<< "<k> = " << comp_it->getDegreeMoment(1) << " "
<< "cc: " << comp_it->getClusterCoefficient() << " "
<< "a: " << comp_it->getAssortativity() << " ";
*/
/*
//Print the mean distance:
map<int, int> ddist = comp_it->getDegreeDist();
map<int, int>::reverse_iterator ddit;
double dave = 0.0;
ddit = ddist.rbegin();
cout << "d = " << ddist.rbegin()->first << endl;
*/
outname.str("");
outname << "comp." << c_count;
ofstream comp_print( outname.str().c_str() );
comp_it->printTo( comp_print );
#if 0
//if( (comp_it->getNodes().size() * 100) > my_net.getNodes().size() ) {
if( comp_it->getClusterCoefficient() > 0.0 ) {
//Print out the communities:
vector< pair<int, int> > joins;
vector<double> q_t;
int step = comp_it->getCommunities(q_t, joins);
set< Network > comms = comp_it->getCommunity(step, joins);
set< Network >::const_reverse_iterator comit;
Network::NodePSet::const_iterator comnodeit;
int community = 0;
cout << "#Q: " << q_t[step] << endl;
cout << "#step: " << step << endl;
for(comit = comms.rbegin();
comit != comms.rend();
comit++) {
//if( comit->getClusterCoefficient() < 0.05 ) { continue; }
cout << "#Community: " << community++ << endl
<< "#size: " << comit->getNodes().size() << endl
<< "#cc: " << comit->getClusterCoefficient() << endl;
for(comnodeit = comit->getNodes().begin();
comnodeit != comit->getNodes().end();
comnodeit++) {
cout << (*comnodeit)->toString() << endl;
}
cout << endl;
//Get sub communities:
vector< pair<int,int> > sjoins;
vector<double> sq;
int sub_steps = comit->getCommunities(sq, sjoins);
set<Network> subcom = comit->getCommunity(sub_steps, sjoins);
set< Network >::const_reverse_iterator comit2;
if( sq[sub_steps] > 0.3 ) {
cout << "#subcommunity: " << endl
<< "#Q: " << sq[sub_steps] << endl;
//There is a subcommunity structure:
for(comit2 = comms.rbegin();
comit2 != comms.rend();
comit2++) {
for(comnodeit = comit2->getNodes().begin();
comnodeit != comit2->getNodes().end();
comnodeit++) {
cout << (*comnodeit)->toString() << endl;
}
cout << endl;
}
}
}
}
#endif
}
#endif
#if 1
//Print the network:
ofstream dot_out("last.nm");
my_net.printTo(dot_out);
#endif
#if 0
//Print out the degree distribution:
ofstream deg_out("last.degs");
cout << "about to getNodes" << endl;
map<int, int> deg_dist = my_net.getDegreeDist(
my_net.getNodes(
//GnutellaFileSpaceNetwork::node_type
)
);
map<int, int>::iterator deg_it = deg_dist.begin();
deg_out << "#printing out degree distribution" << endl;
for(;deg_it != deg_dist.end(); deg_it++ ) {
deg_out << deg_it->first << " " << deg_it->second << endl;
}
#endif
#if 0
//Look at wieght distributions for GnutellaFileSpace
ofstream w_out("last_content_weights.dat");
w_out << "#content weight histogram" << endl;
map<double,int> weights = my_net.getContentWeights();
map<double,int>::iterator wit;
w_out << "#using an exponentially increasing window size" << endl;
for(wit = weights.begin(); wit != weights.end(); wit++) {
w_out << wit->first << " " << wit->second << endl;
}
#endif
#if 0
//Print out the in degree distribution:
ofstream indeg_out("last.indegs");
map<int, int> indeg_dist = my_net.getInDegreeDist();
map<int, int>::iterator indeg_it = indeg_dist.begin();
deg_out << "#printing out in-degree distribution" << endl;
for(;indeg_it != indeg_dist.end(); indeg_it++ ) {
indeg_out << indeg_it->first << " " << indeg_it->second << endl;
}
#endif
#if 0
//Print out the distance distribution:
ofstream dist_out("last_distance.dist");
map<int, int> dist_dist = my_net.getDistanceDist();
map<int, int>::iterator dist_it = dist_dist.begin();
dist_out << "#printing out distance distribution" << endl;
for(;dist_it != dist_dist.end(); dist_it++ ) {
dist_out << dist_it->first << " " << dist_it->second << endl;
}
#endif
#if 0
//Print out the associated number distribution:
ofstream an_out("last_an.dist");
map<int, int> an_dist = my_net.getAssociatedNumberDist();
map<int, int>::iterator an_it = an_dist.begin();
dist_out << "#printing out associated number distribution" << endl;
for(;an_it != an_dist.end(); an_it++ ) {
an_out << an_it->first << " " << an_it->second << endl;
}
#endif
#if 1
//Look at the CDF:
//Print out the degree distribution:
ofstream cdf_out("last.cdf");
/*
map<int, int> cdf_dist = my_net.getDegreeDist(
my_net.getNodes(GnutellaFileSpaceNetwork::node_type)
);
*/
const map<int, int>& cdf_dist = ns.getDist();
map<int, int>::const_iterator cdf_it;
cdf_out << "#printing out degree distribution" << endl;
int degs = 0;
for( cdf_it = cdf_dist.begin(); cdf_it != cdf_dist.end(); cdf_it++) {
degs += cdf_it->second;
}
int sum = 0;
for(cdf_it = cdf_dist.begin(); cdf_it != cdf_dist.end(); cdf_it++ ) {
//plot the number of nodes which have degree >= cdf_it->first
cdf_out << cdf_it->first << " " << degs - sum << endl;
sum += cdf_it->second;
}
#endif
#if 0
//Look at percolation on a network:
Message *my_message = 0;
double p = 1e-5, q = 0.01;
my_rand3.setBoolTrueBias(q);
cout << "#each node gets bug with probability: " << q << endl;
set<Node*> nodes = my_net.getNodes();
set<Node*>::iterator n;
set<Node*> vnodes;
p = 0.001;
//int ttl = -1;
//while( ttl < 20) {
while( p < 1.0) {
my_rand3.setBoolTrueBias(q);
delete my_message;
my_message = new PercolationMessage(my_rand2,p);
//my_message = new AnycastMessage(my_rand2,max,ttl);
n = nodes.begin();
for(; n != nodes.end(); n++) {
if( my_rand3.getBool() ) {
my_message->visit( *n, my_net );
}
/*
cout << my_net.getDegree( *n ) << " "
<< my_net.getClusterCoefficient( *n ) << endl;
*/
}
cout
<< p
//<< ttl
<< " " << my_message->getVisitedNodes().size() << endl;
p *= 1.05;
//++ttl;
}
delete my_message;
#endif
//Delete all the nodes
cout << "clearing the network" << endl;
my_net.clear();
cout << "cleared network" << endl;
#endif
#if 0
//Here is a debian analyzer.
if( argc < 2) {
cerr << "usage: " << argv[0] << " packagefile" << endl;
return 0;
}
DebianDependencyNetwork my_net(argv[1]);
cout << "read debian package: " << argv[1] << endl;
string out_name = argv[1];
out_name += ".out.dat";
string in_name = argv[1];
in_name += ".in.dat";
ofstream out_file( out_name.c_str() );
ofstream in_file( in_name.c_str() );
out_file << "#debian package file: " << argv[1] << endl;
in_file << "#debian package file: " << argv[1] << endl;
//Look at the in degree:
in_file << "#in degree distribution:" << endl;
map<int, int> deg_dist = my_net.getInDegreeDist();
map<int, int>::const_iterator deg_it = deg_dist.begin();
for(; deg_it != deg_dist.end(); deg_it++) {
in_file << deg_it->first << " " << deg_it->second << endl;
}
int nodes = my_net.getNodes().size();
in_file << "#nodes: " << nodes << endl;
//In degree:
deg_it = deg_dist.begin();
int in_edges = 0, in_edges2 = 0;
for(;deg_it != deg_dist.end(); deg_it++) {
in_edges += (deg_it->first) * (deg_it->second);
in_edges2 += (deg_it->first) * (deg_it->second) * (deg_it->second);
}
in_file << "#<deg> = " << (double)(in_edges)/(double)nodes << endl;
in_file << "#<deg^2> = " << (double)(in_edges2)/(double)nodes << endl;
//Look at the out degree:
out_file << "#out degree distribution:" << endl;
deg_dist = my_net.getOutDegreeDist();
deg_it = deg_dist.begin();
for(; deg_it != deg_dist.end(); deg_it++) {
out_file << deg_it->first << " " << deg_it->second << endl;
}
deg_it = deg_dist.begin();
in_edges = 0; in_edges2 = 0;
for(;deg_it != deg_dist.end(); deg_it++) {
in_edges += (deg_it->first) * (deg_it->second);
in_edges2 += (deg_it->first) * (deg_it->second) * (deg_it->second);
}
out_file << "#nodes: " << nodes << endl;
out_file << "#<deg> = " << (double)(in_edges)/(double)nodes << endl;
out_file << "#<deg^2> = " << (double)(in_edges2)/(double)nodes << endl;
cout << "#assortativity: " << my_net.getAssortativity() << endl;
cout << "#lib assortativity: " << my_net.getLibAssortativity() << endl;
cout << "#edges: " << my_net.getEdges().size() << endl;
//Network undir_net;
//my_net.moveIntoUndirectedNetwork( undir_net );
//double cc = undir_net.getClusterCoefficient();
//cout << "#clustering coeff: " << cc << endl;
//undir_net.clear();
#endif
#if 0
//Here we consider a network for a P2P topology
Ran1Random r1(-1), r2(-1000), r3(-1000000), r4(-5678);
int nodes;
int node_max = 256*1024;
//PrefAtNetwork my_net(nodes, r1, 2, 2);
//GnutellaNetwork my_net(argv[1],"limecrawler");
PowerLawProbabilityFunction* pl = 0;
//DynamicNetwork* my_net = 0;
Network* my_net = 0;
ContentNetwork* my_cnet = 0;
Node* a_node = 0;
ContentNode* c_node = 0;
vector<ContentNode*> content_vector;
vector<Node*> node_vector;
int cont_count = 100;
content_vector.reserve(cont_count);
for(int i = 0; i < cont_count; i++) {
content_vector.push_back(new ContentNode);
}
Message* query = 0;
Message* implant = 0;
double p, p_max, p_min;
double hit_rate = 0.0;
double target_rate = 0.25;
double eps = 0.025;
int hits, runs;
int ttl;
cout << "#check percolation search on size n:" << endl;
p = 0.0;
nodes = 1<<14;
//for(nodes = 1024; nodes < 256*1024; nodes*=2) {
//my_net = new PrefAtNetwork(nodes,r1,2,2);
//my_net = new DoublePrefAtNetwork(nodes,r1,2,2);
//my_net = new PrefDelCompNetwork(RandomNetwork(nodes,0.001,r1), r1);
//my_net->incrementTime(4*nodes);
pl = new PowerLawProbabilityFunction(-2.0,1,nodes);
my_net = new DegreeLawRandomNetwork(nodes, *pl, r1);
//Put the nodes into a vector so we can randomly select them easier:
node_vector.clear();
node_vector.insert(node_vector.begin(), my_net->getNodes().begin(), my_net->getNodes().end() );
r3.setIntRange( node_vector.size() - 1);
ttl = ((int)(log(nodes)/log(2)) + 1);
hit_rate = 0.0;
//We keep the previous p each time as our first try.
p_max = 1.0;
p_min = 0.0;
//p = 5.0 * log(nodes)/((double)(nodes));
while( p < 1.0) {
//Do a binary search for |hit_rate - target| < eps
delete query;
//query = new WalkAndPercMessage(r2,p,ttl);
query = new MagnetMessage(r2,p,ttl);
delete implant;
//implant = new AnycastMessage(r4,1,ttl);
implant = new MagnetMessage(r2,p,ttl);
//implant = new WalkAndPercMessage(r4,p,ttl);
delete my_cnet;
my_cnet = new ContentNetwork(*my_net);
// Insert the content into the network
for(int i = 0; i < cont_count; i++)
{
a_node = node_vector[ r3.getInt() ];
c_node = content_vector[i];
my_cnet->insertContent(a_node, c_node, *implant);
}
//Do a random search for each node and see how many are successful.
Network::NodePSet res_nodes;
hits = 0;
runs = 10;
r1.setIntRange( content_vector.size() - 1);
for(int i = 0; i < runs; i++) {
a_node = node_vector[ r3.getInt() ];
c_node = content_vector[ r1.getInt() ];
res_nodes = my_cnet->queryForContent(a_node, c_node, *query);
if( res_nodes.size() != 0) {
++hits;
/*
Network::NodePSet::iterator rn_it;
for(rn_it = res_nodes.begin(); rn_it != res_nodes.end(); rn_it++) {
cout << " address: " << *rn_it << endl;
}
cout << " Hit: " << hits << " Found content: " << c_node << endl;
cout << "hits: " << res_nodes.size() << endl;
*/
}
}
hit_rate = (double)hits/(double)runs;
cout << p << " " << hit_rate << endl;
p+=0.1;
}
//Delete all the content
my_net->clear();
cout << nodes << " " << p << " " << hit_rate << endl;
delete my_net;
delete pl;
//}
my_cnet->deleteContent();
#endif
#if 0
//Here we look at actual bond percolation on a network.
//We create a network, then delete edges with probability p, and
//look at the connected components.
int nodes;
if( argc > 1) {
nodes = atoi(argv[1]);
}
else {
nodes = 5000;
}
Ran1Random r1(-1234), r2(-23456);
DoublePrefAtNetwork my_net(nodes, r1, 1, 2);
//This is the network we will remove nodes from:
Network tmp_net;
//We get the edges because we will selectively delete some:
Network::EdgeSet::const_iterator e_it;
double keep_prob;
if (argc > 2) {
keep_prob = atof( argv[2] );
}
else {
keep_prob = 0.1;
}
for(keep_prob = 0.0001; keep_prob < 1.0; keep_prob *= 1.05) {
r2.setBoolTrueBias(keep_prob);
//Copy the network:
tmp_net = my_net;
for(e_it = my_net.getEdges().begin(); e_it != my_net.getEdges().end(); e_it++) {
if(r2.getBool() == false) {
tmp_net.remove( *e_it );
}
}
//Find the largest component:
set<Network> comps = tmp_net.getComponents();
set<Network>::const_reverse_iterator comp_it = comps.rbegin();
cout << keep_prob << " " << comp_it->getNodes().size() << endl;
#if 0
cout << "components: " << comps.size() << " ";
cout << "nodes: " << nodes << " p: " << keep_prob << " max comp: " << comp_it->getNodes().size()
<< endl;
#endif
}
#endif
#if 0
//What is the largest degree as a function of network size?
PowerLawProbabilityFunction* pl = 0;
Network* my_net = 0;
Ran1Random my_rand;
int nodes = 10;
for(nodes = 10; nodes < 10000; nodes += 200) {
pl = new PowerLawProbabilityFunction(-2.0,1,nodes);
my_net = new DegreeLawRandomNetwork(nodes,*pl,my_rand);
//Find the maximum degree:
map<int, int> deg_dist = my_net->getDegreeDist();
map<int, int>::reverse_iterator deg_it = deg_dist.rbegin();
cout << nodes << " " << deg_it->first << endl;
delete pl;
pl = 0;
delete my_net;
my_net = 0;
}
#endif
return 1;
}
