#include <cstdlib>
#include <iostream>
#include <string>
#include <sstream>
#include <stack>
#include <queue>
#include <iostream>
#include <fstream>
#include <ctime>
#include <iomanip>
#include <Windows.h>
#include <cmath>
#define E 2.71828182845904523536

using namespace std;


int liczbaIteracji = 1500;
const int liczbaNeuronow = 20;
const int liczbaWejsc = 5;
const int liczbaWzorcow = 10;
double wspolczynnikUczeniaWarstwyWejsciowej = 0.0001;
double wspolczynnikUczeniaWarstwyUkrytej = 0.01;
double blad = 0.0;
double bladSieci = 0.0;
int numerWzorca = 0;
double wagiWarstwyUkrytej[liczbaNeuronow];
float wagiWarstwyWejsciowej[liczbaWejsc][liczbaNeuronow];
float wartosciWarstwyUkrytej[liczbaNeuronow];
double wynikSieci;
int wzorceWejsciowe[liczbaWzorcow];
double wzorceWyjsciowe[liczbaWzorcow];

void losowanko();
void uczSiec(int &numerWzorca, double &bladSieci);
void wyswietlWyniki(int &numerWzorca);
void oblicz();
double obliczWyjscie(double lacznePobudzenieNeuronu);
void korygujWagiWarstwyUkrytej();
void korygujWagiWarstwyWejsciowej();
double obliczPochodna(double wartoscWarstwyUkrytej);
void obliczBladSieci(double &bladsieci);

int main() {

	srand(time(0));
	losowanko();
	uczSiec(numerWzorca, bladSieci);
	wyswietlWyniki(numerWzorca);
    system("pause");
}

void losowanko() {

	for (int i = 0; i < liczbaNeuronow; i++)
	{
	    float losowa = (-100+(rand()%300));
		wagiWarstwyUkrytej[i] = losowa/1000 ;

		for (int j = 0; j < liczbaNeuronow; j++)
		{
		    losowa = (-125 + (rand() % 500)) ;

			wagiWarstwyWejsciowej[j][i] = losowa/1000;

		}
	}

	for (int i = 0; i < liczbaWzorcow; i++)
	{
		wzorceWejsciowe[i] = 1+(rand()%100);
		wzorceWyjsciowe[i] = sqrt(wzorceWejsciowe[i]);
	}
}

void uczSiec(int &numerWzorca, double &bladSieci) {

	ofstream bledy;
	bledy.open("bledy.txt", ios::out);

	for (int i = 0; i < liczbaIteracji; i++) {
		for (int j = 0; j < liczbaWzorcow; j++) {
			numerWzorca = j;
			oblicz();
			korygujWagiWarstwyUkrytej();
			korygujWagiWarstwyWejsciowej();
		}
		obliczBladSieci(bladSieci);
		bledy << "Blad przy " << i << " iteracji wynosi: " << bladSieci <<endl;
	}
	bledy.close();

}

void wyswietlWyniki(int &numerWzorca) {
	for (int i = 0; i < liczbaWzorcow; i++)
	{
		numerWzorca = i;
		oblicz();
		double roznica = wzorceWyjsciowe[numerWzorca] - wynikSieci;
		cout << fixed;
		cout << "Wejscie " << i << " wynosi: " << setprecision(10) << roznica << endl;

	}
}

void oblicz() {

	for (int i = 0; i < liczbaNeuronow; i++) {
		wartosciWarstwyUkrytej[i] = 0.0;
		for (int j = 0; j < liczbaWejsc; j++) {
			wartosciWarstwyUkrytej[i] += wagiWarstwyWejsciowej[j][i] * wzorceWejsciowe[numerWzorca];
		}
		wartosciWarstwyUkrytej[i] = obliczWyjscie(wartosciWarstwyUkrytej[i]);
	}

	wynikSieci = 0.0;

	for (int i = 0; i < liczbaNeuronow; i++) {
		wynikSieci += wagiWarstwyUkrytej[i] * wartosciWarstwyUkrytej[i];
	}
	blad = wynikSieci - wzorceWyjsciowe[numerWzorca];
}

double obliczWyjscie(double lacznePobudzenieNeuronu) {
	return (1 / (pow(E, lacznePobudzenieNeuronu)));
}

void korygujWagiWarstwyUkrytej() {
	for (int i = 0; i < liczbaNeuronow; i++) {
		wagiWarstwyUkrytej[i] = wagiWarstwyUkrytej[i] - blad*wartosciWarstwyUkrytej[i] * wspolczynnikUczeniaWarstwyUkrytej;
	}
}

void korygujWagiWarstwyWejsciowej()
{
	for (int i = 0; i<liczbaNeuronow; i++) {
		for (int j = 0; j<liczbaWejsc; j++) {
			wagiWarstwyWejsciowej[j][i] = wagiWarstwyWejsciowej[j][i] - blad*obliczPochodna(wartosciWarstwyUkrytej[i])*wagiWarstwyUkrytej[i] * wspolczynnikUczeniaWarstwyWejsciowej*wzorceWejsciowe[numerWzorca];
		}
	}
}

double obliczPochodna(double wartoscWarstwyUkrytej) {
	return (1 - wartoscWarstwyUkrytej)*wartoscWarstwyUkrytej;
}

void obliczBladSieci(double &bladsieci) {
	bladSieci = 0.0;
	for (int i = 0; i<liczbaWzorcow; i++) {
		numerWzorca = i;
		oblicz();
		bladSieci = bladSieci + blad*blad;
	}
	bladSieci = sqrt(bladSieci / liczbaWzorcow);
}