//Pseudo A.I. tests, expirimental f

#pragma hdrstop
#pragma argsused

#ifdef _WIN32
#include <tchar.h>
#else
  typedef char _TCHAR;
  #define _tmain main
#endif

#include <stdio.h>
#include <math.h>
#include <algorithm>

using namespace std;

const int numberofrounds=101;
const double maxi=75000; //increase for more accuracy
double maxgrowth=0.01;
const int total_number_of_trainingsets=37;
const int total_synapses_per_neuron=4;

    double traininginput_converted[total_synapses_per_neuron][total_number_of_trainingsets];
    double trainingoutput_converted[total_number_of_trainingsets];

double roundoutcome[numberofrounds];
double approx=0, out_average;

int i=0;
int j=0;
int k=0,w,v;

double requested_output_should_be_approx=0;

double traininginput[total_synapses_per_neuron][total_number_of_trainingsets];
double trainingoutput[total_number_of_trainingsets];

double requestedinput[total_synapses_per_neuron][1];
double requestedoutput=0;

double syn[total_synapses_per_neuron]={0,0,0,0};

double syn0adjust =0;
double syn1adjust =0;
double syn2adjust =0;
double syn3adjust =0;

double output=0;
double adjust_weights_by = 0;   // adjust synaptic weights

double fx = 0;
double fx_derivative=0;
double error=0;


double findMedian(double a[], int n)
{
    // First we sort the array
    sort(a, a+n);

    // check for even case
    if (n % 2 != 0)
       return (double)a[n/2];

    return (double)(a[(n-1)/2] + a[n/2])/2.0;
}





