#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 double version = 0.001;
    const double E = 2.71828182845904523536;
    const int cyclesi = 200000;
    const int training_inputs=220000;

    double training_set_inputs[training_inputs][3];
    double training_set_outputs[training_inputs];
    double SynapticWeight[4], new_situation[training_inputs][3];
    double i,j,l, Output5, DOToutput5, output,cool, indicator;
    double Boutput[training_inputs], BsigmoidPart[training_inputs], Bsigmoid_DerivativePart[training_inputs], BerrorPart[training_inputs], BadjustmentPart[training_inputs], BadjustSynapticWeight[4];
    int m,q,qq, create;


    //output for the randomly generated training inputs
double outt(double (*array)[training_inputs][3], int b)
{
    double calc;


    // The current test-formula is input1^2 - input2 - input3
    calc =  (*array)[b][0]*(*array)[b][0]-(*array)[b][1]-(*array)[b][2];

        //avoid 0, major bug
        if (calc==0) { calc=1;
                    }


    return calc;
}


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

    srand (time(NULL));

    //requested data
    new_situation[0][0]=41;new_situation[0][1]=31;new_situation[0][2]=28;

        cool = outt(&new_situation,0);
       printf("\n the output should be approx %.2f\n",cool);


    new_situation[0][0]= 1/(1 + exp(-(1/new_situation[0][0])));
    new_situation[0][1]= 1/(1 + exp(-(1/new_situation[0][1])));
    new_situation[0][2]= 1/(1 + exp(-(1/new_situation[0][2])));

    for (create = 0; create < training_inputs; create++) {

                training_set_inputs[create][0]= (rand() % 100) + 1;
                training_set_inputs[create][1]= (rand() % 100) + 1;
                training_set_inputs[create][2]= (rand() % 100) + 1;

                training_set_outputs[create] = outt(&training_set_inputs, create);

                //printf("\n%d t0=%.2f t1=%.2f t2=%.2f o=%.2f", create, training_set_inputs[create][0], training_set_inputs[create][1], training_set_inputs[create][2], training_set_outputs[create]);

            }




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

    }
}


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

    }










   printf("\n");
   for( m = 1; m <= 19; m++ ){



    SynapticWeight[1]=rand() % 2000/double(1000)-double(1);
    SynapticWeight[2]=rand() % 2000/double(1000)-double(1);
    SynapticWeight[3]=rand() % 2000/double(1000)-double(1);

    //avoid 0, bugfix
    if (SynapticWeight[1]==0) {  SynapticWeight[1]=0.001; }
    if (SynapticWeight[2]==0) {  SynapticWeight[2]=0.001; }
    if (SynapticWeight[3]==0) {  SynapticWeight[3]=0.001; }

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



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


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

        Boutput[q] = training_set_inputs[q-1][0]*SynapticWeight[1]+training_set_inputs[q-1][1]*SynapticWeight[2]+training_set_inputs[q-1][2]*SynapticWeight[3];

        BsigmoidPart[q] = 1 / (1 + exp(-(Boutput[q])));

        Bsigmoid_DerivativePart[q] = BsigmoidPart[q] * (1 - BsigmoidPart[q]);

        BerrorPart[q] = (training_set_outputs[q-1] - BsigmoidPart[q]);

        BadjustmentPart[q] =  BerrorPart[q] * Bsigmoid_DerivativePart[q];

        }


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

            BadjustSynapticWeight[q]=0;
            for( qq = 1; qq <= training_inputs; qq++) {  BadjustSynapticWeight[q] += (training_set_inputs[qq-1][q-1]*BadjustmentPart[qq])/10000;}
                                        // the /1000 is done, bc of the thing will bug out if too many value is added.  so a subtler addition.
                                        // also, too many iterations (>1000000) will cause a strange type of bug, probably the same sort of issue

        SynapticWeight[q]=SynapticWeight[q]+BadjustSynapticWeight[q];

        }

        if ((floor(i/cyclesi*100))!=indicator)
                {
                    printf("Attempt %d, %.0f %% done",m, indicator);

    Output5=new_situation[0][0]*SynapticWeight[1]+new_situation[0][1]*SynapticWeight[2]+new_situation[0][2]*SynapticWeight[3];

    DOToutput5 = 1 / (1 + exp(-(Output5)));


    output = 1 / DOToutput5;
    output = output - 1;
    output = log10(E)/log10(output);
    output = abs(output);


    printf("\n Betweenvalues (%.0d training-inputs, %d iterations) has output %.2f\n",training_inputs, cyclesi, output);
                }



        indicator = floor(i/cyclesi*100);


    }






    Output5=new_situation[0][0]*SynapticWeight[1]+new_situation[0][1]*SynapticWeight[2]+new_situation[0][2]*SynapticWeight[3];

    DOToutput5 = 1 / (1 + exp(-(Output5)));


    output = 1 / DOToutput5;
    output = output - 1;
    output = log10(E)/log10(output);
    output = abs(output);


    printf("\n Final Values (%.0d inputs, %d iterations) has output %.2f\n",training_inputs, cyclesi, output);
   } //m










    cout << "\n\nPress enter to exit..." << endl;
    cin.get();





    return 0;
}