TMVA::GeneticPopulation

 Constructor

 create a Population of individuals with the population size given
 in the parameter
--> every coefficient gets a random value within the constraints
 provided by the user

 allows to connect two populations (using the same number of coefficients
 with the same ranges) 
 this allows to calculate several populations on the same phase-space
 or on different parts of the same phase-space and combine them afterwards
 this improves the global outcome.

 after adding another population or givingHint, the true size of the population
 may be bigger than the size which was given at createPopulation
 trimPopulation should be called (if necessary) after having checked the 
 individuals fitness with calculateFitness

 does what the name says,... it creates children out of members of the
 current generation
 children have a combination of the coefficients of their parents

 this function takes two individuals and produces offspring by mixing (recombining) their
 coefficients

 produces offspring which is are mutated versions of their parents
 Parameters:
         double probability : gives the probability (in percent) of a mutation of a coefficient
         bool near : if true, the mutation will produce a new coefficient which is "near" the old one
                     (gaussian around the current value)
         double spread : if near==true, spread gives the sigma of the gaussian
         bool mirror : if the new value obtained would be outside of the given constraints
                    the value is mapped between the constraints again. This can be done either
                    by a kind of periodic boundary conditions or mirrored at the boundary.
                    (mirror = true seems more "natural")

 mutates the individuals in the genePool
 Parameters:
         double probability : gives the probability (in percent) of a mutation of a coefficient
         int startIndex : leaves unchanged (without mutation) the individuals which are better ranked
                     than indicated by "startIndex". This means: if "startIndex==3", the first (and best)
                     three individuals are not mutaded. This allows to preserve the best result of the 
                     current Generation for the next generation. 
         bool near : if true, the mutation will produce a new coefficient which is "near" the old one
                     (gaussian around the current value)
         double spread : if near==true, spread gives the sigma of the gaussian
         bool mirror : if the new value obtained would be outside of the given constraints
                    the value is mapped between the constraints again. This can be done either
                    by a kind of periodic boundary conditions or mirrored at the boundary.
                    (mirror = true seems more "natural")

 adds a new coefficient to the individuals. 
 Parameters:
          double from : minimum value of the coefficient
          double to : maximum value of the coefficient

 gives back the "Genes" of the population with the given index.

 gives back the calculated fitness of the individual with the given index
 (after the evaluation of the fitness ["calculateFitness"] index==0 
 is the best individual.

 delete the results of the last calculation of the fitnesses of the
 population.
 (to prepare a new Generation)

 get the Genes of where an internal pointer is pointing to in the population

 gives back the currently calculated fitness

 prepare for a new generation

 set the fitness of "g" to the value "fitness". 
 add==true indicates, that this individual is created newly in this generation
 if add==false, this is a reavaluation of the fitness of the individual.

 if there is some good configuration of coefficients one might give this Hint to
 the genetic algorithm. 
 Parameters:
       vector< double > hint : is the collection of coefficients
       double fitness : is the fitness this collection has got

 make a little printout of the individuals up to index "untilIndex"
 this means, .. write out the best "untilIndex" individuals.

 make a little printout to the stream "out" of the individuals up to index "untilIndex"
 this means, .. write out the best "untilIndex" individuals.

 give back a histogram with the distribution of the coefficients
 parameters:
          int bins : number of bins of the histogram
          int min : histogram minimum 
          int max : maximum value of the histogram

 gives back all the values of coefficient "varNumber" of the current generation

 destructor