// Ann.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
# include <cmath>
#include <math.h>
#include <vector>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
using namespace std;
//Generating random number: either 0 or 1, uniform distribution, for XOR operation. Can remove later if using data from files.
int randint();
struct Sample
{
	double input[2];
	double output[2];
	string ToString() {
		string str;
		str = "input: " + to_string(input[0]) + " " + to_string(input[1]) + " output: " + to_string(output[0]) + " " + to_string(output[1])+"\n";
		return str;
	}
};

class Data
{
public:
	int getNumberOfInputs() { return inputs; }
	int getNumberOfOutputs() { return outputs; }

	double *getInput(int index)
	{
		double *input = data[index].input;
		return input;
	}

	double *getOutput(int index)
	{
		double *output = data[index].output;
		return output;
	}

	int getNumberOfSamples() { return samples; }

	void addSample(Sample sample)
	{
		data.push_back(sample);
		samples++;
		//cout << sample.ToString();
	}

	void setSizes(int input_size, int output_size)
	{
		inputs = input_size;
		outputs = output_size;
	}

protected:
	std::vector<Sample> data;
	int inputs;
	int outputs;
	int samples = 0;
};

class XOR : public Data
{
public:
	void generate(int n)
	{
		for (int i = 0; i < n; i++)
		{
			double input1 = randint();
			double input2 = randint();
			double output1 = input1 == input2;
			double output2 = input1 != input2;
			addSample({ { input1, input2 },{ output1, output2 } });
		}
	}

	XOR()
	{
		inputs = 2;
		outputs = 2;
		samples = 0;
	}
	void printInputs(int index)
	{
		cout << index << " index inputs: " << endl;
		for (int i = 0; i < inputs; i++)
		{
			cout << getInput(index)[i] << " ";
		}
		cout << endl;
	}

	void printOutputs(int index)
	{
		cout << index << " index outputs: " << endl;
		for (int i = 0; i < outputs; i++)
		{
			cout << fixed << setprecision(2) << data[index].output[i] << " ";
		}
		cout << endl;
	}
};

struct Topology
{
	int L;//sluoksniu sk
	std::vector<int> l;//kiekiai sluoksnyje
} topolygy;

int kiek = 0;//for statistics - ignore
double f(double x);
double f_deriv(double x);
double gL(double a, double z, double t);
double gl(int layer_id, int w_i, int w_j, double *a_arr, double *z_arr, double *t_arr, double *w_arr, int *s,int *sw, int L, int *l);
double w_gradient(int layer_id, int w_i, int w_j, double *a_arr, double *z_arr, double *t_arr, double *w_arr,int *s, int *sw, int L, int *l);
double delta_w(double grad, double dw);

const double ETA = 0.1;
const double ALPHA = 0.5;

class AnnBase {
public:
	virtual void prepare(Topology top) = 0;
	virtual void init(Topology top, double w_arr_1[]) = 0;
	virtual void train(double *a, double *b) = 0;
	virtual void feedForward(double *a, double *b) = 0;//a and b temp vars for now.
	virtual void destroy() = 0;
};

class AnnSerialDBL : public AnnBase {
public:
	void prepare(Topology top);
	void init(Topology top, double w_arr_1[]);
	void train(double *a, double *b);
	void feedForward(double *a,double *b);
	void destroy();
public:
	int sum1;//temp var to keep the length of z, so z could be reset for calcs. Can adapt code later, so this could be removed
	int L;
	int * l;
	int * s;
	double * a_arr;
	double * z_arr;
	int * W;
	int * sw;
	double * w_arr;
	double * dw_arr;
	double * t_arr;
};
int main()
{
	topolygy.L = 5;
	topolygy.l.push_back(2);
	topolygy.l.push_back(5);
	topolygy.l.push_back(6);
	topolygy.l.push_back(7);
	topolygy.l.push_back(2);
	AnnSerialDBL labas;
	labas.prepare(topolygy);
	labas.init(topolygy, NULL);


	//****temp
	int sum = 0;
	for (int i = 0; i < labas.L; i++) {
		sum += topolygy.l.at(i) + 1;
	}
	//temp***


	XOR xo;
	xo.generate(60000);
	for (int i = 0; i < xo.getNumberOfSamples(); i++) {
		labas.train(xo.getInput(i), xo.getOutput(i));
	}


	//****temp
	for (int i = 0; i < sum; i++) {
	//	cout << labas.a_arr[i] << endl;
	}
	//******temp


	//Checking results(all combinations 0 and 1)
	for (double i = 0; i < 2;i++){
		for (double j = 0; j < 2; j++) {
			double input[] = {i ,j };
			double output[] = { 0,0 };
			labas.feedForward(input, output);

			cout << endl << "input : " << input[0] << "   " << input[1] << endl;
			cout << endl << "output: " << output[0] << "   " << output[1] << endl<<endl;
			cout << "---------------------------------------------------" << endl;
		}
	}

	//Checking results(all combinations 0 and 1)
	for (double i = 0; i < 1; i++) {
		double input[] = { randint()*1.0, randint()*1.0 };
		double output[] = { 0,0 };
		labas.feedForward(input, output);

		cout << endl << "input : " << input[0] << "   " << input[1] << endl;
		cout << endl << "output: " << output[0] << "   " << output[1] << endl << endl;
		cout << "---------------------------------------------------" << endl;
	}

	labas.destroy();

	int a;
	cout << kiek;
	cin >> a;

	return 0;
}

