bug fixing

Jamroot

@@ -32,7 +32,7 @@
 #
 #using gcc ;
 
-using python : ;
+#using python : ;
 
 #using bisonc++ ;
 #using flex++ ;
@@ -45,7 +45,7 @@ project conedy ;
 
 
 
-#using python : 2.5 ;
+using python : 2.7 ;
 
 #project : conedy ? ;
 

createNetwork.cpp

@@ -1413,28 +1413,6 @@ void createNetwork::observeSum ( string s, edgeBlueprint *l )
 
 //! wie oben allerdings wird die Phasenkohärenz r der States s_i weggeschrieben: r = 1/N \sum\limits_i exp( 2 * PI * s_i). Phasen gehen von 0 bis 1 !!! TODO: vielleicht von streamOutNode erben ??
 
-//void createNetwork::observePhaseCoherence ( string s )
-//{
-//	nodeBlueprint *nod = new nodeVirtualEdges < calculateMeanPhaseCoherence > ();
-//	nodeDescriptor newNodeNumber = addNode ( nod );
-//	network::addEdges ( newNodeNumber,_dynNode_ );
-//	delete nod;
-//	observe(newNodeNumber,s);
-//}
-
-
-//void createNetwork::observeAll ( string s, edgeBlueprint *l )
-//{
-//	network::nodeList vl;
-//	network::verticesMatching ( vl,_dynNode_ );
-//	network::nodeIterator it;
-//
-//	for ( it = vl.begin(); it != vl.end(); it++ )
-//		observe( *it,s, l);
-//
-//}
-//
-
 
 
 void createNetwork::observeAll ( string s,  edgeBlueprint *l, nodeBlueprint *n)
@@ -1453,8 +1431,8 @@ void createNetwork::observePhaseCoherence ( string s, edgeBlueprint *l, nodeBlue
 
 	nodeBlueprint *nod = new nodeVirtualEdges < calculateMeanPhaseCoherence > ();
 	nodeDescriptor newNodeNumber = addNode ( nod );
-	nodeList vl;
 
+	nodeList vl;
 	verticesMatching(vl, n);
 
 	nodeIterator vi;
@@ -1466,7 +1444,6 @@ void createNetwork::observePhaseCoherence ( string s, edgeBlueprint *l, nodeBlue
 	nodeDescriptor outNodeNumber = addStreamOutNode ( s );
 	link ( outNodeNumber, newNodeNumber);
 	inOutNodeList.push_back ( dynamic_cast<dynNode*> ( node::theNodes[outNodeNumber] ));
-	delete nod;
 }
 
 //void createNetwork::observePhaseDistance ( string s, nodeBlueprint *n)
@@ -1542,7 +1519,7 @@ void createNetwork::observe ( nodeDescriptor number, string s, edgeBlueprint * l
 	nodeDescriptor newNodeNumber = addStreamOutNode(s);
 	if (node::theNodes.size()  <= number  || node::theNodes[number] == NULL)
 		throw "node which should be observed does not exist.";
-	if	(match (number, _dynNode_))
+	if	(!match (number, _dynNode_))
 		throw "node to be observed is no dynNode.";
 
 	link ( newNodeNumber, number,l );
@@ -1562,6 +1539,7 @@ nodeDescriptor createNetwork::addStreamOutNode (string s)
 		nod = new nodeVirtualEdges <streamOutNode > ( s );
 
 	nodeDescriptor newNodeNumber = addNode ( nod );
+	delete nod;
 	return newNodeNumber;
 }
 

edge.h

@@ -82,9 +82,9 @@ namespace conedy
 			static baseType weight;
 
 		public:
-			staticWeightedEdge() {};
+//			staticWeightedEdge() {};
 			//			staticWeightedEdge ( node* t ) : weightedEdge(t) {};
-			staticWeightedEdge (baseType newWeight)  {    weight = newWeight;};
+			staticWeightedEdge (baseType newWeight = 1)  {    weight = newWeight;};
 
 			staticWeightedEdge (nodeDescriptor targetNumber, baseType newWeight) : EDGE (targetNumber)  {    weight = newWeight;};
 			const edgeInfo getEdgeInfo() {edgeInfo ei = {_staticWeightedEdge_,_weighted_,"staticWeightedEdge"}; return ei;}

fullNetwork.h

@@ -57,6 +57,20 @@ class networkTemplate : public createNetwork, public statisticsNetwork, public s
 
 };
 
