void dynNetwork::readParameter ( string parameterString, string fileName ) { cout << "Reading from:" << fileName << endl; cyclicStream *in = new cyclicStream ( fileName ); boost::function<baseType () > r = boost::bind ( &cyclicStream::readBaseType,in ); networkElementType theNodeType = params<baseType>::getNodeTypeFromString ( parameterString ); cout << "Reading parameter \"" << parameterString << "\" for NodeType " << theNodeType << endl; nodeList vl; nodeIterator vi; verticesMatching (vl, theNodeType); for (vi = vl.begin();vi!= vl.end(); vi ++) { // START Änderung by hdickten 08.06.2009 // if (theNodes[i]->getNodeInfo().theNodeType == theNodeType) // if ((theNodes[i]->getNodeInfo().theNodeKind & _dynNode_) != 0) // langsam, bin zu faul // ENDE Änderung #ifdef debug cout << "Writing parameter \"" << parameterString << "\"["<< i <<"]=" << r << endl; #endif // Änderung 10.06.2009: Pointertyp geändert (HD) -> funktioniert nun //((params<baseType>*)theNodes[i])->randomizeParameter(parameterString, theNodeType, r); ( ( dynamic_cast<dynNode*>( node::theNodes[*vi] )->randomizeParameter ( parameterString, theNodeType, r ))); } delete in; }
void network::verticesMatching(nodeList &res, node *n) { // TODO bug ? // throw "stub verticesSimilar"; if (n == network::stdNode) verticesMatching (res, _dynNode_); else { networkElementType nodeType= n->getNodeInfo().theNodeType; nodeIterator vi; for(vi = theNodes.begin(); vi != theNodes.end(); vi++) // if n has standard parameter -> match if node type is equal { dynNode *x = (dynNode*)node::theNodes[*vi]; if ( ((dynNode*) n)->isStandard()) { if (node::theNodes[*vi]->getNodeInfo().theNodeType == nodeType) res.insert(*vi); } else // if n has specified parameter -> match after node type and parameters { if ((node::theNodes[*vi]->getNodeInfo().theNodeType == nodeType) && (( x-> row == ((dynNode*)n)-> params<baseType>::row) || ( x->compareSheets( x-> row , ((dynNode*)n)-> params<baseType>::row) ))) // match nodes, if their parameter are the same. res.insert(*vi); } } } }
void createNetwork::addRandomEdgesDegreeDistributionDirected ( function <double () > r , edgeBlueprint *l) { nodeList vl; verticesMatching (vl,_dynNode_); nodeIterator it; vector <nodeDescriptor> nodeStubs; unsigned int numberLinks; for (it = vl.begin(); it != vl.end(); it++) { numberLinks = r(); for (unsigned int i = 0; i < numberLinks ; i++) nodeStubs.push_back(*it); } // shuffle the stub-list with Fisher-Yates unsigned int j; nodeDescriptor swap; for (unsigned int i = nodeStubs.size()-1; i > 1 ; i = i - 1) { j = gslNoise::getUniformInt (0, i); swap = nodeStubs [j]; nodeStubs [j] = nodeStubs[i]; nodeStubs [i] = swap; } for (unsigned int i = 0 ; i < nodeStubs.size() / 2; i++ ) link ( nodeStubs[2 * i], nodeStubs [ 2 * i + 1], l); }
void statisticsNetwork::closenessCentrality ( string filename ) // funktioniert nur für komplett verbundene Netzwerke korrekt { nodeIterator vi; network::nodeList vl; verticesMatching(vl, _dynNode_); unsigned int i; double distSum; vector <double> CC (vl.size()); vector<baseType> distance; distance.resize(vl.size()); for( vi=vl.begin() ; vi!=vl.end() ; vi++ ) { dijkstra( distance, vl, *vi ); distSum=0; for ( i=0 ; i<vl.size() ; i++ ) distSum = distSum + distance[i]; CC[ *vi -*vl.begin() ] = (vl.size()-1) / distSum ; } ofstream out(filename.c_str()); for( i=0 ; i<vl.size() ; i++) out << CC[i] << endl ; }
void network::edgesBetween(list< edgeDescriptor > &res, nodeKind sourceNodeKind, nodeKind targetNodeKind) { nodeIterator va; nodeList vl; verticesMatching (vl, sourceNodeKind); for (va = vl.begin(); va != vl.end(); va++) edgesBetween(res, node::theNodes[*va]->getNumber(), targetNodeKind); }
void network::edgesBetween(edgeList &res, networkElementType sourceNodeType, networkElementType targetNodeType) { nodeList vl; verticesMatching (vl, sourceNodeType); for (nodeIterator va = vl.begin(); va != vl.end(); va++) edgesBetween(res, node::theNodes[*va]->getNumber(), sourceNodeType); }
void network::clean ( ) { evolveList.clear(); upkeepList.clear(); enterList.clear(); dynNode *nod; nodeList vl; nodeIterator it; verticesMatching(vl,_dynNode_); for (it = vl.begin(); it != vl.end(); it ++) { nod = ( dynamic_cast<dynNode*>( node::theNodes[*it])); nod->clean ( ); if ( nod->timeEvolution() ) evolveList.push_back ( nod ); if ( nod->requiresUpkeep()) upkeepList.push_back (nod); } set <int> streamNumbers; streamOutNode *sn; nodeList vl2; verticesMatching(vl2,_outNode_); for (it =vl2.begin(); it != vl2.end(); ++it) { sn = dynamic_cast<streamOutNode*> (node::theNodes[*it]); if (sn && !streamNumbers.count(sn->localStreamNumber)) { enterList.push_back(sn); streamNumbers.insert(sn->localStreamNumber); } } }
void createNetwork::normalizeInputs (baseType r) { nodeIterator it; nodeList dynNodes; verticesMatching(dynNodes, _dynNode_); for (it = dynNodes.begin(); it != dynNodes.end(); ++it) dynNode::lookUp(*it)->normalizeInWeightSum(r); network::clean(); }
void createNetwork::normalizeInputs (baseType r) { nodeIterator it; nodeList dynNodes; verticesMatching(dynNodes, _dynNode_); for (it = dynNodes.begin(); it != dynNodes.end(); it++) nodeBlueprint::theNodes[*it]->normalizeInWeightSum(r); network::clean(); }
void dynNetwork::realignAtEventSignature (string inputFilename, string outputFilename, networkElementType nt, baseType epsilon, unsigned int eventNumber, unsigned int skip) { nodeList * vl = new nodeList(); verticesMatching(*vl, nt); realign *r = new realign ( inputFilename, outputFilename, vl, epsilon, skip); insertVisiterAtSignature( bind(&realign::realignPeriodically, r), eventNumber); }
void dynNetwork::realignWhenDistant (string inputFilename, string outputFilename, networkElementType nt, baseType epsilon, unsigned int eventNumber, unsigned int multi) { nodeList * vl = new nodeList(); verticesMatching(*vl, nt); realign *r = new realign ( inputFilename, outputFilename, vl, epsilon, multi); insertVisiter( bind(&realign::realignWhenDistant, r), eventNumber); // insertVisiter( bind(&dynNetwork::snapshot, this), eventNumber); }
void network::addEdges (nodeKind sourceNodeKind, nodeDescriptor target, edgeBlueprint *l) { nodeIterator it; nodeList vl; verticesMatching(vl,sourceNodeKind); for (it = vl.begin(); it != vl.end(); it++) addEdge(*it,target, l); }
void statisticsNetwork::degreeCentrality( string filename ) { network::nodeIterator it; network::nodeList vl; verticesMatching(vl, _dynNode_); ofstream out (filename.c_str() ); for( it = vl.begin(); it != vl.end(); it++) out << node::theNodes[*it]->degree() <<endl; out.close(); }
void network::addEdges (nodeDescriptor source, int targetNodeType, edgeBlueprint *l) { nodeIterator it; nodeList vl; verticesMatching(vl,targetNodeType); for (it = vl.begin(); it != vl.end(); it++) addEdge(source, *it, l); }
void dynNetwork::randomizeParameter ( string s,function<baseType () > r ) { networkElementType n = params<baseType>::getNodeTypeFromString ( s ); nodeIterator it; nodeList vl; verticesMatching (vl, n); for (it = vl.begin();it != vl.end(); it ++) ( ( dynamic_cast<dynNode*>( node::theNodes[*it] )->randomizeParameter ( s,n,r ))); }
void network::removeNodes (nodeBlueprint *n) { nodeList vl; verticesMatching (vl, n); nodeIterator vi; for (vi = vl.begin(); vi != vl.end(); vi++ ) { delete node::theNodes[*vi]; node::theNodes[*vi] = 0; // remove from lookup table in node theNodes.erase (*vi); // remove from the network } }
void network::remove ( nodeKind theNodeKind ) { nodeList vl; verticesMatching (vl, theNodeKind); nodeIterator vi; for (vi = vl.begin(); vi != vl.end(); vi++ ) { delete dynNode::lookUp(*vi); // dynNode::lookUp(*vi) = 0; // remove from lookup table in node theNodes.erase (*vi); // remove from the network } }
bool statisticsNetwork::isConnected() { if( isDirected() ) { cout << "Warning! This network is directed. This function cannout make a statement about connectivity."; cout << "\n"; return false; } network::nodeList vl; network::nodeIterator vi; verticesMatching(vl, _dynNode_ ); unsigned int n,i; n = vl.size(); vector<unsigned int> connect; connect.resize(n); nodeDescriptor v,t; for (vi=vl.begin(); vi!=vl.end(); vi++) { connect[0]=1; for( i=1; i<n; i++) { connect[i]=0; } vector<unsigned int> Sub; Sub.push_back(*vi+1); // Knotennummern um +1 verschoben um nicht 0 zu pushen for( i=0; i<Sub.size(); i++) { v = Sub[i]-1; for( node::edgeDescriptor l=0; l<node::theNodes[v]->degree() ; l++) { t = node::theNodes[v]->getTarget(l)->getNumber(); if (connect[ t - *vl.begin()] == 0) { connect[ t - *vl.begin() ] = 1; Sub.push_back(t+1); } } } if( n!=Sub.size() ) return false; } return true; }
void statisticsNetwork::saveAdjacencyList(string fileName) { ofstream out(fileName.c_str()); network::nodeIterator it; network::nodeList vl; verticesMatching(vl, _dynNode_); out << vl.size() << "\n"; for( it = vl.begin(); it != vl.end(); it++) for( node::edgeDescriptor l=0; l<node::theNodes[*it]->degree() ;l++) if (isInsideNetwork(getTarget (*it, l) )) out << *it <<' '<< node::theNodes[*it]->getTarget(l)->getNumber() <<' '<< node::theNodes[*it]->getWeight(l) <<"\n"; // VERÄNDERT // // node::edgeDescriptor ea, ee; // for ( it = theNodes.begin() ; it != theNodes.end() ; it++) // { // // ea = 0; // ee = node::theNodes[*it] ->degree(); // // // for (; ea != ee; ea++) //// { // // Ausgabe der Nodenummer: // out << *it << " "; // // //Ausgabe der jeweiligen Edge // node::theNodes[*it]->printEdgeStatistics(out, network::edgeVerbosity()); // out << endl; // // ENDE //// out << endl; // // /* VERALTET // out << i << " " <<(*ea)->target->getNumber() << " "; // if ((*ea)->getEdgeInfo().theEdgeKind & _weighted_) // out << ((weightedEdge*)(*ea))->getWeight() << "\n"; // else // out << "\n"; // */ //// } // } out.close(); }
void statisticsNetwork::saveAdjacencyMatrix (string fileName) { nodeIterator vi; nodeIterator vj; nodeList vl; verticesMatching(vl, _dynNode_); ofstream out(fileName.c_str()); for (vi = vl.begin(); vi != vl.end(); vi++) { for (vj = vl.begin(); vj != vl.end(); vj++) { out << linkStrength(*vi, *vj) << " "; } out << "\n"; } }
void createNetwork::normalizeOutputs (baseType r) { nodeIterator it; nodeList dynNodes; verticesMatching(dynNodes, _dynNode_); unsigned int degree; for (it = dynNodes.begin(); it != dynNodes.end(); it++) { degree = nodeBlueprint::theNodes[*it]->degree(); for (unsigned int i = 0 ; i < nodeBlueprint::theNodes[*it]->degree(); i ++) { nodeBlueprint::theNodes[*it]->setWeight (i, r / degree); } } }
void dynNetwork::randomizeStatesVec ( nodeBlueprint *n ,vector <boost::function<baseType () > > r ) { if (r.size() == 1) while (r.size() < n->dimension()) r.push_back(r[0]); if (r.size() != n->dimension()) throw "wrong dimension for randomizeStates!"; nodeList vl; nodeIterator it; verticesMatching(vl,n); for ( it = vl.begin(); it != vl.end(); it ++) dynamic_cast<dynNode*>( node::theNodes[*it] ) ->randomizeState ( r ); }
void createNetwork::normalizeOutputs (baseType r) { nodeIterator it; nodeList dynNodes; verticesMatching(dynNodes, _dynNode_); unsigned int degree; for (it = dynNodes.begin(); it != dynNodes.end(); ++it) { degree = dynNode::lookUp(*it)->degree(); for (unsigned int i = 0 ; i < dynNode::lookUp(*it)->degree(); i ++) { dynNode::lookUp(*it)->setWeight (i, r / degree); } } }
baseType statisticsNetwork::meanPathLength() // funktioniert nur für komplett verbundene Netzwerke korrekt { network::nodeIterator vi; network::nodeList vl; verticesMatching(vl, _dynNode_); unsigned int i; double distSum=0; vector<baseType> distance; distance.resize(vl.size()); for( vi=vl.begin() ; vi!=vl.end() ; vi++ ) { dijkstra( distance, vl, *vi); for( i=0 ; i< vl.size() ; i++) distSum = distSum + distance[i]; } return distSum / (vl.size()-1) / vl.size(); }
void network::clean ( ) { evolveList.clear(); upkeepList.clear(); dynNode *nod; nodeList vl; nodeIterator it; verticesMatching(vl,_dynNode_); for (it = vl.begin(); it != vl.end(); it ++) { nod = ( dynamic_cast<dynNode*>( node::theNodes[*it])); nod->clean ( ); if ( nod->timeEvolution() ) evolveList.push_back ( nod ); if ( nod->requiresUpkeep()) upkeepList.push_back (nod); } }
void dynNetwork::noiseToStatesVec ( nodeBlueprint *n ,vector <boost::function<baseType () > > r ) { if (r.size() == 1) while (r.size() < n->dimension()) r.push_back(r[0]); if (r.size() != n->dimension()) throw "wrong dimension for randomizeStates!"; nodeList vl; verticesMatching (vl, n); nodeIterator vi; vector <baseType> argList(n->dimension()); for (vi = vl.begin();vi != vl.end(); vi++ ) { for (unsigned int i = 0; i < n->dimension() ; i++) { argList[i] = getState (*vi, i) + r[i](); } setInitialConditionVec (*vi, argList); } }
bool network::isDirected() { nodeIterator vi, vj; network::nodeList vl; verticesMatching(vl, _dynNode_ ); bool res = false; for(vi=vl.begin(); vi!=vl.end(); vi++) { for(vj=vl.begin(); vj!=vi; vj++) { if( network::linkStrength(*vi,*vj) != network::linkStrength(*vj,*vi) ) { res = true; break; } } } return res; }
bool network::isGraph() { nodeList vl; nodeIterator vi; verticesMatching (vl, _dynNode_); edgeList el; for (vi = vl.begin(); vi != vl.end(); vi++) { edgesBetween (el, *vi, _dynNode_); // el.sort ([&](edgeDescriptor l, edgeDescriptor r) -> bool { return getTarget(l) < getTarget (r); } ) el.sort (compareByTargets); edgeIterator ePrev = el.begin(); if (getTarget (*ePrev) == getSource(*ePrev)) return 0; edgeIterator eSucc = el.begin(); eSucc ++; for (; eSucc != el.end(); ePrev++, eSucc++) { if ((getTarget(*ePrev) == getTarget (*eSucc)) || (getTarget(*eSucc) == getSource (*eSucc))) return 0; } el.clear(); } return 1; }
unsigned int network::numberVertices (nodeBlueprint * n ) { nodeList vl; verticesMatching (vl,n); return vl.size(); }
void statisticsNetwork::betweennessCentrality( string filename ) // uses the algorithm provided by U. Brandes in "A faster algorithm for betweenness Centrality", // J. Math. Sociol., 25:163-177, 2001 { network::nodeIterator ia; nodeList vl; verticesMatching(vl, _dynNode_); unsigned int t; nodeDescriptor v, w; double d; vector <double> CB (vl.size()); // array CB[v] für alle v in n for ( t=0 ; t<vl.size() ; t++) CB[t]=0.0; list<int> S; vector < list<int> > P (vl.size()); // listen P[w] für jedes w aus n vector <double> sigma (vl.size()); // array sigma der Länge vl.size() dijkstraCompare dC; relaxed_heap < nodeDescriptor, dijkstraCompare > Q (vl.size()+3, dC); // queue Q dC.weightMap.resize(vl.size()); vector <double> delta (vl.size());// array delta der Länge vl.size() for ( ia=vl.begin() ; ia!=vl.end() ; ia++ ) { while(!S.empty()) // S leeren S.pop_back(); for ( t=0 ; t<vl.size() ; t++) // alle P[t] leeren while( !P[t].empty() ) P[t].pop_back(); for ( t=0 ; t<vl.size() ; t++ ) sigma[t]=0; sigma[*ia -*vl.begin()]=1; for ( t=0 ; t<vl.size() ; t++ ) dC.weightMap[t]=numeric_limits<baseType>::infinity(); dC.weightMap[*ia -*vl.begin()]=0; while(!Q.empty()) // Q leeren Q.pop(); Q.push( *ia+1 -*vl.begin() ); // +1 um nicht 0 zu pushen, daher sind die Knotennrn in Q um 1 verschoben while(!Q.empty()) { v = Q.top()-1 +*vl.begin(); Q.pop(); S.push_back( v+1 -*vl.begin() ); for ( node::edgeDescriptor l=0 ; l<node::theNodes[v]->degree() ; l++ ) //weightMap aktualisieren { w = node::theNodes[v]->getTarget(l)->getNumber(); // alle Nachbarn w von v d = 1/( node::theNodes[v]->getWeight(l) ); // d misst die Entfernung zwischen w und v if ( dC.weightMap[w -*vl.begin()] == numeric_limits<baseType>::infinity() ) // zum ersten Mal entdeckt? { dC.weightMap[w -*vl.begin()] = dC.weightMap[v -*vl.begin()] + d; Q.push(w+1 -*vl.begin()); } else if ( dC.weightMap[w -*vl.begin()] > (dC.weightMap[v -*vl.begin()] + d) && dC.weightMap[w -*vl.begin()] < numeric_limits<baseType>::infinity() ) { dC.weightMap[w -*vl.begin()] = dC.weightMap[v -*vl.begin()] + d; Q.update(w+1 -*vl.begin()); } } for ( node::edgeDescriptor l=0 ; l<node::theNodes[v]->degree() ; l++ ) // Prezedessoren checken { w = node::theNodes[v]->getTarget(l)->getNumber(); // alle Nachbarn w von v d = 1/( node::theNodes[v]->getWeight(l) ); // d misst die Entfernung zw w und v // hier soll auf gleichheit kontrolliert werden... if ( dC.weightMap[v -*vl.begin()] == dC.weightMap[w -*vl.begin()] + d ) // kürzester Weg nach v via w? { sigma[v -*vl.begin()] = sigma[v -*vl.begin()] + sigma[w -*vl.begin()]; P[v -*vl.begin()].push_back(w+1 -*vl.begin()); // ggf w Prezedessor von v } // Ähnlichkeitsvergleich für d!= integer: relative Abweicheichung else if ( dC.weightMap[v -*vl.begin()] > dC.weightMap[w -*vl.begin()] ) { double relativeError = 0.001; if( fabs(dC.weightMap[v -*vl.begin()] - dC.weightMap[w -*vl.begin()] - d) / dC.weightMap[v -*vl.begin()] < relativeError ) { sigma[v -*vl.begin()] = sigma[v -*vl.begin()] + sigma[w -*vl.begin()]; P[v -*vl.begin()].push_back(w+1 -*vl.begin()); // ggf w Prezedessor von v } } } } for ( t=0 ; t<vl.size() ; t++ ) delta[t]=0; while(!S.empty()) { w = S.back() -1; S.pop_back(); while ( !P[w].empty() ) { v = P[w].back() -1; P[w].pop_back(); delta[v] = delta[v] + (1+delta[w])*sigma[v]/sigma[w]; } if ( w != *ia -*vl.begin()) CB[w] = CB[w] + delta[w]; } } for( t=0 ; t<vl.size() ; t++ ) // Normierung auf [0;1] CB[t] = CB[t] / vl.size() / (vl.size()-1); ofstream out(filename.c_str()); for( t=0 ; t<vl.size() ; t++ ){ out << CB[t] << endl ; } out.close(); }