//returns random int, either 0 or 1
int randint() {
	double r = ((double)rand() / (RAND_MAX));
	int a = 0;
	if (r > 0.5) {
		a = 1;
	}
	else
	{
		a = 0;
	}
	return a;
}

void AnnSerialDBL::prepare(Topology top)
{
	l = new int[top.L];
	s = new int[top.L];

	int sum = 0;
	int mult = 0;
	for (int i = 0; i < top.L; i++) {
		sum += top.l.at(i) + 1;
	}
	sum1 = sum;
	for (int i = 0; i < top.L - 1; i++) {
		mult += (top.l.at(i) + 1)*top.l.at(i+1);
	}
	a_arr = new double[sum];
	z_arr = new double[sum];

	W = new int[top.L];
	sw = new int[top.L];

	w_arr = new double[mult];
	dw_arr = new double[mult];

	t_arr = new double[top.l.at(top.L - 1)];
}

void AnnSerialDBL::init(Topology top, double w_arr_1[] = NULL)
{
	L = top.L;
	//Neuronu kiekiai sluoksnyje
	for (int i = 0; i < top.L; i++) {
		l[i] = top.l.at(i) + 1;
	}

	//Sluoksniu pradzios indeksai
	for (int i = 0; i < top.L; i++) {
		s[i] = 0;
		for (int j = i; j > 0; j--) {
			s[i] += l[j - 1];
		}
	}

	//Bias neuronai
	for (int i = 0; i < top.L - 1; i++) {
		a_arr[s[i + 1] - 1] = 1;
	}

	//Svoriu kiekiai l-ame sluoksnyje
	for (int i = 0; i < top.L - 1; i++) {
		W[i] = l[i] * (l[i + 1] - 1);
		//cout << "Svoriu sk: " << W[i] << " Pradzios index: ";
		sw[i] = 0;
		if (i != 0) {
			for (int j = 0; j < i; j++) {
				sw[i] += W[j];
			}
		}
		if (w_arr_1 == NULL) {
			for (int j = 0; j < W[i]; j++) {
				w_arr[sw[i] + j] = (double)rand() / double(RAND_MAX);
				//cout << w_arr[sw[i] + j]<< endl;
				dw_arr[sw[i] + j] = 0;
			}
		}
		else {
			w_arr = w_arr_1; //ar reikia pokycius issisaugoti irgi?
		}

		//cout << sw[i] << " " << endl;
	}
}

void AnnSerialDBL::train(double *a,double *b)
{
	a_arr[0] = a[0];
	a_arr[1] = a[1];

	for (int j = 0; j < sum1; j++) {
		z_arr[j] = 0;
	}

	//FFEEED FORWARD
	for (int i = 0; i < L - 1; i++) {//per sluoksnius einu+
		for (int j = 0; j < l[i]; j++) { //kiek neuronu sluoksnyje+
			for (int k = 0; k < l[i + 1] - 1; k++) {//per sekancio sluoksnio z+
				z_arr[s[i + 1] + k] += w_arr[sw[i] + k + j*(l[i + 1] - 1)] * a_arr[s[i] + j];
				//cout << " w: "<< w_arr[sw[i] + k + j*(l[i + 1]-1)] << endl;
				//cout << "a: " << a_arr[s[i] + j] << endl;
				//cout << "z reiksmes: " << z_arr[s[i+1] + k] << endl;
				//cout << endl;
				kiek++;//temp
			}
		}
		for (int k = 0; k < l[i + 1] - 1; k++) {//per sekancio sluoksnio z
			a_arr[s[i + 1] + k] = f(z_arr[s[i + 1] + k]);
		//	cout << s[i + 1] + k << " a reiksmes: " << a_arr[s[i + 1] + k] << endl;
		}
	}

	t_arr[0] = b[0];
	t_arr[1] = b[1];

	//back propogation:
	for (int i = L-2; i >=0; i--) {//per sluoksnius
		for (int j = 0; j < l[i]; j++) {//per neuronus
			for (int k = 0; k < l[i + 1] - 1; k++) {//per kito sluoksnio neuronus
				dw_arr[sw[i] + k+j*(l[i + 1] - 1)] = delta_w(w_gradient(i, j, k, a_arr, z_arr, t_arr, w_arr, s,sw, L, l), dw_arr[sw[i] + k+ j*(l[i + 1] - 1)]);
				w_arr[sw[i] + k+ j*(l[i + 1] - 1)] += dw_arr[sw[i] + k+ j*(l[i + 1] - 1)];
			//	cout << w_arr[sw[i] + k] << " " << endl;
			}
		}
	}

}

