nodeImplement.h

#ifndef nodeImplement_h
#define nodeImplement_h nodeImplement_h



#include "dynNode.h"
#include "edge.h"

#include <complex>


namespace conedy {

	template <typename T>
		void eraseZero (vector <T> & vec)
		{
			unsigned int read = 0;
			unsigned int write = 0;
			for (read =0; read < vec.size();read ++)
			{
				if (vec[read] == 0)
					continue;
				vec[write] = vec[read];
				write++;
			}
			vec.resize(write);

		}


	template <typename T>
		void eraseAll (vector <T> & vec, T what)
		{
			unsigned int read = 0;
			unsigned int write = 0;
			for (read =0; read < vec.size();read ++)
			{
				if (vec[read] == what)
					continue;
				vec[write] = vec[read];
				write++;
			}
		}




	//!	Implementierung der vin node mit virtuellen Funktionen. Brauch mehr Speicherals nodeTemplateEdges, dafür können unterschiedliche Edge-Typen gespeichert werden.
	template <typename DYNNODE>
		class nodeVirtualEdges : public  DYNNODE
	{
		public:

#ifdef PRECALCULATEWEIGHTSUM
			baseType preCalculatedWeightSum;
#endif


			typedef node  targetNodeType;
			typedef edgeVirtual edgeType;
			typedef typename DYNNODE::edgeDescriptor edgeDescriptor;


			// Konstruktoren
			//! Dieser Konstruktor ist nur zum Konstruieren der  Blaupausen gedacht. Echte Knoten im Netzwerk werden von Blaupausenknoten über construct erzeugt.
			virtual ~nodeVirtualEdges();

			//    			nodeVirtualEdges ( networkElementType n) : DYNNODE ( n ) {}
			nodeVirtualEdges () : DYNNODE ( ) {}
			nodeVirtualEdges (string s) : DYNNODE (s) {}
			nodeVirtualEdges (unsigned int i) : DYNNODE (i) {}


			virtual void clean () {


#ifdef PRECALCULATEWEIGHTSUM



				baseType res = 0;
				edgeIterator ei;
				for ( ei =outEdges.begin(); ei != outEdges.end(); ei++ )
					res = res +  (*ei)->getWeight();

				preCalculatedWeightSum = res;



#endif


				unsigned int read = 0;
				unsigned int write = 0;
				for (read =0; read < outEdges.size();read ++)
				{
					if (outEdges[read]->targetNumber == (nodeDescriptor) -1)
					{
						delete outEdges[read];
						continue;
					}
					outEdges[write] = outEdges[read];
					write++;
				}
				outEdges.resize(write);

				DYNNODE::clean();



			}


			virtual void printEdgeStatistics ( ostream &os, int edgeVirtualVerbosity=1);
			virtual edgeInfo getEdgeInfo (edgeDescriptor eD) {return outEdges[eD]->getEdgeInfo(); }
			virtual void setWeight (edgeDescriptor theEdge, baseType w) { outEdges[theEdge]->setWeight(w); }
			virtual nodeDescriptor getTarget(edgeDescriptor theEdge) { return outEdges[theEdge]->getTarget(); }
			virtual baseType getWeight (edgeDescriptor theEdge) { return outEdges[theEdge]->getWeight(); }
			virtual baseType getTargetState (edgeDescriptor theEdge) { return outEdges[theEdge]->getTargetState(); }
			virtual edgeVirtual * getEdge (edgeDescriptor eD){ return outEdges[eD]; }

			// Verbindungen hinzufügen, entfernen
			virtual bool unlink (nodeDescriptor targetNumber);

			virtual void removeEdge	(edgeDescriptor e)
			{
				outEdges[e]->targetNumber = -1;
			}

			virtual void removeEdges() { outEdges.clear(); }

			virtual void link (nodeDescriptor targetNumber, baseType weight);
			virtual void link (nodeDescriptor targetNumber, edgeVirtual	*l);
			virtual bool isLinked ( nodeDescriptor target );
			virtual baseType linkStrength ( nodeDescriptor target );
			virtual void normalizeInWeightSum(baseType d);
			//		virtual void printStatistics();


