Some parts of the code are now obsolete and the genetic algorithm does not work with with different types of chromossome, that's my goal from now on.

The individual, instead of being a vector of values, is a vector of AbstractGene. Each entry of the vector is a gene, of any type supported (binary, integer and float). Now the individual can have different types of genes.

Already did some testing regarding mutations of any gene, and they're working fine. Now the issue are the crossover and selection
functions, since there's one per Genetic Algorithm run. Need to think better on wht'a best and more efficient.

Started debugging the entire code, created a new file just for the structures and some other global code.
Have to test the selection function

Changed the way the fitting tolerance is calculated, since it was giving some weird results, now it's simpler.
Changed the infinite while loop for a for loop to be able to parallelize it in the future.

The FloatGene has already been tested and works fine. Now I have to start building parallel code.

…ADME to add the functions and behaviours created.

Finally fixed the problem regarding the parent population being also updated during crossovers, forgot that,
for structures, a `copy` is not enough, a `deepcopy` was needed.

…by the Crossover structure

Finally finished the first prototype for parallelizing the Genetic Algorithm using DistributedArrays package.
It works quite well, but now it needs to be modified to be able to use piping for communication with external programs.

General

Now communication through FIFOs works using parallel computation.
For non-parallel computation it does not work because the pipes must be launched in separate processes.

The previous prototype was quite slow due to using remote channels and the pipe reading not being made
in the process it was running. Now the remote channels are gone and the pipe reading and the objective
function are determined in the same process, which is much more efficient and faster.

When not using external programs the GA code worls well with both computers connected, now I have to figure out out to
run properly using external programs

Now the GA is capable of spawning the calculations inside a cluster. There are a lot of limitations and the package cannot do that on its own, but I'll create some scripts to do that, since there are several limitations regarding the number of processes needed to run external programs

General

There was a problem regarding the creation of the backup folder in external computers. Now it is fixed and the backup process works in a cluster as well.

…el runs of the Genetic Algorithm

For each iteration the objective function was being calculated 2*N times (parents+offspring). The thing is that N calculations were already performed in the previous iteration, so only the offspring needs to be evaluated in each iteration.

Since most of the optimization problems, before starting the actual optimization runs, need to run some initialization scripts/functions, this function was created to ease the pain of those initializations.

For a long time there was an issue with the fitness array in the parallel calculation function. For some reason said function was not modifying the fitness vector in-place. Now that bug is finally fixed.

Now the output of the genetic algorithm is a structure.
Now the output is much more complete and more organized to be easily used in post-optimization calculations.

Backup

Before this branch the variable boundaries were checked inside the objective function, returning an Inf value when they were not inside boundaries. This was not ideal, since some individuals did not have a chance to improve in further iterations because they were automatically discarded.
Now the boundary checking is made inside the mutation functions. In this way, all the individuals have genes that respect the boundaries, reducing the number of objective function evaluations that would be Inf.

The only thing that was missing regarding the insertion of boundary values in FloatGene and IntegerGene types was the backupo of said values. Now the backup and reverse_backup functions already have the functionality of saving the boundary values in the backup files and in the population variable, respectively.

Before this update boundary checking was performed AFTER the new variables were saved in the gene vector, which made it much more difficult to have new values inside boundaries.
In this update, boundary checking is made BEFORE new values are saved, drastically increasing the probability of having new values inside boundaries.

Bounds