ImprovedV

#pragma hdrstop
#pragma argsused

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

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

using std::cin;
using std::cout;
using std::endl;


    const long double version = 0.001875; // removed weird bug
    const long double cyclesi = 100000;
    const int training_inputs=37;

    long double training_set_inputs[training_inputs][3];
    long double training_set_outputs[training_inputs], new_situation[training_inputs][3];

    long double sigmoidSynapticWeight[4];
    long double sigmoidOutput5, sigmoidDOToutput5, sigmoidoutput;
    long double Bsigmoidoutput[training_inputs], BsigmoidPart[training_inputs], Bsigmoid_DerivativePart[training_inputs], BsigmoiderrorPart[training_inputs], BsigmoidadjustmentPart[training_inputs], BsigmoidadjustSynapticWeight[4];

    long double oldoutput, cool, indicator,i=1;
    int m,q,qq, create;

    int f,g,h,y;


long double outt(long double (*array)[training_inputs][3], int b)
{
    long double calc;

        //testing the ai, for it to 'predict' the outcome of these, known, simple formulas; ofc i can plug in the formula and calculate directly : just experimenting..
            // it 'seems' to work, except for extreme high or low numbers (relative to the training table), it also does not work for extreme formulas like pow(x,5)+pow(y,3) etcc

            //3*  21.5*  1.77*
       calc= 3*(*array)[b][0]  +  21.5*(*array)[b][1]  +  4.77*(*array)[b][2];

        if (calc==0) { calc=1;  printf("\ntest\n");
                     }


    return calc;
}


           // sigmoid function
long double s(long double x)
{
    return 1 / (1 + expl(-(x)));
}

            //sigmoid derivative
long double d(long double x)
{
    return x * (1 - x);
}


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

    srand (time(NULL));

               // 72, 35,65
    new_situation[0][0]=72.00;new_situation[0][1]=35.00;new_situation[0][2]=62.00;
    cool = outt(&new_situation,0);

       printf("\n the output should be approx %.2Lf\n",cool);



//handmade table with somewhat random inputs
y=0;
//set 0 input
training_set_inputs[0][0]=53;
training_set_inputs[0][1]=23;
training_set_inputs[0][2]=42;


//set 0 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 1 input
training_set_inputs[1][0]=24;
training_set_inputs[1][1]=31;
training_set_inputs[1][2]=97;

//set 1 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 2 input
training_set_inputs[2][0]=75;
training_set_inputs[2][1]=19;
training_set_inputs[2][2]=12;

//set 2 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

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

//set 3 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 4 input
training_set_inputs[4][0]=71;
training_set_inputs[4][1]=51;
training_set_inputs[4][2]=17;

//set 4 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 5 input
training_set_inputs[5][0]=45;
training_set_inputs[5][1]=79;
training_set_inputs[5][2]=55;

//set 5 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 6 input
training_set_inputs[6][0]=25;
training_set_inputs[6][1]=19;
training_set_inputs[6][2]=57;

//set 6 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 7 input
training_set_inputs[7][0]=32;
training_set_inputs[7][1]=70;
training_set_inputs[7][2]=56;

//set 7 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 8 input
training_set_inputs[8][0]=31;
training_set_inputs[8][1]=79;
training_set_inputs[8][2]=47;

//set 8 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 9 input
training_set_inputs[9][0]=50;
training_set_inputs[9][1]=51;
training_set_inputs[9][2]=35;

//set 9 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 10 input
training_set_inputs[10][0]=80;
training_set_inputs[10][1]=29;
training_set_inputs[10][2]=14;

//set 10 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 11 input
training_set_inputs[11][0]=33;
training_set_inputs[11][1]=85;
training_set_inputs[11][2]=75;

//set 11 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 12 input
training_set_inputs[12][0]=25;
training_set_inputs[12][1]=73;
training_set_inputs[12][2]=51;

//set 12 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 13 input
training_set_inputs[13][0]=31;
training_set_inputs[13][1]=33;
training_set_inputs[13][2]=32;

//set 13 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 14 input
training_set_inputs[14][0]=22;
training_set_inputs[14][1]=41;
training_set_inputs[14][2]=38;

//set 14 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 15 input
training_set_inputs[15][0]=66;
training_set_inputs[15][1]=86;
training_set_inputs[15][2]=91;

//set 15 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 16 input
training_set_inputs[16][0]=17;
training_set_inputs[16][1]=32;
training_set_inputs[16][2]=30;

//set 16 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 17 input
training_set_inputs[17][0]=80;
training_set_inputs[17][1]=29;
training_set_inputs[17][2]=21;

//set 17 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 18 input
training_set_inputs[18][0]=18;
training_set_inputs[18][1]=21;
training_set_inputs[18][2]=29;

//set 18 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 19 input
training_set_inputs[19][0]=60;
training_set_inputs[19][1]=61;
training_set_inputs[19][2]=24;

//set 19 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 20 input
training_set_inputs[20][0]=61;
training_set_inputs[20][1]=44;
training_set_inputs[20][2]=22;

//set 20 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 21 input
training_set_inputs[21][0]=32;
training_set_inputs[21][1]=38;
training_set_inputs[21][2]=49;

//set 21 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

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

//set 22 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 23 input
training_set_inputs[23][0]=56;
training_set_inputs[23][1]=22;
training_set_inputs[23][2]=36;

