Example

#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;

double SigmoidPart1, SigmoidPart2, SigmoidPart3, SigmoidPart4;
double Sigmoid_DerivativePart1, Sigmoid_DerivativePart2, Sigmoid_DerivativePart3, Sigmoid_DerivativePart4;
double ErrorPart1, ErrorPart2, ErrorPart3, ErrorPart4;
double AdjustmentPart1, AdjustmentPart2, AdjustmentPart3, AdjustmentPart4;

 int _tmain(int argc, _TCHAR* argv[])
{
    double training_set_inputs[4][3];
    double training_set_outputs[4];
    double SynapticWeight[3], new_situation[3];
    double i,j,l, Output1, Output2, Output3, Output4, Output5, DOToutput1, DOToutput2, DOToutput3, DOToutput4, DOToutput5, AdjustSynapticWeight_0, AdjustSynapticWeight_1, AdjustSynapticWeight_2;

    training_set_inputs[0][0]=0;training_set_inputs[0][1]=0;training_set_inputs[0][2]=1;
    training_set_inputs[1][0]=1;training_set_inputs[1][1]=1;training_set_inputs[1][2]=1;
    training_set_inputs[2][0]=1;training_set_inputs[2][1]=0;training_set_inputs[2][2]=1;
    training_set_inputs[3][0]=0;training_set_inputs[3][1]=1;training_set_inputs[3][2]=1;

    training_set_outputs[0]=0;
    training_set_outputs[1]=1;
    training_set_outputs[2]=1;
    training_set_outputs[3]=0;



    // Should be a random number between -1 and +1 ; fixed values b/c of example.
    SynapticWeight[0]=-0.16595599;
    SynapticWeight[1]=0.44064899;
    SynapticWeight[2]=-0.99977125;


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

        Output1 = training_set_inputs[0][0]*SynapticWeight[0]+training_set_inputs[0][1]*SynapticWeight[1]+training_set_inputs[0][2]*SynapticWeight[2];
        Output2 = training_set_inputs[1][0]*SynapticWeight[0]+training_set_inputs[1][1]*SynapticWeight[1]+training_set_inputs[1][2]*SynapticWeight[2];
        Output3 = training_set_inputs[2][0]*SynapticWeight[0]+training_set_inputs[2][1]*SynapticWeight[1]+training_set_inputs[2][2]*SynapticWeight[2];
        Output4 = training_set_inputs[3][0]*SynapticWeight[0]+training_set_inputs[3][1]*SynapticWeight[1]+training_set_inputs[3][2]*SynapticWeight[2];


        // one part for each set, the whole thing needs to be simplified.
        SigmoidPart1 = 1 / (1 + exp(-(Output1)));
        SigmoidPart2 = 1 / (1 + exp(-(Output2)));
        SigmoidPart3 = 1 / (1 + exp(-(Output3)));
        SigmoidPart4 = 1 / (1 + exp(-(Output4)));

        Sigmoid_DerivativePart1 = SigmoidPart1 * (1 - SigmoidPart1);
        Sigmoid_DerivativePart2 = SigmoidPart2 * (1 - SigmoidPart2);
        Sigmoid_DerivativePart3 = SigmoidPart3 * (1 - SigmoidPart3);
        Sigmoid_DerivativePart4 = SigmoidPart4 * (1 - SigmoidPart4);

        ErrorPart1 = (training_set_outputs[0] - SigmoidPart1);
        ErrorPart2 = (training_set_outputs[1] - SigmoidPart2);
        ErrorPart3 = (training_set_outputs[2] - SigmoidPart3);
        ErrorPart4 = (training_set_outputs[3] - SigmoidPart4);

        AdjustmentPart1 =  ErrorPart1 * Sigmoid_DerivativePart1;
        AdjustmentPart2 =  ErrorPart2 * Sigmoid_DerivativePart2;
        AdjustmentPart3 =  ErrorPart3 * Sigmoid_DerivativePart3;
        AdjustmentPart4 =  ErrorPart4 * Sigmoid_DerivativePart4;

        AdjustSynapticWeight_0 = training_set_inputs[0][0]*AdjustmentPart1+training_set_inputs[1][0]*AdjustmentPart2+training_set_inputs[2][0]*AdjustmentPart3+training_set_inputs[3][0]*AdjustmentPart4;
        AdjustSynapticWeight_1 = training_set_inputs[0][1]*AdjustmentPart1+training_set_inputs[1][1]*AdjustmentPart2+training_set_inputs[2][1]*AdjustmentPart3+training_set_inputs[3][1]*AdjustmentPart4;
        AdjustSynapticWeight_2 = training_set_inputs[0][2]*AdjustmentPart1+training_set_inputs[1][2]*AdjustmentPart2+training_set_inputs[2][2]*AdjustmentPart3+training_set_inputs[3][2]*AdjustmentPart4;

        SynapticWeight[0]=SynapticWeight[0]+AdjustSynapticWeight_0;
        SynapticWeight[1]=SynapticWeight[1]+AdjustSynapticWeight_1;
        SynapticWeight[2]=SynapticWeight[2]+AdjustSynapticWeight_2;

       printf("\nTEST %.14f %.14f %.14f ADJ %.14f %.14f %.14f", SynapticWeight[0], SynapticWeight[1], SynapticWeight[2], AdjustSynapticWeight_0, AdjustSynapticWeight_1, AdjustSynapticWeight_2);
    }

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

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

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

    printf("\nsemidebug i: %lf", i);
    printf("\nsemidebug training_set_inputs[3][0]: %lf", training_set_inputs[3][0]);
    printf("\nsemidebug training_set_outputs[3]: %lf", training_set_outputs[3] );

    printf("\n The output is currently %lf \n", DOToutput5);





    cout << "Press enter to exit..." << endl;
    cin.get();





    return 0;
}

// ref:   medium.com/technology-invention-and-more/how-to-build-a-simple-neural-network-in-9-lines-of-python-code-cc8f23647ca1
// A.I. / Neural Network crude example