Created the dev branch, and started code

The files currently contain code for datasets. At the moment we can load
a dataset, and destroy it.

The loading function needs to be expanded to do more checks as we are
are allocating a lot of memory dynamically, but no checks are being done
to see if they are actually being allocated (i.e. != NULL)
Updated data loading function with malloc checks

loadData() was updated such that all instances of malloc were checked to
see if they returned NULL. If any do return NULL, code is present to free
any memory previously allocated in the function.
Added structures for neurons and networks

In addition, constants were added to the header for the learning
methods and the activation types. These can be expanded if more
methods and/or types are included at a later date.
Updated the README with the current aim ofd the library
Started functions for network use

Started functions which are used to run the network. Also started
a function to set the weights of the network.

Some comments were changed to more accurately reflect the sections
they describe.

Prototypes for functions available to the user were also added to
the header.
Fixed some build errors

Note: There are still warnings due to functions which have not been
written yet.
Finished initial versions of helper functions

The functions used to calculate a set of outputs from a single run
have been written, (but not yet tested). Preliminary compilation
shows no errors.

In addition, the makefile was updated to link the math library so
that exp() can be used for the sigmoid function.

The runNetwork(...) function still needs to be written.
Preliminary runNetwork function done

The runNetwork(...) function has been written such that a dataset
can be passed to the network and each member within the set will
be passed through the network.

In addition, code has been included which allows the function to
print the inputs and a combination of outputs, targets and errors
for each data member.

Again, the code compiles successfully, but has yet to be tested.

The next phase will be to implement code to build the network, followed
by the functions necessary to train the network.
Removed Redundant code, Added scaling function

During the allocation of memory for the dataset, there was a lot
of redundant code. This was removed in favour of a check system, where
failed allocations are held until a single point, rather than immediately
after each allocation.

The scaling function was also written. Due to the way data is presented
to the network, the dataset will now hold data which is scaled for
network use. Scaling wwill occur when the data is being put into the
dataset, or when it is being presented.
Added scaling to data loading and display

loadData was updated to include references to the scale(...) function
in the loading of inputs and targets.

Also, runNetworkOnce(...) was updated to include references to scale(...).
Almost finished the function to create the network

Need to finish allocating memory for each neuron, and include calls
to free.

Also, at this point, there should be sufficient structure to test
the library.
Neural Network test (eventually) successful

The makefile was updated to include the debugging flag during testing.
It will remain there until a neural network built with the library
can learn successfully.

The library code has been updated to correct minor mistakes in the
code (such as missing ; and brackets), and also to include functionality
which allows the network to be run on data.

A preliminary test with the XOR problem and a set of known weights and
results show that a network will behave as expected.

NOTE: This version is still buggy and not fully complete.