Neural Nets + Genetic Algorithms Help

[Memester]

I wrote some code for neural networks to learn the XOR function and it works fine. I am not trying to make a neural network that can classify water as a solid liquid or gas. While looping through the generations the program will crash and return 255. I have tested each function individually and everything appears to work fine. There appears to be a limit on how many times it loops and I cant pinpoint the error. I assume that there is something fundamentally wrong with my programming style so any tips will be much appreciated.

 #include <iostream>
#include <stdlib.h>
#include <ctime>
#include <cmath>
#define Ntrain 59
#define inputs 3
#define hidden 5
#define outputs 3
#define POP 19


using namespace std;

float randFloat(); ///declaring functions
float Sigmoid(float A);

class NeuralNet
{
public:
    NeuralNet()
    {
        ///assigning values to each weight
        for(int i = 0; i < hidden-1 ; i++)
        {
            for(int j = 0; j < inputs ;  j++)
            {
                weights1[i][j] = randFloat();
            }
        }
        for(int i = 0; i < outputs ; i++)
        {
            for(int j = 0; j < hidden ;  j++)
            {
                weights2[i][j] = randFloat();
            }
        }
    }
    float feedForward(int trainingIndex)
    {
        float hiddenNeuronSum[hidden-1]; ///sum of imputs to each node in hidden layer
        for(int i = 0 ;  i  < hidden-1 ;  i ++)///for each hidden neurone
        {
            hiddenNeuronSum[i] = 0;
            for(int j = 0; j < inputs ; j ++ ) ///for each weight
            hiddenNeuronSum[i] = hiddenNeuronSum[i] + (weights1[i][j])*(training[trainingIndex][j]);
        }

        for(int i = 0 ;  i < hidden-1 ; i++) ///sigmoid it
        {
            hiddenNeuronSum[i] = Sigmoid(hiddenNeuronSum[i]);
        }
        ///pass onto next layer
        float outputNeuronSum[outputs];
        for(int i = 0; i < outputs ;  i ++)///for each output
        {
            outputNeuronSum[i] = 0;
            for(int j  = 0;  j  < hidden-1 ; j ++)///for each neurone in hidden layer
            {
                outputNeuronSum[i] = outputNeuronSum[i] + (weights2[i][j])*(hiddenNeuronSum[j]);
            }
            outputNeuronSum[i] = outputNeuronSum[i] + weights2[i][hidden-1];
        }


        for(int i = 0;  i < outputs ; i ++)
        {
            outputNeuronSum[i] = Sigmoid(outputNeuronSum[i]);
        }///sigmoid it again

        float error =  0;
        for(int i = 0;  i < outputs ;  i ++)
        {
            error = error + abs(training[trainingIndex][i+3] - outputNeuronSum[i]); ///calculate the error from each output node
        }
        return error;
    }
    float getError() ///returns error
    {
        return totalerror;
    }
    void calculateError() ///calculates each error from each output using training set
    {
        totalerror = 0;
        for(int i = 0  ;  i < Ntrain ;  i ++)
        {
            totalerror = totalerror + feedForward(i);
        }
    }
    void setScore(int score) ///sets fitness score
    {
        fitnessScore = score;
    }
    