void AnnSerialDBL::feedForward(double *a, double *b)
{
	a_arr[0] = a[0];
	a_arr[1] = a[1];

	for (int j = 0; j < sum1; j++) {
		z_arr[j] = 0;
	}
	//FFEEED FORWARD
	for (int i = 0; i < L - 1; i++) {//per sluoksnius einu+
		for (int j = 0; j < l[i]; j++) { //kiek neuronu sluoksnyje+
			for (int k = 0; k < l[i + 1] - 1; k++) {//per sekancio sluoksnio z+
				z_arr[s[i + 1] + k] += w_arr[sw[i] + k + j*(l[i + 1] - 1)] * a_arr[s[i] + j];
			//	cout << "w: "<< w_arr[sw[i] + k + j*(l[i + 1] - 1)] << endl;
			//	cout << "a: " << a_arr[s[i] + j] << endl;
			//	cout << "z reiksmes: " << z_arr[s[i+1] + k] << endl;
			//	cout << endl;
			}
		}
		for (int k = 0; k < l[i + 1] - 1; k++) {//per sekancio sluoksnio z
			a_arr[s[i + 1] + k] = f(z_arr[s[i + 1] + k]);
		//	cout << s[i + 1] + k << " a reiksmes: " << a_arr[s[i + 1] + k] << endl;
		}
	}

	//cout << a_arr[s[L - 1]];
	//cout << a_arr[s[L - 1]+1];
	if (a_arr[s[L - 1]] > a_arr[s[L - 1] + 1]) {
		b[0] = 1;
		b[1] = 0;
	}
	else {
		b[0] = 0;
		b[1] = 1;
	}
}

void AnnSerialDBL::destroy()
{
	delete l;
	l = NULL;
	delete s;
	s = NULL;

	delete a_arr;
	a_arr = NULL;
	delete z_arr;
	z_arr = NULL;

	delete W;
	W = NULL;
	delete sw;
	sw = NULL;

	delete w_arr;
	w_arr = NULL;
	delete dw_arr;
	dw_arr = NULL;

	delete t_arr;
	t_arr = NULL;
}

double f(double x) {
	double y = 1+exp(-x);
	//temp*********************
	if (y == 0) {
		cout << "Error 1";
	}
		if ((y-1) == 0) {
			//cout << "Error 2";
		}
	//temp**********************
	return 1 / y;
}


double f_deriv(double x) {
	//Temp**********
	double y = pow((1 + exp(-x)), 2);
	double z = exp(-x);
	if (y == 0) {
		cout << "Error 3";
	}
	if (z == 0) {
		cout << "Error 4";
	}
	//temp**********************
	return exp(-x) / pow((1 + exp(-x)), 2);
}

double gL(double a, double z, double t) {
	double w = f_deriv(z) * (a - t);
	//cout << "z: " << z << " a: " << a << " t: " << t << endl;
	return w;
}

double gl(int layer_id, int w_i, int w_j, double *a_arr, double *z_arr, double *t_arr, double *w_arr, int *s,int *sw, int L, int *l) {
	double w = f_deriv(z_arr[s[layer_id] + w_j]);
	double sum = 0;
	for (int i = 0; i < l[layer_id + 1] - 1; i++) {
		if (layer_id + 2 == L) {
			sum += w_arr[sw[layer_id] + i] * gL(a_arr[s[layer_id + 1] + i], z_arr[s[layer_id + 1]+ i], t_arr[i]);
		}
		else {
			sum += w_arr[sw[layer_id] + w_j] * gl(layer_id + 1, w_i, i, a_arr, z_arr, t_arr,w_arr, s, sw, L, l);
		}
	}
	return w*sum;
}

double w_gradient(int layer_id, int w_i, int w_j, double *a_arr, double *z_arr, double *t_arr, double *w_arr,int *s, int *sw, int L, int *l) {
	double w = a_arr[s[layer_id] + w_i];
	if (layer_id + 2 == L) {
		w *= gL(a_arr[s[layer_id + 1] + w_j], z_arr[s[layer_id + 1] + w_j], t_arr[w_j]);
	}
	else {
		w *= gl(layer_id + 1, w_i, w_j, a_arr, z_arr, t_arr, w_arr, s, sw, L, l);
	}
	//cout << L << endl;
	//cout << w << " layer id:"<< layer_id <<endl;
	return w;
}

double delta_w(double grad, double dw) {
	return (-ETA)*grad + ALPHA*dw;
}