#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#define NumHidden 6
#define NumInput 2

double trainVal[1000][3];

int valCount;

double wInHid[NumInput+1][NumHidden+1] = {{0}};
double wHidOut[NumHidden+1] = {0};

double xmax = 0;
double ymax = 0;

double eta = 0.0009;

int debugMode = 0;

void normalize(){
    for(int i = 0; i < valCount; i++)
    {
        if(fabs(trainVal[i][0]) > xmax)
        {
            xmax = fabs(trainVal[i][0]);
        }

        if(fabs(trainVal[i][1]) > ymax)
        {
            ymax = fabs(trainVal[i][1]);
        }
    }

    for(int i = 0; i < valCount; i++)
    {
        trainVal[i][0] = trainVal[i][0]/xmax;
        trainVal[i][1] = trainVal[i][1]/ymax;
    }

}

void train(){
    double error = 100;
    double deltaO = 0;

    double hidden[NumHidden+1];
    double output = 0;

    double deltaH [NumHidden + 1] = {0};
    double deltaWeightInHid[NumInput + 1][NumHidden + 1];
    double deltaWeightHidOut[NumHidden + 1];

    double sumHid[NumHidden+1];
    double sumOut;
    double sumDOW[NumHidden + 1];

    normalize();

    int classificationError = 1;

    while(error>0.1)
    {
        if(debugMode) printf("%f\n", error);

        error = 0;

        classificationError = 0;

        for(int p = 1 ; p <= valCount ; p++ )           /* repeat for all the training patterns */
        {

            /* compute hidden unit activations */

            for(int j = 1 ; j <= NumHidden ; j++ )
            {
                sumHid[j] = wInHid[0][j] ;

                for(int i = 1 ; i <= NumInput ; i++ )
                {
                    sumHid[j] += trainVal[p][i-1] * wInHid[i][j] ;
                }

                hidden[j] = tanh(sumHid[j]);
            }

            sumOut = wHidOut[0] ;

            for(int j = 1 ; j <= NumHidden ; j++ )
            {
                sumOut += hidden[j] * wHidOut[j] ;
            }

            output = tanh(sumOut);
            error += (output - trainVal[p][2])*(output - trainVal[p][2]);

            if((output > 0 && trainVal[p][2]<0) && (output < 0 && trainVal[p][2]>0)) classificationError=1;

            deltaO = 2*(trainVal[p][2]-output);

            /* 'back-propagate' errors to hidden layer */
            for(int j = 1 ; j <= NumHidden ; j++ )
            {
                sumDOW[j] = wHidOut[j] * deltaO;
                deltaH[j] = sumDOW[j] *  (1.0 - hidden[j] * hidden[j]) ;
            }

            for(int j = 1 ; j <= NumHidden ; j++ )           /* update weights wInHid */
            {
                deltaWeightInHid[0][j] = eta * deltaH[j];
                wInHid[0][j] += deltaWeightInHid[0][j] ;

                for(int i = 1 ; i <= NumInput ; i++ )
                {
                    deltaWeightInHid[i][j] = eta * trainVal[p][i-1] * deltaH[j];
                    wInHid[i][j] += deltaWeightInHid[i][j] ;
                }

            }

            /* update weights WeightHO */
            deltaWeightHidOut[0] = eta * deltaO;
            wHidOut[0] += deltaWeightHidOut[0] ;

            for(int j = 1 ; j <= NumHidden ; j++ )
            {
                deltaWeightHidOut[j] = eta * hidden[j] * deltaO;
                wHidOut[j] += deltaWeightHidOut[j] ;

            }
        }
    }
}


int main()

{
    int c, j, k;
    double functionOutput;
    double x = 0, y = 0;
    int trainingFinished = 0;
    int trainingDataEnd = 0;

    double sumHid[NumHidden + 1] = {0};
    double hidden[NumHidden + 1] = {0};
    double sumOut = 0;
    double output = 0;

    srand(time(NULL));

    c  = j = valCount = functionOutput =0;

    /***Weight initalisation****/
    for(int i = 1; i <= NumHidden; i++)
    {
        for(int j = 0; j <= NumInput; j++)
        {
            wInHid[i][j] = (rand() % 10)/1000.0;;
            if(debugMode) printf("%f\n", wInHid[i][j]);
        }
    }

    for(int i = 0; i <= NumHidden; i++)
    {
        wHidOut[i] = (rand() % 10)/1000.0;;
        if(debugMode) printf("%f\n", wHidOut[i]);
    }

    for(j = 0; j<1000; j++)
    {
        for(k = 0; k<3; k++)
            trainVal[j][k]=0;
    }


    if(debugMode)
    {
        FILE * pFile;
        pFile = fopen ("/home/vincent/NetTestC.txt","r");

        valCount=0;

        while(1)
        {
            fscanf(pFile, "%lf,%lf,%lf\n", &trainVal[valCount][0], &trainVal[valCount][1],&trainVal[valCount][2]);

            printf("%f,%f,%f\n",trainVal[valCount][0], trainVal[valCount][1],trainVal[valCount][2]);

            if(trainVal[valCount][2]==0) break;

            valCount++;
        }

        trainingFinished=1;
        rewind(pFile);

        train();

        while(1)
        {
            double z = 0;

            if(trainingDataEnd)
            {
                c=fscanf(pFile, "%lf,%lf\n", &x, &y);

                x/=xmax;
                y/=ymax;

                if(c==-1) break;

                for( j = 1 ; j <= NumHidden ; j++ )
                {
                    sumHid[j] = wInHid[0][j] ;

                    sumHid[j] += x * wInHid[1][j] ;
                    sumHid[j] += y * wInHid[2][j] ;

                    hidden[j] = tanh(sumHid[j]);
                }

                sumOut = wHidOut[0] ;

                for( j = 1 ; j <= NumHidden ; j++ )
                {
                    sumOut += hidden[j-1] * wHidOut[j] ;
                }

                output = tanh(sumOut);

                if(output>0) printf("+1\n");
                else printf("-1\n");
            } else
                fscanf(pFile, "%lf,%lf,%lf\n", &x, &y, &z);

            if(z==0) trainingDataEnd=1;

        }
    }else {

    while(c!=-1)
    {
            if(!trainingFinished)
            {
                c = scanf("%lf,%lf,%lf\n", &trainVal[valCount][0], &trainVal[valCount][1], &trainVal[valCount][2]);

                if(trainVal[valCount][2] == 0)
                {
                    train();
                    trainingFinished = 1;
                }
                else
                {
                    valCount++;
                }
            } else {
                x = y = 0;

                c = scanf("%lf,%lf\n", &x, &y);

                x/=xmax;
                y/=ymax;

                if(c == -1) break;

                for( j = 1 ; j <= NumHidden ; j++ )           /* compute hidden unit activations */
                {
                    sumHid[j] = wInHid[0][j] ;

                    sumHid[j] += x * wInHid[1][j] ;
                    sumHid[j] += y * wInHid[2][j] ;

                    hidden[j] = tanh(sumHid[j]);
                }

                sumOut = wHidOut[0] ;

                for( j = 1 ; j <= NumHidden ; j++ )
                {
                    sumOut += hidden[j] * wHidOut[j] ;
                }

                output = tanh(sumOut);

                if(output>0) printf("+1\n");
                else printf("-1\n");

            }
        }
    }

    return 0;
}