    friend void crossOver(NeuralNet a, NeuralNet b, NeuralNet &c);
    friend void transferGenes(NeuralNet a, NeuralNet &b);
    int getScore()
    {
        return fitnessScore;
    }
private:
    float weights1[hidden-1][inputs]; ///weights in layer one
    float weights2[outputs][hidden]; ///weights in layers two
    float totalerror; 
    int fitnessScore; 
    float training[Ntrain][6] = {
    ///{Bias, log(Pa), Kelvin *10^-2, S, L ,G} the error is calculated using the last 3 values
    {1, 5.0, 2.5, 1.0, 0, 0} ,
    {1, 7.0, 3.15, 0, 1.0, 0} ,
    {1, 3.0, 4.76, 0, 0, 1.0},
    //3

    ///solids
    {1, 7.0, 2.0, 1.0, 0, 0},
    {1, 7.0, 2.5, 1.0, 0, 0},
    {1, 6.0, 1.5, 1.0, 0, 0},
    {1, 6.0, 2.5, 1.0, 0, 0},
    {1, 5.0, 1.5, 1.0, 0, 0},
    {1, 5.0, 2.0, 1.0, 0, 0},
    {1, 4.0, 2.0, 1.0, 0, 0},
    {1, 4.0, 2.5, 1.0, 0, 0},
    {1, 3.0, 1.5, 1.0, 0, 0},
    {1, 3.0, 2.5, 1.0, 0, 0},
    {1, 2.0, 2.0, 1.0, 0, 0},
    {1, 2.0, 2.5, 1.0, 0, 0},
    {1, 1.0, 1.5, 1.0, 0, 0},
    {1, 1.0, 2.0, 1.0, 0, 0},
    {1, 1.0, 2.5, 1.0, 0, 0},

//15
    ///liquids

    {1, 1.0, 2.5, 0, 1.0, 0},
    {1, 1.0, 3.0, 0, 1.0, 0},
    {1, 1.0, 3.5, 0, 1.0, 0},
    {1, 1.0, 4.5, 0, 1.0, 0},
    {1, 1.0, 5.0, 0, 1.0, 0},
    {1, 2.0, 3.0, 0, 1.0, 0},
    {1, 2.0, 3.5, 0, 1.0, 0},
    {1, 2.0, 4.0, 0, 1.0, 0},
    {1, 2.0, 4.5, 0, 1.0, 0},
    {1, 2.0, 2.8, 0, 1.0, 0},
    {1, 3.0, 3.0, 0, 1.0, 0},
    {1, 3.0, 3.5, 0, 1.0, 0},
    {1, 3.0, 4.0, 0, 1.0, 0},
    {1, 3.0, 4.5, 0, 1.0, 0},
    {1, 3.0, 5.0, 0, 1.0, 0},
    {1, 4.0, 3.0, 0, 1.0, 0},
    {1, 4.0, 3.3, 0, 1.0, 0},
    {1, 4.0, 4.0, 0, 1.0, 0},
    {1, 4.0, 4.5, 0, 1.0, 0},
    {1, 4.0, 5.0, 0, 1.0, 0},
    {1, 5.0, 4.0, 0, 1.0, 0},
    {1, 5.0, 4.5, 0, 1.0, 0},
    {1, 5.0, 3.8, 0, 1.0, 0},
    {1, 5.0, 5.0, 0, 1.0, 0},
    {1, 6.0, 4.7, 0, 1.0, 0},
    {1, 6.0, 5.0, 0, 1.0, 0},
    {1, 7.0, 6.0, 0, 1.0, 0},
    //27
    ///gas
    {1, 3.0, 2.8, 0, 0, 1.0},
    {1, 4.0, 3.0, 0, 0, 1.0},
    {1, 5.0, 2.8, 0, 0, 1.0},
    {1, 5.0, 3.5, 0, 0, 1.0},
    {1, 6.0, 3.0, 0, 0, 1.0},
    {1, 6.0, 3.5, 0, 0, 1.0},
    {1, 6.0, 4.0, 0, 0, 1.0},
    {1, 6.0, 4.5, 0, 0, 1.0},
    {1, 7.0, 2.8, 0, 0, 1.0},
    {1, 7.0, 3.5, 0, 0, 1.0},
    {1, 7.0, 4.0, 0, 0, 1.0},
    {1, 7.0, 4.5, 0, 0, 1.0},
    {1, 7.0, 5.0, 0, 0, 1.0},
    {1, 7.0, 5.8, 0, 0, 1.0},
    //14
    };
};
int chooseParent(NeuralNet Population[POP]);

int main()
{
    srand(time(0));

    NeuralNet Population[POP];
    NeuralNet Children[POP];
    int nextgen =1; ///using nextgen to test if the loop is working
    while(nextgen == 1){
    for(int i =  0 ; i < POP ; i ++)
    {
        Population[i].calculateError();
    }
    for(int i = 0 ; i < POP ;  i++)
    {
        int A = chooseParent(Population);
        int B = chooseParent(Population);
        crossOver(Population[A], Population[B], Children[i]);
    }
    for(int i =0 ; i < POP ; i ++)
    {
        transferGenes(Children[i], Population[i]);
    }
    nextgen = 0;
    cin >> nextgen;
    cin.ignore();
    }



    return 0;
}

void transferGenes(NeuralNet a, NeuralNet &b) //transfer weights from a to b
{
    for(int i = 0; i < hidden-1 ; i++)
        {
            for(int j = 0; j < inputs ;  j++)
            {
            b.weights1[i][j] = a.weights1[i][j];
            }
        }


    for(int i = 0; i < outputs ; i++)
        {
            for(int j = 0; j < hidden ;  j++)
            {
                b.weights2[i][j] = a.weights2[i][j];
                }
            }
}


void crossOver(NeuralNet a, NeuralNet b, NeuralNet &c) ///crossover
{
    int random;
    for(int i = 0; i < hidden-1 ; i++)
        {
            for(int j = 0; j < inputs ;  j++)
            {
                random = rand()%2;
                if(random ==  1)
                {
                    c.weights1[i][j] = a.weights1[i][j];
                }else{
                c.weights1[i][j] = b.weights1[i][j];
                }
            }
        }

    for(int i = 0; i < outputs ; i++)
        {
            for(int j = 0; j < hidden ;  j++)
            {
                random = rand()%2;
                if(random ==  1)
                {
                    c.weights2[i][j] = a.weights2[i][j];
                }else{
                c.weights2[i][j] = b.weights2[i][j];
                }
            }
        }
}

int chooseParent(NeuralNet Population[POP]) ///using probability to select parents
{
    int greatestError = Population[0].getError();
    for(int i =1 ; i < POP ;  i++)
    {
        if(Population[i].getError() > greatestError)
            greatestError = Population[i].getError();
    }
cout << greatestError << endl;
    int totalFitness = 0;

    for(int i =0 ; i < POP; i++)
    {
      Population[i].setScore(greatestError +1 - Population[i].getError());
      totalFitness = totalFitness + Population[i].getScore();
    }

    int random = rand()%totalFitness +1;
    int parentSelector = 0;
    int parentIndex;
    for(int i=0; parentSelector<random;i++)
    {
        parentSelector = parentSelector + Population[i].getScore();
        parentIndex = i;
    }


    return parentIndex;
}

float randFloat()
{
    float f = static_cast <float> (rand()) / (static_cast <float> (RAND_MAX));
    int Pos_or_Neg = rand()%2;
    if(Pos_or_Neg)
    {
        return f;
    }else{
    return -f;
    }
}

float Sigmoid(float A)
{
    return 1/(1+exp(-A));
}