			virtual node *construct()
			{
				return  new nodeVirtualEdges<DYNNODE>( *this );
			};


			// Statistikkram
			//		virtual void printStatistics();
			virtual unsigned int degree() { return outEdges.size();}
			virtual baseType weightSum();
			virtual baseType inWeightSum();
			//			virtual nodeDescriptor getNumber(); // { return ( nodeDescriptor ) number; };

		protected:

			//! so wie couplingSum. Allerdings werden die Zustände zirkulär addiert.
			baseType getMeanPhaseCoherence() ;
			baseType couplingSum();
			void fire (
					);
		private:
			//! Variable, die von der Klasse offeriert wird, zum Beispiel zum Einkoppeln in andere Nodes
			//		baseType state;


			//! Private Variable, in denen die Edges gespeichert werden
			vector <edgeVirtual* > outEdges;    // Liste der ausgehenden Kanten
			typedef  vector <edgeVirtual*  >::iterator edgeIterator;

	};




	template <typename DYNNODE>
		void nodeVirtualEdges<DYNNODE>::printEdgeStatistics(ostream &os, int edgeVirtualVerbosity)
		{
			if (edgeVirtualVerbosity > 0)
				os << "virtual edges:";

			for (unsigned int i = 0; i < outEdges.size(); i++)
				outEdges[i]->printStatistics(os, edgeVirtualVerbosity );
			os<< endl;
		}


	template <typename DYNNODE>
		nodeVirtualEdges<DYNNODE>::~nodeVirtualEdges()
		{
			// Edges löschen
			for (edgeIterator it = outEdges.begin(); it!=outEdges.end(); it++ )
			{
				delete ( *it );
			}

			//zeiger auf edges löschen
			//		outEdges.rlear();
		}


	template <typename DYNNODE>
		bool nodeVirtualEdges<DYNNODE>::unlink ( nodeDescriptor target )
		{
			bool res = false;
			edgeIterator s;

			for ( s=outEdges.begin(); s != outEdges.end(); s++ )
			{
				if ((*s)->targetNumber  == target )
				{
					res = true;
					//				outEdges.remove(s);
					//				delete *s;
					//				outEdges.erase ( s );
					(*s)->targetNumber = (nodeDescriptor)-1;
					break;
				}
			}
			return res;
		}



	template <typename DYNNODE>
		baseType nodeVirtualEdges<DYNNODE>::couplingSum()
		{
			baseType re = 0;

			edgeIterator it, end;
			it =  outEdges.begin();
			end = outEdges.end();
			for ( ;it!=end; it++ )
				re = re + (*it)->getWeight() *  (*it)->getTargetState();
			return re;
		}



	//		a = new weightedEdgeVirtual ( targetNumber, w );
	//		outEdges.push_back ( a );

	//	}



	template <typename DYNNODE>
void nodeVirtualEdges<DYNNODE>::link (nodeDescriptor targetNumber,  edgeVirtual *l )
{
	edgeVirtual *newEdge =   l->construct();
	newEdge->targetNumber= targetNumber;
	outEdges.push_back (newEdge );
}


	template <typename DYNNODE>
void nodeVirtualEdges<DYNNODE>::link (nodeDescriptor targetNumber,  baseType weight)
{
	weightedEdgeVirtual	*newEdge = new weightedEdgeVirtual(targetNumber,weight);
	outEdges.push_back ( newEdge );
}


	template <typename DYNNODE>
bool nodeVirtualEdges<DYNNODE>::isLinked ( nodeDescriptor target )
{
	bool res = false;
	edgeIterator s;
	for ( s=outEdges.begin(); s != outEdges.end(); s++ )
	{
		if ((*s )->targetNumber == target )
		{
			res = true;
			break;
		}
	}
	return res;
}


