Net.h

#pragma once
 
#include <stdio.h>
#include <assert.h>
#include <iostream>
#include <ctgmath>
#include <cstdlib>
#include <cstdio>
#include <cassert>
#include <fstream>
#include <iostream>
#include <math.h>
#include <fstream>
#include <iostream>
#include <string>
#include <numeric>
#include <vector>
 
#include "Layer.h"
 
class Net {
 
public:
 
    Net(const int _nLayers,
        const int * const _nNeurons,
        const int _nInputs,
        const int _subject,
        const string _trial);
 
    ~Net();
 
    void initNetwork(Neuron::weightInitMethod _wim, Neuron::biasInitMethod _bim, Neuron::actMethod _am);
    
    void setLearningRate(double _w_learningRate, double _b_learningRate);
    
    void setInputs(const double *_inputs, const double scale = 1.0, const unsigned int offset = 0, const int n = -1);
    void propInputs();
 
    void propErrorBackward();
 
 
    void setError(double _leadError);
 
    double getGradient(Layer::whichGradient _whichGradient);
 
    void updateWeights();
 
    Layer *getLayer(int _layerIndex);
    double getOutput(int _neuronIndex);
    double getSumOutput(int _neuronIndex);
 
    int getnLayers();
    int getnInputs();
 
    double getWeightDistance();
 
    double getLayerWeightDistance(int _layerIndex);
    double getWeights(int _layerIndex, int _neuronIndex, int _weightIndex);
 
    int getnNeurons();
 
    void saveWeights();
    void snapWeights(string prefix, string _trial, int _subject);
    void snapWeightsMatrixFormat(string prefix);
    void printNetwork();
 
private:
 
    int nLayers = 0;
    int nNeurons = 0;
    int nWeights = 0;
    int nInputs = 0;
    int nOutputs = 0;
    double w_learningRate = 0;
    Layer **layers = 0;
    const double *inputs = 0;
    double leadForwardError = 0;
    double theLeadError = 0;
    int midLayerIndex = 0;
    double theLeadMidError = 0;
    double *errorGradient = NULL;
    double globalError = 0;
    double echoError = 0;
    double theLeadLocalError = 0;
};