int _tmain(int argc, _TCHAR* argv[])
{

// simple test training-set, the output is t[0] squared and adding t[1] and t[2] and t[3]
 //set 0 input
traininginput[0][0]=11;
traininginput[1][0]=23;
traininginput[2][0]=42;
traininginput[3][0]=31;

//set 0 output
trainingoutput[0]=217;

//set 1 input
traininginput[0][1]=24;
traininginput[1][1]=31;
traininginput[2][1]=97;
traininginput[3][1]=43;

//set 1 output
trainingoutput[1]=747;

//set 2 input
traininginput[0][2]=75;
traininginput[1][2]=10;
traininginput[2][2]=12;
traininginput[3][2]=29;

//set 2 output
trainingoutput[2]=5676;

//set 3 input
traininginput[0][3]=45;
traininginput[1][3]=39;
traininginput[2][3]=51;
traininginput[3][3]=91;

//set 3 output
trainingoutput[3]=2206;

//set 4 input
traininginput[0][4]=71;
traininginput[1][4]=51;
traininginput[2][4]=17;
traininginput[3][4]=31;

//set 4 output
trainingoutput[4]=5140;

//set 5 input
traininginput[0][5]=45;
traininginput[1][5]=89;
traininginput[2][5]=55;
traininginput[3][5]=25;

//set 5 output
trainingoutput[5]=2194;

//set 6 input
traininginput[0][6]=15;
traininginput[1][6]=19;
traininginput[2][6]=57;
traininginput[3][6]=22;

//set 6 output
trainingoutput[6]=323;

//set 7 input
traininginput[0][7]=12;
traininginput[1][7]=70;
traininginput[2][7]=56;
traininginput[3][7]=19;

//set 7 output
trainingoutput[7]=289;

//set 8 input
traininginput[0][8]=1;
traininginput[1][8]=79;
traininginput[2][8]=47;
traininginput[3][8]=17;

//set 8 output
trainingoutput[8]=144;

//set 9 input
traininginput[0][9]=50;
traininginput[1][9]=51;
traininginput[2][9]=35;
traininginput[3][9]=32;

//set 9 output
trainingoutput[9]=2618;

//set 10 input
traininginput[0][10]=99;
traininginput[1][10]=9;
traininginput[2][10]=14;
traininginput[3][10]=40;

//set 10 output
trainingoutput[10]=9864;

//set 11 input
traininginput[0][11]=33;
traininginput[1][11]=90;
traininginput[2][11]=75;
traininginput[3][11]=10;

//set 11 output
trainingoutput[11]=1264;

//set 12 input
traininginput[0][12]=25;
traininginput[1][12]=75;
traininginput[2][12]=50;
traininginput[3][12]=15;

//set 12 output
trainingoutput[12]=765;

//set 13 input
traininginput[0][13]=31;
traininginput[1][13]=33;
traininginput[2][13]=32;
traininginput[3][13]=37;

//set 13 output
trainingoutput[13]=1063;

//set 14 input
traininginput[0][14]=2;
traininginput[1][14]=1;
traininginput[2][14]=8;
traininginput[3][14]=7;

//set 14 output
trainingoutput[14]=20;

//set 15 input
traininginput[0][15]=66;
traininginput[1][15]=86;
traininginput[2][15]=91;
traininginput[3][15]=79;

//set 15 output
trainingoutput[15]=4612;

//set 16 input
traininginput[0][16]=17;
traininginput[1][16]=0;
traininginput[2][16]=30;
traininginput[3][16]=56;

//set 16 output
trainingoutput[16]=375;

//set 17 input
traininginput[0][17]=80;
traininginput[1][17]=29;
traininginput[2][17]=21;
traininginput[3][17]=32;

//set 17 output
trainingoutput[17]=6482;

//set 18 input
traininginput[0][18]=18;
traininginput[1][18]=21;
traininginput[2][18]=22;
traininginput[3][18]=53;

//set 18 output
trainingoutput[18]=420;

//set 19 input
traininginput[0][19]=60;
traininginput[1][19]=61;
traininginput[2][19]=24;
traininginput[3][19]=13;

//set 19 output
trainingoutput[19]=3698;

//set 20 input
traininginput[0][20]=61;
traininginput[1][20]=14;
traininginput[2][20]=22;
traininginput[3][20]=49;

//set 20 output
trainingoutput[20]=3806;

//set 21 input
traininginput[0][21]=32;
traininginput[1][21]=38;
traininginput[2][21]=19;
traininginput[3][21]=43;

//set 21 output
trainingoutput[21]=1124;

//set 22 input
traininginput[0][22]=46;
traininginput[1][22]=97;
traininginput[2][22]=52;
traininginput[3][22]=1;

//set 22 output
trainingoutput[22]=2266;

//set 23 input
traininginput[0][23]=16;
traininginput[1][23]=22;
traininginput[2][23]=36;
traininginput[3][23]=77;

//set 23 output
trainingoutput[23]=391;

//set 24 input
traininginput[0][24]=81;
traininginput[1][24]=51;
traininginput[2][24]=24;
traininginput[3][24]=33;

//set 24 output
trainingoutput[24]=6669;

//set 25 input
traininginput[0][25]=5;
traininginput[1][25]=9;
traininginput[2][25]=10;
traininginput[3][25]=91;

//set 25 output
trainingoutput[25]=135;

//set 26 input
traininginput[0][26]=50;
traininginput[1][26]=50;
traininginput[2][26]=50;
traininginput[3][26]=50;

//set 26 output
trainingoutput[26]=2650;

//set 27 input
traininginput[0][27]=10;
traininginput[1][27]=15;
traininginput[2][27]=50;
traininginput[3][27]=39;

//set 27 output
trainingoutput[27]=204;

//set 28 input
traininginput[0][28]=20;
traininginput[1][28]=21;
traininginput[2][28]=27;
traininginput[3][28]=16;

//set 28 output
trainingoutput[28]=464;

//set 29 input
traininginput[0][29]=3;
traininginput[1][29]=81;
traininginput[2][29]=36;
traininginput[3][29]=14;

//set 29 output
trainingoutput[29]=140;

//set 30 input
traininginput[0][30]=24;
traininginput[1][30]=81;
traininginput[2][30]=97;
traininginput[3][30]=71;

//set 30 output
trainingoutput[30]=825;

//set 31 input
traininginput[0][31]=24;
traininginput[1][31]=38;
traininginput[2][31]=97;
traininginput[3][31]=50;

//set 31 output
trainingoutput[31]=761;

//set 32 input
traininginput[0][32]=26;
traininginput[1][32]=27;
traininginput[2][32]=41;
traininginput[3][32]=49;

//set 32 output
trainingoutput[32]=793;

//set 33 input
traininginput[0][33]=19;
traininginput[1][33]=31;
traininginput[2][33]=38;
traininginput[3][33]=67;

//set 33 output
trainingoutput[33]=497;

//set 34 input
traininginput[0][34]=20;
traininginput[1][34]=10;
traininginput[2][34]=99;
traininginput[3][34]=91;

//set 34 output
trainingoutput[34]=600;

//set 35 input
traininginput[0][35]=17;
traininginput[1][35]=70;
traininginput[2][35]=57;
traininginput[3][35]=18;

//set 35 output
trainingoutput[35]=434;

//set 36 input
traininginput[0][36]=78;
traininginput[1][36]=8;
traininginput[2][36]=71;
traininginput[3][36]=6;

//set 36 output
trainingoutput[36]=6169;

//INPUT REQUESTED DATA HERE
requestedinput[0][0]=77;
requestedinput[1][0]=8;
requestedinput[2][0]=71;
requestedinput[3][0]=6;
 requested_output_should_be_approx=3840;


  for(k=0;k<numberofrounds;k++)
 {


 //Randomize synaptic weights each round
 syn[0] = rand() % ( 2000 ) + 1 ; syn[0] = (syn[0]/1000)-1;
 syn[1] = rand() % ( 2000 ) + 1 ; syn[1] = (syn[1]/1000)-1;
 syn[2] = rand() % ( 2000 ) + 1 ; syn[2] = (syn[2]/1000)-1;
 syn[3] = rand() % ( 2000 ) + 1 ; syn[3] = (syn[3]/1000)-1;


  for(j=0;j<total_number_of_trainingsets;j++)
  {

    for(i=1;i<maxi;i++)
    {

     output = (traininginput[0][j]*syn[0]+traininginput[1][j]*syn[1]+traininginput[2][j]*syn[2]+traininginput[3][j]*syn[3]);

     fx = output+1;  // sin(output)

     fx_derivative = 1; // cos(fx)

     error = trainingoutput[j] - output;

     adjust_weights_by = error * fx_derivative;

     syn0adjust =  traininginput[0][j]*adjust_weights_by;
     syn1adjust =  traininginput[1][j]*adjust_weights_by;
     syn2adjust =  traininginput[2][j]*adjust_weights_by;
     syn3adjust =  traininginput[3][j]*adjust_weights_by;

            if (syn0adjust>maxgrowth) syn0adjust=maxgrowth;
            if (syn1adjust>maxgrowth) syn1adjust=maxgrowth;
            if (syn2adjust>maxgrowth) syn2adjust=maxgrowth;
            if (syn3adjust>maxgrowth) syn3adjust=maxgrowth;

            if (syn0adjust<-maxgrowth) syn0adjust=-maxgrowth;
            if (syn1adjust<-maxgrowth) syn1adjust=-maxgrowth;
            if (syn2adjust<-maxgrowth) syn2adjust=-maxgrowth;
            if (syn3adjust<-maxgrowth) syn3adjust=-maxgrowth;

      syn[0]=syn[0]+syn0adjust;
      syn[1]=syn[1]+syn1adjust;
      syn[2]=syn[2]+syn2adjust;
      syn[3]=syn[3]+syn3adjust;

    } // for i


  } // for j

   approx=requestedinput[0][0]*syn[0]+requestedinput[1][0]*syn[1]+requestedinput[2][0]*syn[2]+requestedinput[3][0]*syn[3];
   roundoutcome[k] = approx;

    printf("\nDone %d %% ",k);
        printf(",currently the outcome is %.2f",approx);
           out_average+=approx;

 }  //for k

    out_average=out_average/numberofrounds;
    printf("\nThe output should be approx (this number was inserted MANUALLY and is not computed in any way!) : %lf\n\n", requested_output_should_be_approx);
    printf("101 round average output %lf \n", abs(out_average));
    printf("101 round median output  %lf\n", findMedian(roundoutcome, sizeof(roundoutcome[0])));



    cin.get();

    return 0;



}