	template <typename DYNNODE>
void nodeVirtualEdges<DYNNODE>::fire ()
{
	edgeIterator it, end;
	it =  outEdges.begin();
	end = outEdges.end();
	for ( ;it!=end; it++ )
		((dynNode*)(node::theNodes[(*it)->getTarget()] ) ) ->excite ( (*it) ->getWeight() );
}



template <typename DYNNODE>
baseType nodeVirtualEdges<DYNNODE>::inWeightSum() {
	baseType res = 0;
	vector<node *>::iterator it;
	
	for (unsigned int i = 0 ; i < DYNNODE::theNodes.size(); i++)
		res+= linkStrength(i);
	
	return res;
}




#ifdef PRECALCULATEWEIGHTSUM
template <typename DYNNODE>
baseType nodeVirtualEdges<DYNNODE>::weightSum() {
	return preCalculatedWeightSum;
}
#else
	template <typename DYNNODE>
baseType nodeVirtualEdges<DYNNODE>::weightSum()
{
	baseType res = 0;
	edgeIterator ei;
	for ( ei =outEdges.begin(); ei != outEdges.end(); ei++ )
		res = res +  (*ei)->getWeight();
	return res;
}

#endif

	template <typename DYNNODE>
baseType nodeVirtualEdges<DYNNODE>::getMeanPhaseCoherence()
{
	complex<baseType> re ( ( baseType ) 0, ( baseType ) 0 );
	//	complex<double> dummy;
	edgeIterator i;
	for ( i = outEdges.begin(); i != outEdges.end(); i++ )
	{
		complex<baseType> dummy ( (baseType)0.0, (baseType) ( *i )->getTargetState() );
		re = re + exp ( dummy );

	}
	return abs ( re );
}





	template <typename DYNNODE>
void nodeVirtualEdges<DYNNODE>::normalizeInWeightSum(baseType d)
{

	nodeDescriptor i;
	baseType a;
	vector<nodeDescriptor> presynaptics;

	for (i = 0; i < node::theNodes.size(); i++)
		if ((a = node::theNodes[i]->linkStrength(this->getNumber()))) {

			//					inWeightSum += a;
			presynaptics.push_back (i);
		}
	for ( i = 0; i < presynaptics.size();i++)
	{
		node::theNodes[presynaptics[i]]->unlink(DYNNODE::getNumber());
		node::theNodes[presynaptics[i]]-> link (DYNNODE::getNumber(),  d / presynaptics.size());

	}


}





	template <typename DYNNODE>
baseType nodeVirtualEdges<DYNNODE>::linkStrength ( nodeDescriptor target )
{
	baseType res = 0;
	edgeIterator s;
	for ( s=outEdges.begin(); s != outEdges.end(); s++ )
	{
		if (  (*s)->targetNumber  == target )
		{
			res = ( *s )->getWeight();
			break;
		}
	}
	return res;
}


















//! Implementierung von node mit Edges ohne virtuelle Funktionen (brauch weniger Speicherpladz und ist theoretisch schneller.
template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
class nodeTemplateEdges : public DYNNODE
{
	public:

#ifdef PRECALCULATEWEIGHTSUM
		baseType preCalculatedWeightSum;
#endif


		typedef EDGEVIRTUAL  targetNodeType;
		typedef EDGE edgeType;
		static EDGE standardEdge;
		typedef typename DYNNODE::edgeDescriptor edgeDescriptor;

		//! Statischer Vector mit Zeigern zu allen Knoten, die mit construct erzeugt wurden.
		static vector<nodeTemplateEdges* > theNodes;



		//! Variable, die von der Klasse offeriert wird, zum Beispiel zum Einkoppeln in andere Nodes
		baseType state;



		virtual void removeEdge	(edgeDescriptor e)
		{
			outEdges[e].targetNumber = -1;
		}

		virtual void clean () {
#ifdef PRECALCULATEWEIGHTSUM

			baseType res = 0;

			edgeIterator ei;
			for ( ei =outEdges.begin(); ei != outEdges.end(); ei++ )
				res = res +  ei->getWeight();



			preCalculatedWeightSum = res;

#endif


			unsigned int read = 0;
			unsigned int write = 0;
			for (read =0; read < outEdges.size();read ++)
			{
				if (outEdges[read].targetNumber == (nodeDescriptor) -1)
					continue;
				outEdges[write] = outEdges[read];
				write++;
			}
			outEdges.resize(write);

			DYNNODE::clean();


		}


