#include <cstdlib> 
#include <iostream>
#include <math.h>
#include <ctime>


#include "math_functions.h"
#include "pitch.h"
#include "node.h"
#include "net.h"


Node* inputs[NUMINPUTS];
Node* hidden[NUMHIDDEN];
Node* outputs[NUMOUTPUTS];
pitch* training[TRAINING_POINTS];
pitch* testing[TESTING_POINTS];

using namespace std;


net::net(void)
{
 	    
}


void net::trainNetwork()
{
		double tmpAct, tmpDelta;
        double gain = 0.1;
        int success = 0;
        int currentPitch;
		int y,x,i,z;
        
        double hiddenDelta[NUMHIDDEN];
        double outputDelta[NUMOUTPUTS];
        double target[NUMOUTPUTS];


       cout<<"Training Points"<<endl;

        for (i=0; i< TRAINING_POINTS; i++) 
		{
			pitch* new_pitch = new pitch();
			training[i] = new_pitch;
			cout<<training[i]->xpos<<"       "<<training[i]->ypos<<
				"      "<<training[i]->recognition<<endl;
        	
        }
        
        
        for (x=0; x<EPOCH; x++) 
		{
        	for (currentPitch=0; currentPitch<TRAINING_POINTS; currentPitch++) 
			{
        		inputs[0]->activation = training[currentPitch]->xpos;
        		inputs[1]->activation = training[currentPitch]->ypos;
				inputs[2]->activation = training[currentPitch]->recognition;
            
        		// start the feed-forward steps:
        		// calculate values of the hidden layer
        		for (y=0; y<NUMHIDDEN; y++) 
				{
        			tmpAct = hidden[y]->bias;
        			for ( z=0; z<NUMINPUTS; z++) 
						tmpAct += inputs[z]->activation * inputWeights[z][y];
        			
					hidden[y]->activation = calcSigmoid(tmpAct);
        		}
            
        		// calculate values of the Output layer
        		for ( y=0; y<NUMOUTPUTS; y++) 
				{
        			tmpAct = outputs[y]->bias;
        			for ( z=0; z<NUMHIDDEN; z++) 
        				tmpAct += hidden[z]->activation * outputWeights[z][y];
        			
        			outputs[y]->activation = calcSigmoid(tmpAct);
        		}
            
        		// end the feed-forward step
            
        		// Given point class (S or T) set target values for outputLayer.
        		if (training[currentPitch]->getType() == 'S') 
				{
        			target[0] = 1.0;
        			target[1] = 0.0;
        		} 
				else 
				{
        			target[0] = 0.0;
        			target[1] = 1.0;
        		}

        		// Perform the backpropogation steps
        		for ( i=0; i < NUMOUTPUTS; i++)
				{
        			outputDelta[i] = (target[i] - outputs[i]->activation) 
						  * outputs[i]->activation * (1.0 - outputs[i]->activation);
				}
            
        		for ( y=0; y<NUMHIDDEN; y++) 
				{
        			tmpDelta = 0.0;
        			for ( z=0; z<NUMOUTPUTS; z++)     
        				tmpDelta += outputDelta[z] * outputWeights[y][z];
        			
        			hiddenDelta[y] = tmpDelta * hidden[y]->activation
						* (1.0 - hidden[y]->activation);
        		}

        		// Update weights (between input and hidden layers).
        		for ( y=0; y<NUMINPUTS; y++)
				{
        			for ( z=0; z<NUMHIDDEN; z++)
        				inputWeights[y][z] += gain * hiddenDelta[z] * inputs[y]->activation;
				}
            
        		// Update weights (between hidden and output layers).
        		for ( y=0; y<NUMHIDDEN; y++)
				{
        			for ( z=0; z<NUMOUTPUTS; z++)
        				outputWeights[y][z] += gain * outputDelta[z] * hidden[y]->activation;
				}
            
        		// Update bias (hidden layer).
        		for ( y=0; y<NUMHIDDEN; y++)
				{
        			hidden[y]->bias += gain * hiddenDelta[y];
				}

        		// Update bias (output layer).
        		for ( y=0; y<NUMOUTPUTS; y++)
				     outputs[y]->bias += gain * outputDelta[y];
        		
            
        		// end of the back-propogation steps
        	}
     
        }
        cout<<"Exiting Training"<<endl;
	}

	void net::testNetwork() 
 {
		double net1;
		char predicted;
		char actual;
		int missed=0;
		int i,t,j;
		double percentCorrect;


		for ( i = 0; i < TESTING_POINTS; i++)
		{
			pitch* new_pitch = new pitch();
			testing[i] = new_pitch;
		}
		
		
		cout<<"   X        Y    Recognition    Pred         Act"<<endl;
	
		for ( t = 0; t < TESTING_POINTS; t++) {
			inputs[0]->activation = testing[t]->xpos;
			inputs[1]->activation = testing[t]->ypos;
			inputs[2]->activation = testing[t]->recognition;
		  
			// Calculate the net input to each hidden node
			for ( i = 1; i < NUMHIDDEN; i++) 
			{
				net1 = hidden[i]->bias;
				for ( j = 0; j < NUMINPUTS; j++)
					net1 += (inputWeights[j][i] * inputs[j]->activation);
					
				hidden[i]->activation = calcSigmoid(net1);
				
			}
		  
			//Calculate the net input to each output node
			for ( i = 0; i < NUMOUTPUTS; i++) 
			{
				net1 = outputs[i]->bias;
				for ( j = 0; j < NUMHIDDEN; j++) 
					net1 += (outputWeights[j][i] * hidden[j]->activation);
				
				outputs[i]->activation = calcSigmoid(net1);
			}
			
			if (outputs[0]->activation >= 1.0 - THRESHOLD)
				predicted = 'S';
			else
				predicted = 'T';

			actual = testing[t]->getType();
			
			cout<<testing[t]->xpos<<"       "<<testing[t]->ypos<<
				"      "<<testing[t]->recognition<<"         "<<predicted<<"        "<< actual<<endl;
			

			
			if ( actual != predicted) {
				missed++;
			}

		}


		percentCorrect = 100* (double)(TESTING_POINTS - missed)/TESTING_POINTS;

		cout<<endl;
		cout<<"Percent Correct: "<<percentCorrect<<endl;
		
	}
	
	void net::initializeNetwork() 
	{
		double rs=0;
		int x,y;

		cout<<"Starting Initialization"<<endl;	
        for ( x=0; x<NUMINPUTS; x++)
		{
            for ( y=0; y<NUMHIDDEN; y++) 
				inputWeights[x][y] = get_rand() * .1 - (.1/2.0);
			                
        }
        
      
        for ( x=0; x<NUMHIDDEN; x++)
		{
            for ( y=0; y<NUMOUTPUTS; y++) 
			     outputWeights[x][y] = get_rand() * .1 - (.1/2.0);
			         
		}
        
       
        for ( x=0; x<NUMINPUTS; x++) 
		{
			Node* new_node = new Node(0.0,0.0);
		    inputs[x] = new_node;
		}
            
        for ( x=0; x<NUMHIDDEN; x++) 
		{
			Node* new_node = new Node();
            hidden[x] = new_node;
		}
           
        for ( x=0; x<NUMOUTPUTS; x++) 
		{
			Node* new_node = new Node();
            outputs[x] = new_node;
		}
           
		cout<<"Exiting Initialization"<<endl;
	}


	double net::calcSigmoid(double x) 
	{
		double tempx;

		//make sure to have error checking
		if(x > 7.0 )
			return .9999;
		else if (x < -7.0)
		    return .0001;
		else
		{
			tempx = ((double) (1.0 / (1.0 + exp(-x))));
		    return tempx;
		}
		
    }