+class directedNetwork : public networkTemplate
+{
+	public:
+		directedNetwork() { network::setDirected(); }
+};
+
+
+class undirectedNetwork : public networkTemplate
+{
+	public:
+		undirectedNetwork() { network::setUndirected(); }
+};
+
+
 }
 #endif
 

network.cpp

@@ -48,6 +48,10 @@ namespace conedy
 
 
 
+	void network::replaceNodes(nodeDescriptor nodeNumber, nodeBlueprint *n)
+	{
+		throw "replaceNodes is a stub";
+	}
 
 
 
@@ -347,6 +351,12 @@ unsigned int network::numberVertices (nodeKind theNodeKind )
 }
 
 
+void network::removeNodes (nodeBlueprint *n)
+{
+	throw "removeNodes is a stub."; 
+}
+
+
 
 void network::remove ( nodeKind theNodeKind )
 {
@@ -355,25 +365,23 @@ void network::remove ( nodeKind theNodeKind )
 	verticesMatching (vl, theNodeKind);
 	nodeIterator vi;
 
-	for (vi = theNodes.begin(); vi != theNodes.end(); )
+	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
+	}
+
+}
+
+
+
+
 
 
-		if (node::theNodes[*vi]->getNodeInfo().theNodeKind == theNodeKind)
-		{
-			delete node::theNodes[*vi];
-			nodeIterator here = vi;
-			vi++;
-			theNodes.erase(here);
-			numberOfNodes--;
-		}
-		else
-			vi++;
 
-	}
 
 
-}
 
 
 //

network.h

@@ -136,6 +136,8 @@ namespace conedy
 
 			void setUndirected () { directed = false; };
 
+			//! returns the connections strength between node i and j, returns 0 if no connection exists.
+			baseType linkStrength ( nodeDescriptor i, nodeDescriptor j ) { return node::theNodes[i]->linkStrength ( j ); }
 
 
 		friend bool compareByTargets (network::edgeDescriptor l, network::edgeDescriptor r) {return network::getTarget(l) < network::getTarget(r); } 
@@ -148,8 +150,6 @@ namespace conedy
 			bool directed;
 
 
-			//! returns the connections strength between node i and j, returns 0 if no connection exists.
-			baseType linkStrength ( nodeDescriptor i, nodeDescriptor j ) { return node::theNodes[i]->linkStrength ( j ); }
 
 
 			//! returns the number of nodes in the network

neuroPython.cpp

@@ -349,7 +349,7 @@ template <class N>
 	BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS (cycle_overloads, cycle, 2,4);
 	BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS (createFromAdjacencyList_overloads, createFromAdjacencyList, 1,3);
 	BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS (createFromAdjacencyMatrix_overloads, createFromAdjacencyMatrix, 1,3);
-	BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS (observePhaseCoherence_overloads, observePhaseCoherence, 1,5);
+	BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS (observePhaseCoherence_overloads, observePhaseCoherence, 1,3);
 	BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS (observeSum_overloads, observeSum, 1,2);
 	BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS (setState_overloads, setInitialCondition, 2,13);
 	BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS (getState_overloads, getState, 1,2);
@@ -418,13 +418,17 @@ template <class N>
 		def("get", &globals::getGlobal<int>);
 		def("setRandomSeed", &gslNoise::setSeed);
 
-		class_<createNetwork>("createNetwork");
+		class_<createNetwork>("createNetwork")
+			.def("addNode", &network::addNode, reinterpret_cast<const char *>(__network_addNode));
+
+
+
 		class_<dynNetwork>("dynNetwork");
-		
+
 
 		class_<networkTemplate, bases <createNetwork, dynNetwork> >("network")
 			//	 class_<networkTemplate >("directedNetwork")
-			.def("__init__", make_constructor(networkFactory))
+			.def("__init__", make_constructor(directedNetworkFactory))
 			.def("__del__", &networkTemplate::clear, reinterpret_cast<const char *>(__network_clear))
 			.def("lattice", &networkTemplate::lattice, lattice_overloads(reinterpret_cast<const char *>(__createNetwork_lattice)))
 
@@ -438,28 +442,27 @@ template <class N>
 			.def("observeSum", &networkTemplate::observeSum, observeSum_overloads( reinterpret_cast<const char *>(__dynNetwork_observeSum)))
 			.def("printNodeStatistics", &networkTemplate::printNodeStatistics, reinterpret_cast<const char *>(__statisticsNetwork_printNodeStatistics))
 			.def("removeObserver", &networkTemplate::removeObserver, reinterpret_cast<const char *>(__dynNetwork_removeObserver))