		//   			nodeTemplateEdges ( networkElementType n) : DYNNODE( n ) {}


		// Konstruktoren
		//! Dieser Konstruktor ist nur zum Konstruieren der  Blaupausen gedacht. Echte Knoten im Netzwerk werden von Blaupausenknoten über construct erzeugt.
		nodeTemplateEdges () :state ( 0 ) {};

		//		list< edgeDescriptor >

		//! Private Variable, in denen die Edgess gespeichert werden
		vector <EDGE > outEdges;    // Liste der ausgehenden Kanten

		virtual edgeInfo getEdgeInfo (edgeDescriptor eD) {return outEdges[eD].getEdgeInfo(); }
		virtual void setWeight (edgeDescriptor theEdge, baseType w) { outEdges[theEdge].setWeight(w); }
		virtual nodeDescriptor getTarget(edgeDescriptor theEdge) { return   outEdges[theEdge].getTarget(); }
		virtual baseType getWeight (edgeDescriptor theEdge) { return outEdges[theEdge].getWeight(); }
		virtual baseType getTargetState (edgeDescriptor theEdge) { return outEdges[theEdge].getTargetState(); }
		virtual edgeVirtual * getEdge (edgeDescriptor eD);

		virtual node *construct()
		{
			return  new nodeTemplateEdges< EDGE, EDGEVIRTUAL, DYNNODE>( *this );
		};

		// Verbindungen hinzufügen, entfernen
		virtual bool unlink (nodeDescriptor targetNumber);

		virtual void removeEdges () { outEdges.clear(); }

		virtual void link (nodeDescriptor targetNumber, baseType weight);
		virtual void link (nodeDescriptor targetNumber, edgeVirtual *l);
		virtual bool isLinked ( nodeDescriptor target );
		virtual baseType linkStrength ( nodeDescriptor target );
		virtual void normalizeInWeightSum(baseType d);

		virtual void printEdgeStatistics ( ostream &os, int edgeVirtualVerbosity=1);


		// Statistikkram
		//		virtual void printStatistics();
		virtual unsigned int degree() { return outEdges.size();}
		virtual baseType weightSum();
		virtual baseType inWeightSum();
		//			virtual nodeDescriptor getNumber(); // { return ( nodeDescriptor ) number; };

	protected:
		//! so wie couplingSum. Allerdings werden die Zustände zirkulär addier
		baseType getMeanPhaseCoherence();
		baseType couplingSum () ;
		void fire ();


	private:
		//! die Nummer vom Knoten.  theNodes[number] = this!
		int number;


