//BackPropagation is incharge of recomputing weights and values based on the output (learning from previous values)
void NeuralNetwork::backPropogation(){
   //variables and containers for poth parts
   double oldWeight;                                //holds value of old weight for a given matrix index at row r and column c
   double dVal;                                    //holds value for the change in weight for a given index in matrix
   double newVal;                                    //Holds the computed new value for a given index in the newWeights matrix

    vector<MatrixForNN *> updatedWeights;            //this vector stores the updated weights for the NN that are found via back propogation
   
   MatrixForNN *deltaW;                            //holds the change in weight
   MatrixForNN *gradients;                            //holds the change in gradients
   MatrixForNN *L;                                    //holds activated values of current left layer
   MatrixForNN *newWeights;                        //holds values of the new weights computed using deltaW and other values
                                         
   //============================================================
   //PART 1 of back propogation: output layer-> last hidden layer
   //Since it is the output layer involved, it has to be treated slightly different than if it was just hidden layers

    //variables and weights for Part 1 only
   int outIndex = mapOfNN.size() - 1;    //get output layer's index
   double error;                                    // Value of how much error was made
   double output;                                    //the actual output value
   double gradient;                                //the gradient value (found by: error*output)
   
   MatrixForNN *derivedVals;                        //value of derived outputs at output layer
   MatrixForNN *Gt;                                //transposed gradients matrix (used for finding delta weights)

    // create a matrix for the change in weights, a matrix of gradients, and a matrix of derived values

    //create the new matrix for gradients
   //gradient is 1 row and columns = the amount of nodes in output layer 
   

    gradients = new MatrixForNN(1, mapOfNN[outIndex], false);

    //need derived values at the output layer
   //create a new matrix for derived values
   derivedVals = layersOfNN[outIndex]->calculateMatrixDerived();

    //to get the gradients: G=derivedValues*derivedErrors (by column index)
   for (int c = 0; c < mapOfNN[outIndex]; ++c) {
       error = derivedErrorValues[c];
       output = derivedVals->getOneMatrixValue(0, c);
       gradient = error * output;

        gradients->setMatrixValue(0, c, gradient);
   }

    //to get the gradient weights, it is a transpose of the actual gradients with the output of the last hidden layer
   //delta values =transpose(Gt* L), where Gt is the transpose of gradients and L is the last hidden layer's output    
   //the transpose of (Gt*L) is done later in the loop
   L = layersOfNN[outIndex - 1]->calculateMatrixActivated();
   Gt = gradients->transposeMatrix();

    //create new matrix for the delta weights
   deltaW = new MatrixForNN(Gt->getNumberOfRows(), L->getNumberOfColumns(), false);

    MatrixMultiplication(Gt, L, deltaW);

    //Now we can start working towards figuring out the new weights that should be applied to the edges between the hidden layer and the output layer 
   //rows = same as last hidden layer, columns = same as the output layer, values are set by these two values, so we do not want randomizing
   newWeights = new MatrixForNN(mapOfNN[outIndex-1], mapOfNN[outIndex],false);

    //now set the new weights by looping through rows of hidden layer and columns of output layer
   for (int r = 0; r < mapOfNN[outIndex - 1]; ++r) {
       for (int c = 0; c < mapOfNN[outIndex]; ++c) {
           //set values of the new weights by taking the old weight values, delta values, learning rate, and momentum
           //new weight = (oldweight*momentum)-(learning rate* delta value)
           oldWeight = allWeightMatrices[outIndex - 1]->getOneMatrixValue(r, c);
           dVal = deltaW->getOneMatrixValue(c, r);        //acts as the transpose(gt*L) by switching colum and row element by element

            oldWeight = momentum * oldWeight;
           dVal = rateOfLearning * dVal;

            newVal = oldWeight - dVal;

            newWeights->setMatrixValue(r, c, newVal);
       }
   }
   updatedWeights.push_back(new MatrixForNN(*newWeights)); 

    //delete values that we need to reinstantiate to (don't want floating pointers)
   delete L;
   delete deltaW;
   delete newWeights;
   //===================================================================================
   //part 2 of back propogation last hidden layer -> input layer

    // variables and containers used in part two of back propogation
   double grad;                                    //value of gradient at a given index in matrix (value is recomputed)

    MatrixForNN *Gp;                                //holds value of gradients for the previous layer (Gp= gradients previous)
   MatrixForNN *PrevWT;                            //holds the values of the transpose of the previous weights
   MatrixForNN *LastHiddenLayer;                    //holds derived output values of the last hidden layer (used for finding gradient values in this part)
   MatrixForNN *TransposedL;                        //holds the transposed version of L (needed to find deltaW in this part)

    //for this half of back propogation, there needs to be a Gp(gradients previous), which is the previous iteration's gradients (gradients to the right)-> aka, 
   //if looking at hidden layer->input layer, the Gp= the gradients for output -> hidden layer
   //these gradients will be used to find the change in weights for this section by : deltaWeights= X_transposed*New_gradients, where X is the layer on the Left (in the case of a single layer, this is the input layer)

    //loop through layer positions from last hidden layer to input layer for a single layer network, this is only one loop)
   for (int index = outIndex - 1; index > 0; --index) {
       Gp= new MatrixForNN(*gradients);
       delete gradients;                                                                //clear current pointer to gradients, since it is going to point to a new matrix

        // to get the new gradients: G= (gp* transpose(previousWeights))X LastHiddenLayer's Output
       PrevWT = allWeightMatrices[index]->transposeMatrix();

        //create a new matrix for gradients that has previous gradients row size, and the transposed previous weight columns
       gradients = new MatrixForNN(Gp->getNumberOfRows(), PrevWT->getNumberOfColumns(), false);

        //do the multiplication of gp and transposed weights
       MatrixMultiplication(Gp, PrevWT, gradients);

        //make a matrix for the last hidden layer's outputs (part of the equation)-> because we want outputs, we are working with derived values
       LastHiddenLayer = layersOfNN[index]->calculateMatrixDerived();
       
       //cross the new gradient matrix with the output of the last hidden layer in order to do the last part of the equation
       // gradients = (gp* prevWeightsTransposed)*LastHiddenLayerOutput -> right now have the gp*PWTrans, but don't have the Last Hidden layer
       for (int c = 0; c < LastHiddenLayer->getNumberOfRows(); ++c) {
           grad = gradients->getOneMatrixValue(0, c)* LastHiddenLayer->getOneMatrixValue(0, c); //calculate (gp* prevWeightsTransposed)*LastHiddenLayerOutput
           gradients->setMatrixValue(0, c, grad); //set new gradient value G
       }
       
       //to get the new weights for this section of back propogation, need to multiply gradient matrix by transpose of  left layer's outputs 
       //(in this case, the input layer's, since there is only a single hidden layer)-> reusing L for this
       //check to make sure that we are not in the input layer (if we are we cannot get values for the left layers (there are no more layers)
       //-> basically want to stop at the first hidden layer and make L= input layer. Don't want to look for L in input layer
       if (index = 1) {
           L = layersOfNN[0]->calculateMatrixRaw();            //back at input layer, so want the raw values that were input
       }else {
           L = layersOfNN[0]->calculateMatrixActivated();        //all other layers (assuming there was more than 1 hidden layer) should be set to activated values, not raw, because it is in the hidden layers.
       }

        //Now that L has been updated to the proper level, to get the new weights, the transposed version of this value is needed (dW= gradient * LayerOutputsTransposed)
       TransposedL = L->transposeMatrix();
       
       //make new deltaW matrix-> reuse deltaW matrix for the weights from hiddent to input as well
       deltaW = new MatrixForNN(TransposedL->getNumberOfRows(), gradients->getNumberOfColumns(), false);    

        //now can get the new weights via matrix multiplication
       MatrixMultiplication(TransposedL, gradients, deltaW);

        //now update the weights the same way that was done for the output->last hidden layer section
       newWeights = new MatrixForNN(allWeightMatrices[index-1]->getNumberOfRows(),allWeightMatrices[index-1]->getNumberOfColumns(), false);

        //set the new weights 
       for (int r = 0; r <newWeights->getNumberOfRows(); ++r) {
           for (int c = 0; c < newWeights->getNumberOfColumns(); ++c) {
               //set values of the new weights by taking the old weight values, delta values, learning rate, and momentum
               //Note: new weight = (oldweight*momentum)-(learning rate* delta value)
               oldWeight = allWeightMatrices[index-1]->getOneMatrixValue(r, c);
               dVal = deltaW->getOneMatrixValue(r, c);

                oldWeight = momentum * oldWeight;
               dVal = rateOfLearning * dVal;

                double newVal = oldWeight - dVal;

                newWeights->setMatrixValue(r, c, newVal);
           }
       }
       updatedWeights.push_back(new MatrixForNN(*newWeights)); 

    }

    //cleanup Stage
   //the matrices that have been pushed into updatedWeights backwards, so this needs to be fixed
   //the updatedWeights vector will be applied to the AllWeightMatrices vector in the class, so the current pointers in that vector need to be deleted before being over written
   //also need to take care of deleting all Matrix pointers that were used. 

    //clear current weight matrices that are saved in the vector that is a member variable of NN class 
   for (int i = 0; i < allWeightMatrices.size(); ++i) {
       delete allWeightMatrices[i];
   }
   //clear/ empty the vector now that all pointers were dealt with
   allWeightMatrices.clear();

    //reverse the order of the weight matrices in the vector so that they are going from beginning of NN to end (instead of vice versa)
   std::reverse(updatedWeights.begin(), updatedWeights.end());

    //Now these values can be pushed into allWeightMatrices and the pointer in UpdatedWeights can be deleted
   for (int i = 0; i < updatedWeights.size(); ++i) {
       allWeightMatrices.push_back(new MatrixForNN(*updatedWeights[i])); //push new matrix to AllWeightMatrices based on matrix in updatedWeights
       delete updatedWeights[i];
   }

    delete deltaW;
   delete gradients;
   delete L;
   delete newWeights;

    delete derivedVals;
   delete Gt;
}