+			.def("setTime", &networkTemplate::setTime, reinterpret_cast<const char *>(__dynNetwork_setTime))
 
 			////network commands
 			.def("addEdge", &networkTemplate::addEdge, reinterpret_cast<const char *>(__network_addEdge))
-			.def("addNode", &networkTemplate::addNode, reinterpret_cast<const char *>(__network_addNode))
 			.def("addWeightedEdge", &networkTemplate::addWeightedEdge, reinterpret_cast<const char *>(__network_addWeightedEdge))
 			.def("clear", &networkTemplate::clear, reinterpret_cast<const char *>(__network_clear))
-			.def("replaceNodes", &networkTemplate::replace, reinterpret_cast<const char *>(__network_replace))
+			.def("replaceNodes", &networkTemplate::replaceNodes, reinterpret_cast<const char *>(__network_replace))
 			.def("removeNodes", &networkTemplate::removeNodes, reinterpret_cast<const char *>(__network_removeNodes))
-			.def("isLinked", &networkTemplate::isLinked, reinterpret_cast<const char *>(__statisticsNetwork_isLinked))
-			.def("linkStrength", &networkTemplate::linkStrength, reinterpret_cast<const char *>(__statisticsNetwork_linkStrength))
-			.def("size", &networkTemplate::size, reinterpret_cast<const char *>(__statisticsNetwork_size))	
-			.def("randomizeWeights", &networkTemplate::randomizeWeights_overloads, reinterpret_cast<const char *>(__createNetwork_randomizeWeights))
-			.def("removeEdges", &networkTemplate::removeEdges, reinterpret_cast<const char *>(__createNetwork_addRandomEdges))
-			.def("removeEdge", &networkTemplate::removeEdge, reinterpret_cast<const char *>(__createNetwork_removeEdge))
+			.def("isLinked", &networkTemplate::isLinked, reinterpret_cast<const char *>(__network_isLinked))
+			.def("linkStrength", &networkTemplate::linkStrength, reinterpret_cast<const char *>(__network_linkStrength))
+			.def("size", &networkTemplate::size, reinterpret_cast<const char *>(__network_size))	
+			.def("randomizeWeights", &networkTemplate::randomizeWeights,  randomizeWeights_overloads( reinterpret_cast<const char *>(__network_randomizeWeights)))
+			.def("removeEdges", &networkTemplate::removeEdges, reinterpret_cast<const char *>(__network_removeEdges))
+			.def("removeEdge", &networkTemplate::removeEdge, reinterpret_cast<const char *>(__network_removeEdge))
 
 			////statisticsNetworkCommands
 			.def("betweennessCentrality", &networkTemplate::betweennessCentrality, reinterpret_cast<const char *>(__statisticsNetwork_betweennessCentrality))
 			.def("closenessCentrality", &networkTemplate::closenessCentrality, reinterpret_cast<const char *>(__statisticsNetwork_closenessCentrality))
 			.def("degreeCentrality", &networkTemplate::degreeCentrality, reinterpret_cast<const char *>(__statisticsNetwork_degreeCentrality))
 			.def("degree", &networkTemplate::degree, reinterpret_cast<const char *>(__statisticsNetwork_degree))
 			.def("size", &networkTemplate::size, reinterpret_cast<const char *>(__statisticsNetwork_size))	
-			.def("setTime", &networkTemplate::setTime, reinterpret_cast<const char *>(__dynNetwork_setTime))
 			.def("meanDegree", &networkTemplate::meanDegree, reinterpret_cast<const char *>(__statisticsNetwork_meanDegree))
 			.def("meanWeight", &networkTemplate::meanWeight, reinterpret_cast<const char *>(__statisticsNetwork_meanWeight))
 			.def("meanClustering", &networkTemplate::meanClustering, reinterpret_cast<const char *>(__statisticsNetwork_meanClustering))
@@ -475,7 +478,6 @@ template <class N>
 			.def("removeRandomEdges", &networkTemplate::removeRandomEdges, reinterpret_cast<const char *>(__createNetwork_removeRandomEdges))
 			.def("removeRandomEdgesUndirected", &networkTemplate::removeRandomEdgesUndirected, reinterpret_cast<const char *>(__createNetwork_removeRandomEdgesUndirected))
 			.def("addRandomEdges", &networkTemplate::addRandomEdges, addRandomEdges_overloads (reinterpret_cast<const char *>(__createNetwork_addRandomEdges)))
