Added inputLayer class

This class initialises an input layer and holds the input neuron values.
Other functions can then access and set the input neuron values through
this class. This class was just proof of concept, to make sure I
understood how to move from procedural to object oriented programming,
from here I can now add class for the other layers, weight, errors, etc,
with the aim of making the program as modular and parameterised as
possible.  Once I have achieved this it will just be a matter of
programming interfaces and tweaking the network settings.
Two Changes

I'm going to commit two changes here, which is probably bad form as far
as version control goes, but it all works.

The first changes I've made is to add the files, 'Network.cpp' and
'Network.h', these files are going to contain the information about the
classes from now on. I'm gradually going to move all the functions
currently in 'main.cpp' over to separate files to stop it getting
cluttered.

The second change I've made is to add a hiddenLayer class, and write it
in to the main code. However it occurred to me whilst I was writing it
that I  only actually need one layer class, and just create many
instances of the same class. I'm going to keep going with the way I'm
doing it now, but this should be implemented in future.
Added outputLayer class

The outputLayer class was output, so now all the neuron values are
stored in class. I had some more thoughts on how to implement all the
layers as multiple instances of one class, I need to add an additional
parameter to the constructor, just a boolean, so that the addition of a
bias neuron is true or false.

The next thing I need to do is create the classes which hold all the
errors. This is probably going to be slightly more complicated as the
change to object oriented is going to be slightly more radical. I'm
going to move to creating all errors as instances of one error class.
Added weights class

Weights are now contained in a class in a similar way to layers, however
unlike the layer class, there is only one type of weights class, which
is how the layer class should of been implemented, but now it must be
changed in a later version.

Now I need to make a training class, which I think I'm going to set up
as a different *.cpp and *.h file, so that when I have different types
of trainers, networks, and neurons, everything will be collect together.
Removed garbage comments

I've removed all the garbage comments that have been left in the code so
that I don't get confused with what I've changed and what I haven't
changed.
Trainer added

I added the trainer class so that training methods could now be moved
together into one file, in an effort to make it more modular. As I'm
doing this in a gradual way, things can probably be cut down later on,
as I predict there will not be a lot of use for the get and set methods
contained within the trainer class.
Moved layer calculations

The layer calculation has been moved from a function from the main
program, to being contain within the layer class. The compiler had to be
told that the weights class existed in the Network.h file in order to
avoid a circular dependency issue. Next I need to move the update
weights class to within the weights function.
Moved weight update

The weight update is now contained within the weight class.
The ugliest code ever

Okay, to pass the training data to the backpropagation class I have had
to do it in a very ugly way. There is no double a better way to do this,
but I want to keep moving on with this and sort it out at a later date.
Pretty much there

I believe that all of the network code is now object-oriented. The code
that isn't is all for data input, which I suppose could be changed to
object-oriented fairly quickly. What I need to do know is find out how
to pass arrays as parameter to instances, instead of the ugly code, and
then start tiding everything up, like getting rid of all the checking
functions I wrote when developing the original program. I think I'll
just move them into a seperate C++ file, and just not include it in the
project,  but still in the git repository.
Got rid of the ugly code, almost

The function now accepts an array of arrays, now that the constants are
in a shared header file.
Removed Header.h

Exactly what it says on the tin.
Major

This is a major commit.

First, I wrote all the input and outputs to *.csv files. This allowed me
to create the dataIO class which reads the *.csv files into the input
and output arrays. Made a small error in the dataIO class which isn't
much of a problem as it still works, but the array dimensions are the
wrong way round to the rest of the code. Currently the amount of inputs
and outputs are defined in the function arguments, but given that I have
a specified a maximum number of inputs, in future I could just have the
number of inputs and outputs determined by if the input and output files
are there are not, as I have created an input output file specification
as well.

The dataIO class was then integrated into the main code, the idea behind
this is that I should just be able to pass the dataIO object to the
trainer, and the trainer will do the training loop rather than in the
main code. As the trainer class will be able to access the input/output
arrays from the dataIO class.

For now, passing the outputs to the trainer class works, but now I need
to make it work for the inputs, then I will be able to get rid of the
training loop by moving it inside the trainer class.
Clean up

Removed more now-unused functions from the main function to the junk
functions file, it is unlikely they'll be needed again.
Almost got rid of training loop

Have finally moved everything within the training loop into classes, the
training loop can now be moved within the class as well.
No more training loop

Now that the training loop is no longer there, the code is nearly fully
object-oriented. There is now a few things I can do:

Move the user interface parts to within the dataIO class, I guess it
covers that area. That should mean that the main function will be
completely free of other functions.

Reorganise the trainer file, I should probably change the name of the
class to something better, move the parameter of 'errorsAndGradients'
so that there are declared when an instance of the trainer object is
called. The best way to probably do this is with pointers, but I can try
it with both ways to see if it works differently.

I need to change the dataIO class so that it stops reading from a file
if the amount of data has gone beyond the MAX_DATA_LENGTHS, and make
sure that doubles can be read from the *.csv files.

Then I need to do some pretty big changes to the trainer class so that
it writes out information on the training, validation etc. And also make
it so that it has other stopping parameter rather than just putting in
the number of iterations to do.

The aim of all this is to change the code that it can train over the
same data set many times (each time is also know as an epoch, and for
that matter I need to be able to set the size of the epoch) before the
training parameters decide that it has trained enough for a simulation.
Fully object-oriented

The code is now fully object-oriented. I moved most of the additional
functions in the main function into the dataIO class, anything else that
was left in the main function got moved to the junk code file.