reffactored and recurrent implementation

include/NeuralNetwork/BasisFunction/BasisFunction.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <math.h>
+#include <vector>
+
+#include <string>
+
+namespace NeuralNetwork {
+namespace BasisFunction {
+	class BasisFunction {
+		public:
+			virtual ~BasisFunction() {}
+			virtual float operator()(const std::vector<float>& weights, const std::vector<float>& input)=0;
+
+			/**
+			 * @brief Function returns clone of object
+			 */
+			virtual BasisFunction* clone() const = 0;
+
+			/**
+			 * @brief This is a virtual function for storing Basis function
+			 * @returns json describing function
+			 */
+			virtual std::string stringify() const =0;
+	};
+}
+}

include/NeuralNetwork/BasisFunction/Linear.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <mmintrin.h>
+#include <xmmintrin.h>
+#include <emmintrin.h>
+#include <xmmintrin.h>
+#include <pmmintrin.h>
+
+#include "./StreamingBasisFunction.h"
+
+#include "../../sse_mathfun.h"
+
+namespace NeuralNetwork {
+namespace BasisFunction {
+
+	class Linear: public StreamingBasisFunction {
+		public:
+			Linear() {}
+
+			inline virtual float computeStreaming(const std::vector<float>& weights, const std::vector<float>& input) override {
+				size_t inputSize=input.size();
+				size_t alignedPrev=inputSize-inputSize%4;
+
+				const float* weightsData=weights.data();
+				const float* inputData=input.data();
+				vec4f partialSolution;
+				partialSolution.sse =_mm_setzero_ps();
+
+				//TODO prefetch ??
+				for(register size_t k=0;k<alignedPrev;k+=4) {
+					partialSolution.sse=_mm_add_ps(partialSolution.sse,_mm_mul_ps(_mm_load_ps(weightsData+k),_mm_load_ps(inputData+k)));
+				}
+
+				for(register size_t k=alignedPrev;k<inputSize;k++) {
+					partialSolution.sse=_mm_add_ps(partialSolution.sse,_mm_mul_ps(_mm_load_ss(weightsData+k),_mm_load_ss(inputData+k)));
+				}
+
+#ifdef USE_SSE2 //pre-SSE3 solution
+				partialSolution.sse= _mm_add_ps(_mm_movehl_ps(partialSolution.sse, partialSolution.sse), partialSolution.sse);
+				partialSolution.sse=_mm_add_ss(partialSolution.sse, _mm_shuffle_ps(partialSolution.sse,partialSolution.sse, 1));
+#else
+				partialSolution.sse = _mm_hadd_ps(partialSolution.sse, partialSolution.sse);
+				partialSolution.sse = _mm_hadd_ps(partialSolution.sse, partialSolution.sse);
+#endif
+
+				return partialSolution.f[0];
+			}
+
+			inline virtual float compute(const std::vector<float>& weights, const std::vector<float>& input) override {
+				register float tmp = 0;
+				size_t inputSize=input.size();
+				for(size_t k=0;k<inputSize;k++) {
+					tmp+=input[k]*weights[k];
+				}
+				return tmp;
+			}
+
+			virtual BasisFunction* clone() const override {
+				return new Linear();
+			}
+
+			virtual std::string stringify() const override {
+				return "{ \"class\": \"NeuralNetwork::BasisFunction::Linear\" }";
+			}
+
+	};
+}
+}

include/NeuralNetwork/BasisFunction/Radial.h

@@ -0,0 +1,25 @@
+#ifndef __BASIS_RADIAL_H_
+#define  __BASIS_RADIAL_H_
+
+#include "./BasisFunction.h"
+
+namespace NeuralNetwork
+{
+namespace BasisFunction
+{
+	class Radial: public BasisFunction
+	{
+		public:
+			Radial() {}
+
+			virtual BasisFunction* clone() const override {
+				return new Radial();
+			}
+
+			virtual std::string stringify() const override {
+				return "{ \"class\": \"NeuralNetwork::BasisFunction::Radial\" }";
+			}
+	};
+}
+}
+#endif

include/NeuralNetwork/BasisFunction/StreamingBasisFunction.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <xmmintrin.h>
+
+#include "./BasisFunction.h"
+
+namespace NeuralNetwork {
+namespace BasisFunction {
+	class StreamingBasisFunction : public BasisFunction {
+		public:
+			union vec4f{
+				__m128 sse;
+				float f[4];
+			};
+
+			virtual float operator()(const std::vector<float>& weights, const std::vector<float>& input) override {
+				return computeStreaming(weights,input);
+			}
+			virtual float computeStreaming(const std::vector<float>& weights, const std::vector<float>& input) =0;
+			virtual float compute(const std::vector<float>& weights, const std::vector<float>& input) =0;
+	};
+}
+}