//set 23 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 24 input
training_set_inputs[24][0]=81;
training_set_inputs[24][1]=51;
training_set_inputs[24][2]=24;

//set 24 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 25 input
training_set_inputs[25][0]=58;
training_set_inputs[25][1]=79;
training_set_inputs[25][2]=31;

//set 25 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 26 input
training_set_inputs[26][0]=50;
training_set_inputs[26][1]=49;
training_set_inputs[26][2]=50;

//set 26 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 27 input
training_set_inputs[27][0]=51;
training_set_inputs[27][1]=45;
training_set_inputs[27][2]=64;

//set 27 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 28 input
training_set_inputs[28][0]=20;
training_set_inputs[28][1]=21;
training_set_inputs[28][2]=67;

//set 28 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 29 input
training_set_inputs[29][0]=37;
training_set_inputs[29][1]=81;
training_set_inputs[29][2]=36;

//set 29 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 30 input
training_set_inputs[30][0]=24;
training_set_inputs[30][1]=81;
training_set_inputs[30][2]=57;

//set 30 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 31 input
training_set_inputs[31][0]=24;
training_set_inputs[31][1]=38;
training_set_inputs[31][2]=97;

//set 31 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 32 input
training_set_inputs[32][0]=26;
training_set_inputs[32][1]=27;
training_set_inputs[32][2]=41;

//set 32 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 33 input
training_set_inputs[33][0]=19;
training_set_inputs[33][1]=31;
training_set_inputs[33][2]=38;

//set 33 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 34 input
training_set_inputs[34][0]=20;
training_set_inputs[34][1]=29;
training_set_inputs[34][2]=55;

//set 34 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 35 input
training_set_inputs[35][0]=17;
training_set_inputs[35][1]=70;
training_set_inputs[35][2]=57;

//set 35 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;

//set 36 input
training_set_inputs[36][0]=78;
training_set_inputs[36][1]=80;
training_set_inputs[36][2]=71;

//set 36 output
training_set_outputs[y] = outt(&training_set_inputs, y);y++;




    new_situation[0][0]= 1/new_situation[0][0];
    new_situation[0][1]= 1/new_situation[0][1];
    new_situation[0][2]= 1/new_situation[0][2];




    for(auto& rows: training_set_inputs)
{
    for(auto& elem: rows)
    {
        elem =  1/elem;

    }
}


    for (auto& number : training_set_outputs)
    {
        number =  1/number;

    }




    sigmoidSynapticWeight[1]=0.41;
    sigmoidSynapticWeight[2]=0.42;
    sigmoidSynapticWeight[3]=0.43;//NON RANDOM values to test the system, to weed out some randomness.



    printf("SynapticWeight[1]=%.2Lf , SynapticWeight[2]=%.2Lf, SynapticWeight[3]=%.2Lf\n\n", sigmoidSynapticWeight[1], sigmoidSynapticWeight[2], sigmoidSynapticWeight[3]);


    while (i++) {


        //for( q = 1; q <= training_inputs; q++)
        q = rand() % training_inputs + 1;  //same result quicker, tested..
         {

        Bsigmoidoutput[q] = training_set_inputs[q-1][0]*sigmoidSynapticWeight[1]+training_set_inputs[q-1][1]*sigmoidSynapticWeight[2]+training_set_inputs[q-1][2]*sigmoidSynapticWeight[3];

        BsigmoidPart[q] = s(Bsigmoidoutput[q]);

        Bsigmoid_DerivativePart[q] = d(BsigmoidPart[q]);

        BsigmoiderrorPart[q] = (s(training_set_outputs[q-1]) - BsigmoidPart[q]);

        BsigmoidadjustmentPart[q] =  BsigmoiderrorPart[q] * Bsigmoid_DerivativePart[q];

        }


        for( q = 1; q <= 3; q++) {


            BsigmoidadjustSynapticWeight[q]=0;


            for( qq = 1; qq <= training_inputs; qq++) {  BsigmoidadjustSynapticWeight[q] += (s(training_set_inputs[qq-1][q-1])*BsigmoidadjustmentPart[qq])/(training_inputs/10);}

        sigmoidSynapticWeight[q]=sigmoidSynapticWeight[q]+BsigmoidadjustSynapticWeight[q];

        }



        if ((floor(i/cyclesi*100))!=indicator)
                {



    sigmoidOutput5=new_situation[0][0]*sigmoidSynapticWeight[1]+new_situation[0][1]*sigmoidSynapticWeight[2]+new_situation[0][2]*sigmoidSynapticWeight[3];

    sigmoidDOToutput5 = s(sigmoidOutput5);

        //these four lines here below should not be here, but without it, it simply does not work.
    sigmoidoutput = 1 / sigmoidDOToutput5;
    sigmoidoutput = sigmoidoutput - 1;
    sigmoidoutput = log(expl(1))/log(sigmoidoutput);
    sigmoidoutput = -sigmoidoutput;






    printf("Step %.0Lf ",indicator); printf("Increase : %Lf \n", sigmoidoutput-oldoutput);
    oldoutput = sigmoidoutput;



    printf("\nSigmoid-method, %.0Lf iterations) has output %.2Lf  (targetvalue = %.2Lf)",i, sigmoidoutput,cool);

                }



        indicator = floor(i/cyclesi*100);


    }



    cin.get();





    return 0;
}