#include <iostream>
#include "n.h"
#include <math.h>
#include <stdlib.h>
#include <string.h>

node nullnode;
/* funkcja aktywacji
 */
double sigma(double v, double di){
	double x=-2*di*v;
	return 1/(1+exp(x));
}
/* pochodna funkcji aktywacji
 */
double dsigma(double v, double di){
	double x=-2*di*v;
	return 2*di*exp(x)/((1+exp(x))*(1+exp(x)));
}

/* Konstruktor węzła (klasy pierwotnej dla neuronu) 
 * dla ulatwienia debugowania wprowadzona zostala 
 * zmienna name
 */
node::node(char *aname){
	pnext=0;
	h=0; d=0;
	eval_ready=false;
	err_ready=false;
	ncount=0;
	
	if(aname==0)	{name= new char[1]; name[0]=0;}
	else {name= new char[strlen(aname)+1]; strcpy(name,aname);}
}

node *node::addnext(node* an){
	if(!pnext) return pnext=an;
	return pnext->addnext(an);
}

/* Ta funkcja łączy wejscia neuronu
 * do wczesniej utowrzonej warstwy (lub wejsc)
 * inicjalizuje licznik wejsc.
 */
node &neuron::connect(node* an){
	ncount=an->getCount();
	pinput=an;
	reset();
	return *an;
}

/*
 * Neuron rozni sie od węzla tym, że posiada wejscia
 * i dla kazdego z nich okreslon± wagę oraz wagę wejscia
 * stałego. Wagi wejsc zapisywane sa w tablicy pw 
 * inicjalizowanej  w funkcji initw() dla kazdego neuronu
 * po utworzeniu sieci.
 */
neuron::neuron(char *aname) : node(aname){
	pinput=0;
	pw=0;
	w0=0;
}

neuron::~neuron(){
   if(pw) delete [] pw;
}

node &node::getknext(int k){
if(k<=0) return *this;
if(pnext) return pnext->getknext(k-1);
return nullnode;
}

/* oblicznienie funkcji aktywacji dla wartosci
 * potencjalu membranowego
 * */
double neuron::fa(){
	return sigma(h,1.0);
}

/* oblicznienie pochodnej funkcji aktywacji dla wartosci
 * potencjalu membranowego
 * */
double neuron::dfa(){
	return dsigma(h,1.0);
}

/* oblicznie wyscia neuronu zoptymalizowane tak, by 
 * suma wejsc byla obliczana tylko raz
 * */
double neuron::eval(){
	if(eval_ready) return fa();
	if(ncount) {
		h=-w0;
		for(int i = 0; i<ncount; i++)	{h+=pw[i]*((*this)[i].eval());
		}
	}
	eval_ready=true;
	return fa();
}

/* dezaktualizacja potencjalu membranowego
 * */
void neuron::reset(){

	if(!eval_ready) return;
	if(ncount) for(int i=0; i<ncount;i++) 
			  	(*this)[i].reset();
	h=0; eval_ready=false;
}

/* funkcja zapisuje stan wag neuronu na wyjscie standardowe
 * */
void neuron::dumpw(){

	cerr 	  << name
			  << " dumpw--> " 
			  << "w0"<<"="<< w0<<" " ;
	for(int i =0; i<ncount; i++) cerr << "w"<<i+1<<"="<< pw[i] <<" ";
	cerr<<endl;
}

/* dezaktualizowanie obliczonych bledow
 * */
void neuron::reset_err(){
if(!err_ready) return;
	if(ncount) for(int i=0; i<ncount;i++) 
		(*this)[i].reset_err();

	d=0; err_ready=false;
}

/* inicjalizacja wag
 * */
void neuron::initw(){
	if(ncount) 
	if(pw) delete [] pw;
	else pw = new double [ncount];
	for(int i =0; i<ncount; i++) pw[i]=((double)random())/RAND_MAX-0.5;
	w0=1;
}

node &neuron::operator[](int k){
		if(!pinput) return nullnode;
		  return pinput->getknext(k);
}

/* propagacja wsteczna bledu
 * */
void neuron::bpg(){
for(int i=0;i<ncount;i++) (*this)[i].adderr(pw[i]*d);
}

/* korekta wag 
 * */
void neuron::dw(double n){

for(int i=0;i<ncount;i++) pw[i]+=n*d*(*this)[i].eval();
w0-=n*d;
}