-
 			.def("torusNearestNeighbors", &networkTemplate::torusNearestNeighbors,  reinterpret_cast<const char *>(__createNetwork_torusNearestNeighbors))
 			//		.def("loadGraphML", &networkTemplate::loadGraphML, reinterpret_cast<const char *>(__createNetwork_loadGraphXml))
 			.def("saveGraphML", &networkTemplate::saveGraphML, reinterpret_cast<const char *>(__createNetwork_saveGraphML))
@@ -484,7 +486,6 @@ template <class N>
 			.def("createFromAdjacencyMatrix", &networkTemplate::createFromAdjacencyMatrix ,  createFromAdjacencyMatrix_overloads( reinterpret_cast< const char *> (__createNetwork_createFromAdjacencyMatrix)))
 			.def("saveAdjacencyMatrix", &networkTemplate::saveAdjacencyMatrix, reinterpret_cast<const char *>(__createNetwork_saveAdjacencyMatrix))
 			.def("randomNetwork", &networkTemplate::randomNetwork ,  randomNetwork_overloads( reinterpret_cast< const char *> (__createNetwork_randomNetwork)))
-// 			.def("randomUndirectedNetwork", &networkTemplate::randomUndirectedNetwork ,  randomUndirectedNetwork_overloads( reinterpret_cast< const char *> (__createNetwork_randomUndirectedNetwork)))
 			.def("completeNetwork", &networkTemplate::completeNetwork, completeNetwork_overloads( reinterpret_cast<const char *>(__createNetwork_completeNetwork)))
 			.def("line", &networkTemplate::line, reinterpret_cast<const char *>(__createNetwork_line))
 			.def("cycle", &networkTemplate::cycle, cycle_overloads( reinterpret_cast<const char *>(__createNetwork_cycle)))
@@ -586,12 +587,12 @@ template <class N>
 
 
 
-		class_<networkTemplate, bases <networkTemplate> >("directedNetwork")
-				.def ("__init__", make_constructur(directedNetworkFactory));
+		class_<directedNetwork, bases <networkTemplate> >("directedNetwork");
+//				.def ("__init__");
 
 
-		class_<networkTemplate, bases <networkTemplate> >("undirectedNetwork")
-				.def ("__init__", make_constructur(undirectedNetworkFactory));
+		class_<undirectedNetwork, bases <networkTemplate> >("undirectedNetwork");
+//				.def ("__init__");
 
 		//	class_< delayEdge
 

testing/dynNetwork/writeBinary.co

@@ -12,6 +12,7 @@ samplingTime= 0.015;
 N.observeTime("output/writeBinary.co.time");
 
 
-#N.printNodeStatistics();
+N.printNodeStatistics();
 
 N.evolve(0.0,10.0);
+

testing/integrators/coupledSystems.co

@@ -16,9 +16,13 @@ N.setState(j+1, startwertb);
 N.setParam(j, "onlyCoupling_a", a);
 N.setParam(j+1, "onlyCoupling_a", b);
 N.observe(j, "output/coupledSystems.co.single", component(0));
+
+
 N.evolve(0.0,100.0);
 N.clear();
 
+
+
 odeStepSize = 0.001;
 
 j = N.completeNetwork(2, onlyCouplingCouplingSum(), staticWeightedEdge());

testing/integrators/coupledSystems2.co

@@ -42,5 +42,5 @@ N.observe(k, "output/coupledSystems2.co.double", component(0));
 N.evolve(0.0,40.0);
 N.clear();
 
-#:diff output/coupledSystems2.co.single output/coupledSystems2.co.double:;
-#:diff output/coupledSystems2.co.singleCouplingSum output/coupledSystems2.co.double:;
+:"diff output/coupledSystems2.co.single output/coupledSystems2.co.double":;
+:"diff output/coupledSystems2.co.singleCouplingSum output/coupledSystems2.co.double":;

testing/integrators/doubleEvolveSde.co

@@ -2,7 +2,7 @@ network N;
 
 N.addNode(ornUhl());
 N.observeTime("output/doubleEvolveSde.co.series");
-N.observeAll("output/doubleEvolveSde.co.series",ornUhl(),component(0));
+N.observeAll("output/doubleEvolveSde.co.series",component(0),ornUhl());
 N.evolve(0.0, 1.0);
 N.evolve(1.0, 2.0);
 

testing/integrators/singleEvolveSde.co

@@ -2,7 +2,7 @@ network N;
 
 N.addNode(ornUhl());
 N.observeTime("output/singleEvolveSde.co.series");
-N.observeAll("output/singleEvolveSde.co.series",ornUhl(), component(0));
+N.observeAll("output/singleEvolveSde.co.series", component(0),ornUhl());
 N.evolve(0.0, 2.0);