new implementation of FF Network

src/Genetics/Generation.h

@@ -47,7 +47,7 @@ namespace Genetics
 			double bestFitness()
 			{
 				double f=DBL_MIN;
-				for(const _T &a:individual)
+				for(_T &a:individual)
 					if(f < a.getFitness())
 						f=a.getFitness();
 				return f;
@@ -56,7 +56,7 @@ namespace Genetics
 			double worstFitness()
 			{
 				double f=DBL_MAX;
-				for(const _T &a:individual)
+				for(_T &a:individual)
 					if(f > a.getFitness())
 						f=a.getFitness();
 				return f;
@@ -65,7 +65,7 @@ namespace Genetics
 			double averageFitness()
 			{
 				double f=0;
-				for(const _T &a:individual)
+				for(_T &a:individual)
 						f+=a.getFitness();
 				return f/individual.size();
 			}

src/Genetics/GenerationCreater.h

@@ -9,14 +9,15 @@ namespace Shin
 namespace Genetics
 {
 	template <class _T>
-	class GenerationCreater
+	class GenerationCreator
 	{
 		public:
 			Generation<_T> operator()(Generation<_T> &g) {return generate(g);}
 			virtual Generation<_T> generate(Generation<_T> &gen)=0;
-			virtual ~GenerationCreater() {}
+			virtual ~GenerationCreator() {}
+			void setMaxGenerationSize(const unsigned size) {maxGenerationSize=size;}
 		protected:
-			unsigned maxGenerationSize=150;
+			unsigned maxGenerationSize=100;
 /*			static void run(GenerationCreater* r,unsigned long from, unsigned long to,unsigned long fitness, Generation *gen, Generation *s)
 				{ r->runner(from,to,fitness,gen,s); }
 			virtual void runner(unsigned long from, unsigned long to,unsigned long fitness, Generation *gen, Generation *s)=0;
@@ -24,7 +25,7 @@ namespace Genetics
 	};
 
 	template <class _T>
-	class Roulete: public GenerationCreater<_T>
+	class Roulete: public GenerationCreator<_T>
 	{
 		public:
 			Generation<_T> generate(Generation<_T> &gen) override;
@@ -38,13 +39,13 @@ Shin::Genetics::Generation< _T > Shin::Genetics::Roulete<_T>::generate(Shin::Gen
 {
 	Generation<_T> newGen;
 	long fitness=0;
-	for(const _T &a:gen)
+	for(_T &a:gen)
 	{
 		fitness+=a.fitness();
 	}
-	double avFitness=gen.averageFitness();
+	double avFitness=(gen.bestFitness()+gen.averageFitness())/2;
 
-	for(unsigned int i=0;i<gen.size() && i < this->maxGenerationSize*2/3;i++)
+	for(unsigned int i=0;i<gen.size() && i < this->maxGenerationSize;i++)
 	{
 		if(gen[i].getFitness() >= avFitness)
 		{

src/Genetics/Genetics.h

@@ -29,11 +29,11 @@ namespace Genetics
 	class Genetics
 	{
 		public:
-			Genetics():c(*new _C()),generation(),deleteCreater(1) {}
-			Genetics(GenerationCreater<_T> *gc):c(gc),generation() {}
+			Genetics():c(*new _C()),generation(),deleteCreator(1) {}
+			Genetics(GenerationCreator<_T> *gc):c(gc),generation() {}
 			virtual ~Genetics()
 			{
-				if(deleteCreater)
+				if(deleteCreator)
 					delete &c;
 			}
 			void addIndividual (const _T &ind) { generation.add(ind); }
@@ -60,14 +60,15 @@ namespace Genetics
 			}
 			void makeRound(const int round)
 			{
-				if(round%500==1)
-					srand(time(NULL));
+//				if(round%500==1)
+//					srand(time(NULL));
 				generation=c(generation);
 			}
+			GenerationCreator<_T>& getCreator() {return c;};
 		protected:
-			GenerationCreater<_T> &c;
+			GenerationCreator<_T> &c;
 			Generation<_T> generation;
-			bool deleteCreater=0;
+			bool deleteCreator=0;
 		private:
 	};
 

src/Genetics/Individual.h

@@ -8,11 +8,13 @@ namespace Genetics
 	class Individual
 	{
 		public:
+			virtual ~Individual() {};
 			virtual void mutate()=0;
-			virtual double getFitness() const=0;
-			inline double fitness() const {return getFitness();}
+			virtual double getFitness()=0;
+			virtual double fitness() final {return getFitness();}
 		private:
 	};
 }
 }
+
 #endif // INDIVIDUAL_H

src/NeuronNetwork/FeedForward

@@ -0,0 +1 @@
+./FeedForward.h

src/NeuronNetwork/FeedForward.cpp

@@ -0,0 +1,32 @@
+#include "FeedForward"
+
+using namespace Shin::NeuronNetwork;
+
+FeedForwardNetwork::~FeedForwardNetwork()
+{
+	for(Layer *l:layers)
+	{
+		delete l;
+	}
+}
+
+Solution FeedForwardNetwork::solve(const Problem& p)
+{
+	Solution s=Solution(p);
+	for (Layer *l:layers)
+	{
+		s=l->solve(s);
+	}
+	return s;
+}
+
+const Layer* FeedForwardNetwork::operator[](int layer)
+{
+	return layers[layer];	
+}
+
+void FeedForwardNetwork::addLayer(int neurons)
+{
+	layers.push_back(new Layer(neurons));
+}
+

src/NeuronNetwork/FeedForward.h

@@ -0,0 +1,50 @@
+#ifndef _S_NN_FF_H_
+#define _S_NN_FFs_H_
+
+#include "Problem"
+#include "Solution"
+#include "Neuron"
+#include "Network"
+
+#include <cstdarg>
+#include <vector>
+#include <initializer_list>
+
+#include <iostream>
+namespace Shin
+{
+namespace NeuronNetwork
+{
+
+//	template <typename _NT>
+	class FeedForwardNetwork : public ACyclicNetwork
+	{
+		public:
+			FeedForwardNetwork(const FeedForwardNetwork &f):first(nullptr),last(nullptr),layers()
+			{
+				for(Layer *l:f.layers)
+				{
+					layers.push_back(new Layer(*l));
+					last=layers[layers.size()-1];
+				}
+				first=layers[0];
+			}
+			FeedForwardNetwork operator=(const FeedForwardNetwork &f)=delete;
+			template<typename... Args>inline FeedForwardNetwork(std::initializer_list<int> s):first(nullptr),last(nullptr),layers() { for(const int i:s) {addLayer(i);}}
+			//inline FeedForwardNetwork(std::vector<int> q);
+			~FeedForwardNetwork();
+	
+			virtual Solution solve(const Problem& p)override;
+			unsigned size() {return layers.size();}
+			const Layer* operator[](int layer);
+		protected:
+			void addLayer(int neurons);
+		private:
+			Layer* first;
+			Layer* last ;
+			std::vector<Layer*> layers;
+	};
+
+}
+}
+#endif	

src/NeuronNetwork/FeedForwardQuick

@@ -0,0 +1 @@
+./FeedForwardQuick.h

src/NeuronNetwork/FeedForwardQuick.cpp

@@ -0,0 +1,67 @@
+#include "FeedForwardQuick"
+
+using namespace Shin::NeuronNetwork;
+
+FeedForwardNetworkQuick::~FeedForwardNetworkQuick()
+{
+	if(weights != nullptr)
+	{
+		for(size_t i=0;i<layers;i++)
+		{
+			for (size_t j=0;j<layerSizes[i];j++)
+			{
+				delete[] weights[i][j];
+			}
+			delete[] weights[i];
+			delete[] potentials[i];
+		}
+		delete[] weights;
+		delete[] potentials;
+		delete[] layerSizes;
+	}
+}
+
+Solution FeedForwardNetworkQuick::solve(const Problem& p)
+{
+	std::vector<bool> solution=p;
+	bool* sol=new bool[solution.size()];
+
+	for(size_t i=0;i<solution.size();i++)
+	{
+		sol[i]=solution[i];
+	}
+
+	size_t prevSize=1;
+	for(size_t i=0;i<layers;i++)
+	{
+		bool* newSolution= new bool[layerSizes[i]];
+		for(size_t j=0;j<layerSizes[i];j++)
+		{
+			double q;
+			if(i==0)
+			{
+				q=sol[j]*weights[i][j][0];
+			}else
+			{
+				q=0;
+				for(size_t k=0;k<prevSize;k++)
+				{
+					q+=sol[k]*weights[i][j][k];
+				}
+			}
+			newSolution[j]=q >= potentials[i][j]?1:0;
+		}
+
+		prevSize=layerSizes[i];
+		delete[] sol;
+		sol=newSolution;
+	}
+
+	std::vector<bool> ret;
+	for(size_t i=0;i<prevSize;i++)
+	{
+		ret.push_back(sol[i]);
+	}
+	delete[] sol;
+	return ret;
+}

src/NeuronNetwork/FeedForwardQuick.h

@@ -0,0 +1,95 @@
+#ifndef _S_NN_FF_H_
+#define _S_NN_FFs_H_
+
+#include "Problem"
+#include "Solution"
+#include "Neuron"
+#include "Network"
+
+#include <cstdarg>
+#include <vector>
+#include <initializer_list>
+
+#include <iostream>
+namespace Shin
+{
+namespace NeuronNetwork
+{
+	class FFNeuron : public Neuron
+	{
+		public:
+			FFNeuron() = delete;
+			FFNeuron(const FFNeuron&) = delete;
+			FFNeuron& operator=(const FFNeuron&) = delete;
+			FFNeuron(double *pot, double *w):potential(pot),weights(w) { }
+
+			double getPotential() {return *potential;}
+			void setPotential(double p) { std::cout <<"S"; *potential=p;}
+			double getWeight(unsigned int i ) { return weights[i];}
+			void setWeight(unsigned int i,double p) { weights[i]=p; }
+		protected:
+			double *potential;
+			double *weights;
+		private:
+	};
+
+	class FFLayer//: public Layer
+	{
+		public:
+			FFLayer(size_t s, double *p,double **w): layerSize(s),potentials(p),weights(w) {}
+			FFNeuron* operator[](int neuron) const { return new FFNeuron(&potentials[neuron],weights[neuron]); };
+			int size() const {return layerSize;};
+		protected:
+			size_t layerSize;
+			double *potentials;
+			double **weights;
+	};
+
+	class FeedForwardNetworkQuick:public ACyclicNetwork
+	{
+		public:
+			FeedForwardNetworkQuick(const FeedForwardNetworkQuick &f) = delete; //TODO
+			FeedForwardNetworkQuick operator=(const FeedForwardNetworkQuick &f)=delete;
+			template<typename... Args>inline FeedForwardNetworkQuick(std::initializer_list<int> s):weights(nullptr),potentials(nullptr),layerSizes(nullptr),layers(s.size())
+			{
+				weights= new double**[s.size()];
+				potentials= new double*[s.size()];
+				layerSizes= new size_t[s.size()];
+				int i=0;
+				int prev_size=1;
+				for(int layeSize:s) // TODO rename
+				{
+					if(i==0) 
+						prev_size=layeSize;
+
+					layerSizes[i]=layeSize;
+					weights[i]= new double*[layeSize];
+					potentials[i]= new double[layeSize];
+					for (int j=0;j<layeSize;j++)
+					{
+						potentials[i][j]=1;
+						weights[i][j]= new double[prev_size];
+						for(int k=0;k<prev_size;k++)
+						{
+							weights[i][j][k]=1;
+						}
+					}
+					i++;
+					prev_size=layeSize;
+				}
+			}
+			~FeedForwardNetworkQuick();
+			virtual Solution solve(const Problem& p) override;
+			unsigned size() { return layers;}
+			FFLayer* operator[](int l) { return new FFLayer(layerSizes[l],potentials[l],weights[l]); }
+		protected:
+		private:
+			double ***weights;
+			double **potentials;
+			size_t *layerSizes;
+			size_t layers;
+	};
+
+}
+}
+#endif	

src/NeuronNetwork/Makefile

@@ -1,4 +1,4 @@
-OBJFILES=./Solution.o ./Problem.o ./Network.o ./Neuron.o
+OBJFILES=./Solution.o ./Problem.o ./Network.o ./Neuron.o ./FeedForward.o ./FeedForwardQuick.o
 
 LIBNAME=NeuronNetwork
 

src/NeuronNetwork/Network.cpp

@@ -2,39 +2,6 @@
 
 using namespace Shin::NeuronNetwork;
 
-FeedForwardNetwork::~FeedForwardNetwork()
-{
-	for(Layer *l:layers)
-	{
-		delete l;
-	}
-}
-
-Solution FeedForwardNetwork::solve(const Problem& p)
-{
-	Solution s=Solution(p);
-	for (Layer *l:layers)
-	{
-		s=l->solve(s);
-	}
-	return s;
-}
-
-void FeedForwardNetwork::learn(const Problem & problem, const Solution &actual)
-{
-	//S::Solution s= solve(p);
-}
-
-const Layer* FeedForwardNetwork::operator[](int layer)
-{
-	return layers[layer];	
-}
-
-void FeedForwardNetwork::addLayer(int neurons)
-{
-	layers.push_back(new Layer(neurons));
-}
-
 Layer::Layer(int a):neurons()
 {
 	while(a--)

src/NeuronNetwork/Network.h

@@ -7,7 +7,9 @@
 
 #include <cstdarg>
 #include <vector>
+#include <initializer_list>
 
+#include <iostream>
 namespace Shin
 {
 namespace NeuronNetwork
@@ -15,8 +17,8 @@ namespace NeuronNetwork
 	class Network
 	{
 		public:
+			virtual ~Network() {};
 			virtual Solution solve(const Problem&)=0;
-			virtual void learn(const Problem & p, const Solution &s)=0;
 		protected:
 		private:
 	};
@@ -32,6 +34,13 @@ namespace NeuronNetwork
 	{
 		public:
 			Layer(int a);
+			Layer(const Layer &l):neurons()
+			{
+				for(unsigned i=0;i<l.neurons.size();i++)
+				{
+					neurons.push_back(new Neuron(*l.neurons[i]));
+				}
+			}
 			~Layer();
 			Solution solve(const std::vector<bool> &input);
 			Neuron* operator[](int neuron) const;
@@ -40,25 +49,6 @@ namespace NeuronNetwork
 			std::vector<Neuron*> neurons;
 	};
 
-//	template <typename _NT>
-	class FeedForwardNetwork : public ACyclicNetwork
-	{
-		public:
-			 template<typename... Args>inline FeedForwardNetwork(Args &&... args) {pass((addLayer(args),1)...);};
-			 //inline FeedForwardNetwork(std::vector<int> q);
-			~FeedForwardNetwork();
-	
-			virtual Solution solve(const Problem& p) override;
-			virtual void learn(const Problem & p, const Solution &s) override;
-			const Layer* operator[](int layer);
-		protected:
-			template<typename... Args> inline void pass(Args&&...) {};
-			void addLayer(int neurons);
-		private:
-			Layer* first;
-			Layer* last ;
-			std::vector<Layer*> layers;
-	};
 
 }
 }

src/NeuronNetwork/Neuron.h

@@ -11,6 +11,10 @@ namespace NeuronNetwork
 	{
 		public:
 			Neuron();
+			Neuron(const Neuron &n):potential(n.potential),weights(n.weights)
+			{
+				
+			}
 			double getPotential() const;
 			void setPotential(double p);
 			double getWeight(unsigned int) const;

src/NeuronNetwork/Problem.h

@@ -11,6 +11,7 @@ namespace NeuronNetwork
 	{
 		public:
 			Problem();
+			virtual ~Problem(){};
 			operator std::vector<bool>() const;
 		protected:
 			virtual std::vector<bool> representation() const =0;

src/NeuronNetwork/Solution.cpp

@@ -2,7 +2,7 @@
 
 using namespace Shin::NeuronNetwork;
 
-Solution::Solution(std::vector<bool>solution):solution(solution)
+Solution::Solution(std::vector<bool>sol):solution(sol)
 {
 
 }