reffactored and recurrent implementation

include/NeuralNetwork/Recurrent/Network.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "../Network.h"
+#include "Neuron.h"
+
+#include <vector>
+
+#include <sstream>
+#include <iomanip>
+#include <limits>
+
+namespace NeuralNetwork {
+namespace Recurrent {
+
+	/**
+	* @author Tomas Cernik (Tom.Cernik@gmail.com)
+	* @brief Reccurent model of Artifical neural network
+	*/
+	class Network: public NeuralNetwork::Network {
+		public:
+
+			/**
+			 * @brief Constructor for Network
+			 * @param _inputSize is number of inputs to network
+			 * @param _outputSize is size of output from network
+			 * @param hiddenUnits is number of hiddenUnits to be created
+			 */
+			inline Network(size_t _inputSize, size_t _outputSize,size_t hiddenUnits=0):NeuralNetwork::Network(),inputSize(_inputSize),outputSize(_outputSize), neurons(0) {
+				for(size_t i=0;i<_inputSize+_outputSize;i++) {
+					addNeuron();
+				}
+
+				for(size_t i=0;i<hiddenUnits;i++) {
+					addNeuron();
+				}
+			};
+
+			// todo: implement
+			inline Network(const std::string &json) {
+				
+			}
+			/**
+			 * @brief Virtual destructor for Network
+			 */
+			virtual ~Network() {};
+
+			/**
+			 * @brief  This is a function to compute one iterations of network
+			 * @param input is input of network
+			 * @returns output of network
+			 */
+			inline virtual std::vector<float> computeOutput(const std::vector<float>& input) override {
+				return computeOutput(input,1);
+			}
+
+			/**
+			 * @brief  This is a function to compute iterations of network
+			 * @param input is input of network
+			 * @param iterations is number of iterations
+			 * @returns output of network
+			 */
+			std::vector<float> computeOutput(const std::vector<float>& input, unsigned int iterations);
+
+			std::vector<Neuron>& getNeurons () {
+				return neurons;
+			}
+
+			using NeuralNetwork::Network::stringify;
+
+			void stringify(std::ostream& out) const override;
+
+			Neuron& addNeuron() {
+				neurons.push_back(Recurrent::Neuron(neurons.size()));
+				Neuron &newNeuron=neurons.back();
+				for(size_t i=0;i<neurons.size();i++) {
+					neurons[i].setWeight(newNeuron,0.0);
+				}
+				return newNeuron;
+			}
+
+		protected:
+			size_t inputSize=0;
+			size_t outputSize=0;
+
+			std::vector<Recurrent::Neuron> neurons;
+	};
+}
+}

include/NeuralNetwork/Recurrent/Neuron.h

@@ -0,0 +1,123 @@
+#pragma once
+
+#include "../Neuron.h"
+#include <NeuralNetwork/ActivationFunction/Sigmoid.h>
+#include <NeuralNetwork/BasisFunction/Linear.h>
+#include <vector>
+
+
+#include <sstream>
+#include <iomanip>
+#include <limits>
+
+namespace NeuralNetwork {
+namespace Recurrent {
+
+	class Network;
+
+	/**
+	 * @author Tomas Cernik (Tom.Cernik@gmail.com)
+	 * @brief Class of recurrent neuron.
+	 */
+	class Neuron : public NeuralNetwork::Neuron
+	{
+		public:
+			Neuron(unsigned long _id=0,const float& _bias = 0): NeuralNetwork::Neuron(), basis(new BasisFunction::Linear),
+																activation(new ActivationFunction::Sigmoid(-4.9)),
+																id_(_id),bias(_bias),weights(_id+1),_output(0),_value(0) {
+			}
+
+			Neuron(const Neuron &r): NeuralNetwork::Neuron(), basis(r.basis->clone()), activation(r.activation->clone()),id_(r.id_),
+									 bias(r.bias), weights(r.weights), _output(r._output), _value(r._value) {
+			}
+			virtual ~Neuron() {
+				delete basis;
+				delete activation;
+			};
+
+			virtual std::string stringify(const std::string &prefix="") const override;
+
+			Recurrent::Neuron& operator=(const NeuralNetwork::Recurrent::Neuron&r) {
+				id_=r.id_;
+				bias=r.bias;
+				weights=r.weights;
+				basis=r.basis->clone();
+				activation=r.activation->clone();
+				return *this;
+			}
+
+			virtual long unsigned int id() const override {
+				return id_;
+			};
+
+			/**
+			 * @brief Gets weight
+			 * @param n is neuron
+			 */
+			virtual float getWeight(const NeuralNetwork::Neuron &n) const override {
+				return weights[n.id()];
+			}
+
+			/**
+			 * @brief Sets weight
+			 * @param n is neuron
+			 * @param w is new weight for input neuron n
+			 */
+			virtual void setWeight(const NeuralNetwork::Neuron& n ,const float &w) override {
+				if(weights.size()<n.id()+1) {
+					weights.resize(n.id()+1);
+				}
+				weights[n.id()]=w;
+			}
+
+			/**
+			 * @brief Returns output of neuron
+			 */
+			virtual float output() const override {
+				return _output;
+			}
+
+			/**
+			 * @brief Returns input of neuron
+			 */
+			virtual float value() const override {
+				return _value;
+			}
+
+			/**
+			 * @brief Function sets bias for neuron
+			 * @param _bias is new bias (initial value for neuron)
+			 */
+			virtual void setBias(const float &_bias) override {
+				bias=_bias;
+			}
+
+			/**
+			 * @brief Function returns bias for neuron
+			 */
+			virtual float getBias() const override {
+				return bias;
+			}
+
+			float operator()(const std::vector<float>& inputs) {
+				//compute value
+				_value=basis->operator()(weights,inputs)+bias;
+
+				//compute output
+				_output=activation->operator()(_value);
+
+				return _output;
+			}
+
+		protected:
+			BasisFunction::BasisFunction *basis;
+			ActivationFunction::ActivationFunction *activation;
+
+			unsigned long id_;
+			float bias;
+			std::vector<float> weights;
+			float _output;
+			float _value;
+	};
+}
+}