		typedef typename vector<EDGE>::iterator edgeIterator;
		static EDGE privateBluePrint;


};


template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
EDGE nodeTemplateEdges<EDGE, EDGEVIRTUAL, DYNNODE>::standardEdge;



	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
void nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::printEdgeStatistics(ostream &os, int edgeVirtualVerbosity)
{
	os<< "static edges: ";


	for (unsigned int i = 0; i < outEdges.size(); i++)
		outEdges[i].printStatistics(os, edgeVirtualVerbosity );


	os << endl;


}


	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
void nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::fire ()
{
	edgeIterator it, end;
	it =  outEdges.begin();
	end = outEdges.end();
	for ( ;it!=end; it++ )
		dynNode::lookUp(it->getTarget())->excite ( it ->getWeight() );
}

	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
edgeVirtual * nodeTemplateEdges< EDGE,EDGEVIRTUAL, DYNNODE >::getEdge (edgeDescriptor eD)
{
	vector <baseType> parameter;
	outEdges[eD].getParameter(parameter);
	EDGEVIRTUAL *res = new EDGEVIRTUAL();
	res->setParameter(parameter);
	return res;
}

	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
baseType nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::getMeanPhaseCoherence()
{
	complex<baseType> re ( ( baseType ) 0, ( baseType ) 0 );
	//	complex<double> dummy;
	edgeIterator i;
	for ( i = outEdges.begin(); i != outEdges.end(); i++ )
	{
		complex<baseType> dummy ( (baseType)0.0, (baseType) i->getTargetState() );
		re = re + exp ( dummy );

	}
	return abs ( re );
}


	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
baseType nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::inWeightSum ()
{
	baseType res = 0;
	vector<node *>::iterator it;
	
	for (unsigned int i = 0 ; i < DYNNODE::theNodes.size(); i++)
		res+= linkStrength(i);
	
	return res;

}


#ifdef PRECALCULATEWEIGHTSUM
	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
baseType nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::weightSum ()
{
	return preCalculatedWeightSum;
}
#else
	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
baseType nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::weightSum ()
{
	baseType res = 0;
	edgeIterator ei;
	for ( ei =outEdges.begin(); ei != outEdges.end(); ei++ )
		res = res +  ei->getWeight();
	return res;
}
#endif





template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
void nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::normalizeInWeightSum(baseType d)  {

	nodeDescriptor i;
	baseType a;
	vector<nodeDescriptor> presynaptics;

	for (i = 0; i < node::theNodes.size(); i++)
		if ((a = node::theNodes[i]->linkStrength(DYNNODE::getNumber()))) {

			//					inWeightSum += a;
			presynaptics.push_back (i);
		}

	for ( i = 0; i < presynaptics.size();i++)
	{
		node::theNodes[presynaptics[i]]->unlink(DYNNODE::getNumber());
		node::theNodes[presynaptics[i]]-> link (DYNNODE::getNumber(),  d / presynaptics.size());
	}



};





	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
baseType nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::linkStrength ( nodeDescriptor target )
{
	baseType res = 0;
	edgeIterator s;
	for ( s=outEdges.begin(); s != outEdges.end(); s++ )
	{
		if ( s->targetNumber == target )
		{
			res =  s ->getWeight();
			break;
		}
	}
	return res;
}










	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
baseType nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::couplingSum()
{
	baseType re = 0;

	edgeIterator it, end;
	it =  outEdges.begin();
	end = outEdges.end();
	for ( ;it!=end; it++ )
		re = re +  it->getWeight()* it->getTargetState();
	return re;
}



	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
void nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::link (nodeDescriptor targetNumber,  edgeVirtual *l )
{
	vector <baseType> theParameter;
	l->getParameter(theParameter);


	link(targetNumber, 0.0);
	outEdges[outEdges.size() -1].setParameter(theParameter);
}

	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
void nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::link (nodeDescriptor targetNumber, baseType w )
{
	outEdges.push_back ( standardEdge );

	outEdges[outEdges.size() -1].targetNumber = targetNumber;
	outEdges[outEdges.size() -1].setWeight (w);
}


	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
bool nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::unlink ( nodeDescriptor target )
{
	bool res = false;
	edgeIterator s;

	//		outEdges.remove(target);
	for ( s=outEdges.begin(); s != outEdges.end(); s++ )
	{
		if (  s->targetNumber == target )
		{
			res = true;
			//				outEdges.remove(s);
			//				delete *s;
			//		outEdges.erase ( s );

			s->targetNumber = (nodeDescriptor) -1;

			break;
		}
	}
	return res;
}

	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
bool nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::isLinked ( nodeDescriptor target )
{
	bool res = false;
	edgeIterator s;
	for ( s=outEdges.begin(); s != outEdges.end(); s++ )
	{
		if ( s->targetNumber == target )
		{
			res = true;
			break;
		}
	}
	return res;
}


/*	template <typename EDGE, typename EDGEVIRTUAL, typename DYNNODE>
	baseType nodeTemplateEdges<EDGE,EDGEVIRTUAL, DYNNODE>::ninkStrength ( node *target )
	{
	baseType res = 0;
	edgeIterator s;
	for ( s=outEdges.begin(); s != outEdges.end(); s++ )
	{
	if ( s->getTarget()== target )
	{
	res =  s->getWeight();
	break;
	}
	}
	return res;
	}

*/






}




#endif