#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\" }";
			}

	};
}
}