\section{EO Class List}
Here are the classes, structs, unions and interfaces with brief descriptions:\begin{CompactList}
\item\contentsline{section}{{\bf eo1Pt\-Bit\-Crossover} (Eo1Pt\-Bit\-Xover --$>$ classic 1-point crossover )}{\pageref{classeo1_pt_bit_crossover}}{}
\item\contentsline{section}{{\bf eo\-Aged$<$ Object $>$} (Eo\-Age is a template class that adds an age to an object.$\backslash$ Requisites for template instantiation are that the object must admit a default ctor and a copy ctor )}{\pageref{classeo_aged}}{}
\item\contentsline{section}{{\bf eo\-Algo$<$ EOT $>$} (This is a generic class for population-transforming algorithms )}{\pageref{classeo_algo}}{}
\item\contentsline{section}{{\bf eo\-Arithmetic\-Crossover} (Eo\-Hypercube\-Crossover --$>$ uniform choice in hypercube == arithmetical with different values for each coordinate )}{\pageref{classeo_arithmetic_crossover}}{}
\item\contentsline{section}{{\bf eo\-Assembled\-Fitness\-Average\-Stat$<$ EOT $>$} (Average fitness values of a population, where the fitness is of type eo\-Scalar\-Assembled\-Fitness )}{\pageref{classeo_assembled_fitness_average_stat}}{}
\item\contentsline{section}{{\bf eo\-Assembled\-Fitness\-Best\-Stat$<$ EOT $>$} (Fitness values of best individuum in a population, where the fitness is of type eo\-Scalar\-Assembled\-Fitness )}{\pageref{classeo_assembled_fitness_best_stat}}{}
\item\contentsline{section}{{\bf eo\-Atom\-Exchange$<$ Atom $>$} (A helper class for choosing which genes to exchange )}{\pageref{classeo_atom_exchange}}{}
\item\contentsline{section}{{\bf eo\-Average\-Stat$<$ EOT $>$} (Average fitness of a population )}{\pageref{classeo_average_stat}}{}
\item\contentsline{section}{{\bf eo\-Best\-Fitness\-Stat$<$ EOT $>$} (Best fitness of a population )}{\pageref{classeo_best_fitness_stat}}{}
\item\contentsline{section}{{\bf eo\-Best\-Select$<$ EOT $>$} (Eo\-Best\-Select: a selection method that always return the best (mainly for testing purposes) )}{\pageref{classeo_best_select}}{}
\item\contentsline{section}{{\bf eo\-BF$<$ A1, A2, R $>$} (Basic Binary Functor )}{\pageref{classeo_b_f}}{}
\item\contentsline{section}{{\bf Biased\-Node\-Selector} (A node selector that does a specified number of rounds ignoring terminals )}{\pageref{class_biased_node_selector}}{}
\item\contentsline{section}{{\bf eo\-Binary\-Functor\-Counter$<$ Binary\-Functor $>$} (Generic counter class that counts the number of times a binary function is used )}{\pageref{classeo_binary_functor_counter}}{}
\item\contentsline{section}{{\bf eo\-Bin\-Clone\-Op$<$ EOT $>$} (Binary clone: two operands, only the first could be modified )}{\pageref{classeo_bin_clone_op}}{}
\item\contentsline{section}{{\bf eo\-Bin\-Gen\-Op$<$ EOT $>$} (Wrapper for binop: here we use select method of {\bf eo\-Populator}{\rm (p.\,\pageref{classeo_populator})} but we could also have an embedded selector to select the second parent )}{\pageref{classeo_bin_gen_op}}{}
\item\contentsline{section}{{\bf eo\-Bin\-Op$<$ EOType $>$} (Binary genetic operator: subclasses {\bf eo\-Op}{\rm (p.\,\pageref{classeo_op})}, and defines basically the operator() with two operands, only the first one can be modified When defining your own, make sure that you return a boolean value indicating that you have changed the content )}{\pageref{classeo_bin_op}}{}
\item\contentsline{section}{{\bf eo\-Bit$<$ Fit\-T $>$} (Implementation of bitstring chromosome )}{\pageref{classeo_bit}}{}
\item\contentsline{section}{{\bf eo\-Bit\-Bit\-Flip} (Eo\-Bit\-Flip --$>$ changes 1 bit )}{\pageref{classeo_bit_bit_flip}}{}
\item\contentsline{section}{{\bf eo\-Bit\-Gx\-Over$<$ Chrom $>$} (Eo\-Bit\-Gx\-Over --$>$ Npts crossover when bistd::string considered as a std::string of binary-encoded genes (exchanges genes) Is anybody still using it apart from historians ??? :-) )}{\pageref{classeo_bit_gx_over}}{}
\item\contentsline{section}{{\bf eo\-Bit\-Inversion$<$ Chrom $>$} (Eo\-Bit\-Inversion: inverts the bits of the chromosome between an interval )}{\pageref{classeo_bit_inversion}}{}
\item\contentsline{section}{{\bf eo\-Bit\-Mutation$<$ Chrom $>$} (Eo\-Bit\-Mutation --$>$ classical mutation )}{\pageref{classeo_bit_mutation}}{}
\item\contentsline{section}{{\bf eo\-Bit\-Next$<$ Chrom $>$} (Eo\-Bit\-Next --$>$ next value when bitstring considered as binary value )}{\pageref{classeo_bit_next}}{}
\item\contentsline{section}{{\bf eo\-Bit\-Op\-Factory$<$ EOT $>$} ({\bf EO}{\rm (p.\,\pageref{class_e_o})} Factory )}{\pageref{classeo_bit_op_factory}}{}
\item\contentsline{section}{{\bf eo\-Bit\-Prev$<$ Chrom $>$} (Eo\-Bit\-Prev --$>$ previous value when bitstring treated as binary value )}{\pageref{classeo_bit_prev}}{}
\item\contentsline{section}{{\bf boolean\_\-generator} (The class boolean\_\-generator can be used in the STL generate function to easily generate random booleans with a specified bias )}{\pageref{classboolean__generator}}{}
\item\contentsline{section}{{\bf eo\-Boolean\-Generator} (The class eo\-Boolean\-Generator can be used in the STL generate function to easily generate random booleans with a specified bias )}{\pageref{classeo_boolean_generator}}{}
\item\contentsline{section}{{\bf eo\-Boolean\-Init} (The class eo\-Boolean\-Init can be used in the STL apply function to easily generate random booleans with a specified bias )}{\pageref{classeo_boolean_init}}{}
\item\contentsline{section}{{\bf eo\-Bool\-Flip} (Simple boolean mutation - to be used in generic eo\-Op's )}{\pageref{classeo_bool_flip}}{}
\item\contentsline{section}{{\bf eo\-Branch\-Mutation$<$ FType, Node $>$} (Eo\-Branch\-Mutation --$>$ replace a subtree with a randomly created subtree )}{\pageref{classeo_branch_mutation}}{}
\item\contentsline{section}{{\bf eo\-Breed$<$ EOT $>$} (Breeding: combination of selecting and transforming a population )}{\pageref{classeo_breed}}{}
\item\contentsline{section}{{\bf eo\-Cellular\-Easy\-EA$<$ EOT $>$} (The abstract cellular easy algorithm )}{\pageref{classeo_cellular_easy_e_a}}{}
\item\contentsline{section}{{\bf eo\-Check\-Point$<$ EOT $>$} (Eo\-Check\-Point is a container class )}{\pageref{classeo_check_point}}{}
\item\contentsline{section}{{\bf eo\-CMABreed$<$ Fit\-T $>$} (TODO, handle bounds )}{\pageref{classeo_c_m_a_breed}}{}
\item\contentsline{section}{{\bf eo\-CMAInit$<$ Fit\-T $>$} (TODO, handle bounds )}{\pageref{classeo_c_m_a_init}}{}
\item\contentsline{section}{{\bf eo\-Collapse\-Subtree\-Mutation$<$ FType, Node $>$} (Eo\-Collapse\-Subtree --$>$ replace a subtree with a randomly chosen terminal )}{\pageref{classeo_collapse_subtree_mutation}}{}
\item\contentsline{section}{{\bf eo\-Combined\-Continue$<$ EOT $>$} (Combined continuators - logical AND: Continues until one of the embedded continuators says halt! )}{\pageref{classeo_combined_continue}}{}
\item\contentsline{section}{{\bf eo\-Combined\-Init$<$ EOT $>$} (Combined INIT: a proportional recombination of {\bf eo\-Init}{\rm (p.\,\pageref{classeo_init})} objects )}{\pageref{classeo_combined_init}}{}
\item\contentsline{section}{{\bf eo\-Comma\-Replacement$<$ EOT $>$} (ES type of replacement strategy: ignore parents, truncate offspring )}{\pageref{classeo_comma_replacement}}{}
\item\contentsline{section}{{\bf eo\-Continue$<$ EOT $>$} (Termination condition for the genetic algorithm Takes the population as input, returns true for continue, false for termination )}{\pageref{classeo_continue}}{}
\item\contentsline{section}{{\bf eo\-Counted\-Dyn\-Update} (An {\bf eo\-Updater}{\rm (p.\,\pageref{classeo_updater})} to update an {\bf eo\-Updatable}{\rm (p.\,\pageref{classeo_updatable})} object every given tic )}{\pageref{classeo_counted_dyn_update}}{}
\item\contentsline{section}{{\bf eo\-Counted\-State\-Saver} (Eo\-Updater that saves a state every given generations )}{\pageref{classeo_counted_state_saver}}{}
\item\contentsline{section}{{\bf Cov} (Single covariance between two variates )}{\pageref{class_cov}}{}
\item\contentsline{section}{{\bf eo\-Ctrl\-CContinue$<$ EOT $>$} (Ctrl C handling: this {\bf eo\-Continue}{\rm (p.\,\pageref{classeo_continue})} tells whether the user pressed Ctrl C )}{\pageref{classeo_ctrl_c_continue}}{}
\item\contentsline{section}{{\bf eo\-Det\-Bit\-Flip$<$ Chrom $>$} (Eo\-Det\-Bit\-Flip --$>$ changes exactly k bits )}{\pageref{classeo_det_bit_flip}}{}
\item\contentsline{section}{{\bf eo\-Deterministic\-Sa\-DReplacement$<$ EOT $>$} (Eo\-Deterministic\-Sa\-DReplacement: replacement strategy that is just, in sequence saves best and kill worse from parents + saves best and kill worse from offspring + merge remaining (neither save nor killed) parents and offspring + reduce that merged population = returns reduced pop + best parents + best offspring )}{\pageref{classeo_deterministic_sa_d_replacement}}{}
\item\contentsline{section}{{\bf eo\-Deterministic\-Survive\-And\-Die$<$ EOT $>$} (An instance (theonly one as of today, Dec )}{\pageref{classeo_deterministic_survive_and_die}}{}
\item\contentsline{section}{{\bf eo\-Det\-Select$<$ EOT $>$} (Eo\-Det\-Select selects many individuals determinisctically )}{\pageref{classeo_det_select}}{}
\item\contentsline{section}{{\bf eo\-Det\-Tournament\-Select$<$ EOT $>$} (Eo\-Det\-Tournament\-Select: a selection method that selects ONE individual by deterministic tournament -MS- 24/10/99 )}{\pageref{classeo_det_tournament_select}}{}
\item\contentsline{section}{{\bf eo\-Det\-Tournament\-Truncate$<$ EOT $>$} (Truncate class based on a repeated deterministic (reverse!) tournament To be used in SSGA-like replacements (e.g )}{\pageref{classeo_det_tournament_truncate}}{}
\item\contentsline{section}{{\bf eo\-Det\-Tournament\-Truncate\-Split$<$ EOT $>$} (Reduce\-Split class based on a repeated deterministic (reverse!) tournament To be used in SSGA-like replacements (e.g )}{\pageref{classeo_det_tournament_truncate_split}}{}
\item\contentsline{section}{{\bf eo\-Det\-Tournament\-Worth\-Select$<$ EOT, Worth\-T $>$} (An instance of eo\-Select\-Perf2Worth that does selection from the Worthes using a .. )}{\pageref{classeo_det_tournament_worth_select}}{}
\item\contentsline{section}{{\bf eo\-Det\-Uniform\-Mutation$<$ EOT $>$} (Eo\-Det\-Uniform\-Mutation --$>$ changes exactly k values of the std::vector by uniform choice with range epsilon )}{\pageref{classeo_det_uniform_mutation}}{}
\item\contentsline{section}{{\bf eo\-Distance$<$ EOT $>$} (This is a generic class for distance functors: takes 2 things ane returns a double )}{\pageref{classeo_distance}}{}
\item\contentsline{section}{{\bf eo\-Distrib\-Updater$<$ EOT $>$} (Base class for Distribution Evolution Algorithms within {\bf EO}{\rm (p.\,\pageref{class_e_o})}: the update rule of distribution )}{\pageref{classeo_distrib_updater}}{}
\item\contentsline{section}{{\bf eo\-Distribution$<$ EOT $>$} (Abstract class for Distribution Evolution Algorithms within {\bf EO}{\rm (p.\,\pageref{class_e_o})}: the distribution itself )}{\pageref{classeo_distribution}}{}
\item\contentsline{section}{{\bf d\-Matrix} (A helper class for Sharing - to hold distances )}{\pageref{classd_matrix}}{}
\item\contentsline{section}{{\bf eo\-Dominance\-Map$<$ Eo\-Type $>$} (Eo\-Dominance\-Map, utility class to calculate and maintain a map (std::vector$<$std::vector$<$bool$>$ $>$) of pareto dominance statistics )}{\pageref{classeo_dominance_map}}{}
\item\contentsline{section}{{\bf eo\-Double\-Exchange} (Discrete crossover == exchange of values )}{\pageref{classeo_double_exchange}}{}
\item\contentsline{section}{{\bf eo\-Double\-Intermediate} (Intermediate crossover == linear combination )}{\pageref{classeo_double_intermediate}}{}
\item\contentsline{section}{{\bf eo\-Drawable$<$ Object $>$} (Eo\-Drawable is a template class that adds a drawing interface to an object.$\backslash$ Requisites for template instantiation are that the object must admit a default ctor and a copy ctor )}{\pageref{classeo_drawable}}{}
\item\contentsline{section}{{\bf Dummy} (Test program for the general operator - millenium version! uses dummy individuals )}{\pageref{struct_dummy}}{}
\item\contentsline{section}{{\bf eo\-Dyn\-SGATransform$<$ EOT $>$} (Eo\-Dyn\-SGATransform: transforms a population using genetic operators )}{\pageref{classeo_dyn_s_g_a_transform}}{}
\item\contentsline{section}{{\bf eo\-Dyn\-Updater} (A base class to actually update an {\bf eo\-Updatable}{\rm (p.\,\pageref{classeo_updatable})} object )}{\pageref{classeo_dyn_updater}}{}
\item\contentsline{section}{{\bf eo\-Easy\-EA$<$ EOT $>$} (An easy-to-use evolutionary algorithm; you can use any chromosome, and any selection transformation, merging and evaluation algorithms; you can even change in runtime parameters of those sub-algorithms )}{\pageref{classeo_easy_e_a}}{}
\item\contentsline{section}{{\bf eo\-EDA$<$ EOT $>$} (Eo\-EDA: Estimation of Distribution Algorithm within {\bf EO}{\rm (p.\,\pageref{class_e_o})} )}{\pageref{classeo_e_d_a}}{}
\item\contentsline{section}{{\bf eo\-Elite\-Sequential\-Select$<$ EOT $>$} (All Individuals in order )}{\pageref{classeo_elite_sequential_select}}{}
\item\contentsline{section}{{\bf eo\-Elitism$<$ EOT $>$} (Straightforward elitism class, specify the number of individuals to copy into new geneneration or the rate w.r.t )}{\pageref{classeo_elitism}}{}
\item\contentsline{section}{{\bf EO$<$ F $>$} (EO is a base class for evolvable objects, that is, the subjects of evolution )}{\pageref{class_e_o}}{}
\item\contentsline{section}{{\bf eo\-EPReduce$<$ EOT $>$} (EP truncation method (some global stochastic tournament + sort) Softer selective pressure than pure truncate )}{\pageref{classeo_e_p_reduce}}{}
\item\contentsline{section}{{\bf eo\-EPReplacement$<$ EOT $>$} (EP type of replacement strategy: first add parents to population, then truncate using EP tournament )}{\pageref{classeo_e_p_replacement}}{}
\item\contentsline{section}{{\bf eo\-Es\-Chrom\-Init$<$ EOT $>$} (Random Es-chromosome initializer (therefore derived from {\bf eo\-Init}{\rm (p.\,\pageref{classeo_init})}) )}{\pageref{classeo_es_chrom_init}}{}
\item\contentsline{section}{{\bf eo\-Es\-Full$<$ Fit $>$} (The most complex evolutionary strategy representation )}{\pageref{classeo_es_full}}{}
\item\contentsline{section}{{\bf eo\-Es\-Global\-Xover$<$ EOT $>$} (Gloabl crossover operator for ES genotypes )}{\pageref{classeo_es_global_xover}}{}
\item\contentsline{section}{{\bf eo\-Es\-Mutate$<$ EOT $>$} (ES-style mutation in the large )}{\pageref{classeo_es_mutate}}{}
\item\contentsline{section}{{\bf eo\-Es\-Mutation\-Init} (Initialize Mutation operator )}{\pageref{classeo_es_mutation_init}}{}
\item\contentsline{section}{{\bf eo\-Es\-Simple$<$ Fit $>$} (Simple Evolution Strategy )}{\pageref{classeo_es_simple}}{}
\item\contentsline{section}{{\bf eo\-Es\-Standard\-Xover$<$ EOT $>$} (Standard (i.e )}{\pageref{classeo_es_standard_xover}}{}
\item\contentsline{section}{{\bf eo\-Es\-Stdev$<$ Fit $>$} (Evolutionary Strategy with a standard deviation per parameter )}{\pageref{classeo_es_stdev}}{}
\item\contentsline{section}{{\bf eo\-Eval\-Continue$<$ EOT $>$} (Continues until a number of evaluations has been made )}{\pageref{classeo_eval_continue}}{}
\item\contentsline{section}{{\bf eo\-Eval\-Func$<$ EOT $>$} (Evaluate: takes one {\bf EO}{\rm (p.\,\pageref{class_e_o})} and sets its \char`\"{}fitness\char`\"{} property returning this fitness also )}{\pageref{classeo_eval_func}}{}
\item\contentsline{section}{{\bf eo\-Eval\-Func\-Counter$<$ EOT $>$} (Counts the number of evaluations actually performed, thus checks first if it has to evaluate. )}{\pageref{classeo_eval_func_counter}}{}
\item\contentsline{section}{{\bf eo\-Eval\-Func\-Ptr$<$ EOT, Fit\-T, Function\-Arg $>$} (EOEval\-Func\-Ptr: This class takes an existing function pointer and converts it into a evaluation function class )}{\pageref{structeo_eval_func_ptr}}{}
\item\contentsline{section}{{\bf eo\-Expansion\-Mutation$<$ FType, Node $>$} (Eo\-Expansion\-Mutation --$>$ replace a terminal with a randomly created subtree )}{\pageref{classeo_expansion_mutation}}{}
\item\contentsline{section}{{\bf eo\-External\-Bin\-Op$<$ F, External, External\-EO $>$} (Crossover of external struct, ctor expects a function of the following signature: )}{\pageref{classeo_external_bin_op}}{}
\item\contentsline{section}{{\bf eo\-External\-EO$<$ Fit, External $>$} (Definition of an object that allows an external struct to be inserted in {\bf EO}{\rm (p.\,\pageref{class_e_o})} )}{\pageref{classeo_external_e_o}}{}
\item\contentsline{section}{{\bf eo\-External\-Eval\-Func$<$ F, External, External\-EO $>$} (Evaluation of external struct, ctor expects a function of the following signature: )}{\pageref{classeo_external_eval_func}}{}
\item\contentsline{section}{{\bf eo\-External\-Init$<$ F, External, External\-EO $>$} (Initialization of external struct, ctor expects a function of the following signature: )}{\pageref{classeo_external_init}}{}
\item\contentsline{section}{{\bf eo\-External\-Mon\-Op$<$ F, External, External\-EO $>$} (Mutation of external struct, ctor expects a function of the following signature: )}{\pageref{classeo_external_mon_op}}{}
\item\contentsline{section}{{\bf eo\-External\-Quad\-Op$<$ F, External, External\-EO $>$} (Crossover of external struct, ctor expects a function of the following signature: )}{\pageref{classeo_external_quad_op}}{}
\item\contentsline{section}{{\bf eo\-F$<$ R $>$} (Basic Function )}{\pageref{classeo_f}}{}
\item\contentsline{section}{{\bf eo\-Factory$<$ EOClass $>$} ({\bf EO}{\rm (p.\,\pageref{class_e_o})} Factory )}{\pageref{classeo_factory}}{}
\item\contentsline{section}{{\bf eo\-FDCFile\-Snapshot$<$ EOT $>$} (Specific class for FDCStat monitoring: As I failed to have FDC stat as an {\bf eo\-Stat}{\rm (p.\,\pageref{classeo_stat})}, this is the trick to put the 2 {\bf eo\-Param}{\rm (p.\,\pageref{classeo_param})}$<$std::vector$<$double$>$ $>$ into a monitor This class does nothing else )}{\pageref{classeo_f_d_c_file_snapshot}}{}
\item\contentsline{section}{{\bf eo\-FDCStat$<$ EOT $>$} (The FDC computation - stores the values into eo\-Value\-Param$<$EOT,double$>$ so they can be snapshot by some eo\-Gnuplot\-Snapshot .. )}{\pageref{classeo_f_d_c_stat}}{}
\item\contentsline{section}{{\bf eo\-File\-Monitor} (Prints statistics to file )}{\pageref{classeo_file_monitor}}{}
\item\contentsline{section}{{\bf eo\-File\-Snapshot} (Prints snapshots of fitnesses to a (new) file every N generations )}{\pageref{classeo_file_snapshot}}{}
\item\contentsline{section}{{\bf eo\-Fit\-Continue$<$ EOT $>$} (Fitness continuation: )}{\pageref{classeo_fit_continue}}{}
\item\contentsline{section}{{\bf eo\-Fitness\-Scaling\-Select$<$ EOT $>$} (Eo\-Fitness\-Scaling\-Select: select an individual proportional to the linearly scaled fitness that is computed by the private {\bf eo\-Linear\-Fit\-Scaling}{\rm (p.\,\pageref{classeo_linear_fit_scaling})} object )}{\pageref{classeo_fitness_scaling_select}}{}
\item\contentsline{section}{{\bf eo\-Fitness\-Stat$<$ EOT, Fit\-T $>$} (The fitnesses of a whole population, as a vector )}{\pageref{classeo_fitness_stat}}{}
\item\contentsline{section}{{\bf eo\-Fl\-Or1pt\-Bin\-Op$<$ EOT $>$} (The 1pt crossover (just in case someone wants it some day!) )}{\pageref{classeo_fl_or1pt_bin_op}}{}
\item\contentsline{section}{{\bf eo\-Fl\-Or1pt\-Quad\-Op$<$ EOT $>$} (The 1pt crossover (just in case someone wants it some day!) )}{\pageref{classeo_fl_or1pt_quad_op}}{}
\item\contentsline{section}{{\bf eo\-Fl\-Or\-All\-Atom\-Bin\-Op$<$ EOT $>$} (Bin Crossover using an Atom Crossover that is applied to a ALL components with given rate )}{\pageref{classeo_fl_or_all_atom_bin_op}}{}
\item\contentsline{section}{{\bf eo\-Fl\-Or\-All\-Atom\-Quad\-Op$<$ EOT $>$} (Quad Crossover using an Atom Crossover )}{\pageref{classeo_fl_or_all_atom_quad_op}}{}
\item\contentsline{section}{{\bf eo\-Fl\-Or\-All\-Mutation$<$ EOT $>$} (Applies an atomic mutation to all the components with a given rate )}{\pageref{classeo_fl_or_all_mutation}}{}
\item\contentsline{section}{{\bf eo\-Fl\-Or\-KAtom\-Bin\-Op$<$ EOT $>$} (Bin Crossover using an Atom Crossover that is applied to a FIXED NB of components )}{\pageref{classeo_fl_or_k_atom_bin_op}}{}
\item\contentsline{section}{{\bf eo\-Fl\-Or\-KAtom\-Quad\-Op$<$ EOT $>$} (Quad Crossover using an Atom Crossover that is applied to a FIXED NB of components )}{\pageref{classeo_fl_or_k_atom_quad_op}}{}
\item\contentsline{section}{{\bf eo\-Fl\-Or\-KMutation$<$ EOT $>$} (Applies an atomic mutation to a fixed number of components (1 by default) )}{\pageref{classeo_fl_or_k_mutation}}{}
\item\contentsline{section}{{\bf eo\-Fl\-Or\-Uniform\-Bin\-Op$<$ EOT $>$} (The uniform crossover - exchanges atoms uniformly ! )}{\pageref{classeo_fl_or_uniform_bin_op}}{}
\item\contentsline{section}{{\bf eo\-Fl\-Or\-Uniform\-Quad\-Op$<$ EOT $>$} (The uniform crossover - exchanges atoms uniformly ! )}{\pageref{classeo_fl_or_uniform_quad_op}}{}
\item\contentsline{section}{{\bf eo\-Functor\-Base} (Base class for functors to get a nice hierarchy diagram )}{\pageref{classeo_functor_base}}{}
\item\contentsline{section}{{\bf eo\-Functor\-Base::binary\_\-function\_\-tag} (Tag to identify a binary function in compile time function selection functor\_\-category )}{\pageref{structeo_functor_base_1_1binary__function__tag}}{}
\item\contentsline{section}{{\bf eo\-Functor\-Base::procedure\_\-tag} (Tag to identify a procedure in compile time function selection functor\_\-category )}{\pageref{structeo_functor_base_1_1procedure__tag}}{}
\item\contentsline{section}{{\bf eo\-Functor\-Base::unary\_\-function\_\-tag} (Tag to identify a unary function in compile time function selection functor\_\-category )}{\pageref{structeo_functor_base_1_1unary__function__tag}}{}
\item\contentsline{section}{{\bf eo\-Functor\-Store} (Eo\-Functor\-Store is a class that stores functors that are allocated on the heap )}{\pageref{classeo_functor_store}}{}
\item\contentsline{section}{{\bf eo\-G3Replacement$<$ EOT $>$} (Eo\-G3Replacement is an {\bf eo\-Replacement}{\rm (p.\,\pageref{classeo_replacement})}: - no strong elitism (is suppposed to be within a steady-state engine) - choose N (2) parents RANDOMLY - remove them from the parent population - merge offspring and the N removed parents - select best N of this merged population - put them back into parent population )}{\pageref{classeo_g3_replacement}}{}
\item\contentsline{section}{{\bf eo\-Gen\-Continue$<$ EOT $>$} (Generational continuator: continues until a number of generations is reached )}{\pageref{classeo_gen_continue}}{}
\item\contentsline{section}{{\bf eo\-Gene\-Del\-Chooser$<$ EOT $>$} (A helper class for choosing which site to delete )}{\pageref{classeo_gene_del_chooser}}{}
\item\contentsline{section}{{\bf eo\-General\-Breeder$<$ EOT $>$} (Base class for breeders using generalized operators )}{\pageref{classeo_general_breeder}}{}
\item\contentsline{section}{{\bf eo\-General\-Int\-Bounds} (A class that encapsulate all possible {\bf eo\-Int\-Bounds}{\rm (p.\,\pageref{classeo_int_bounds})} )}{\pageref{classeo_general_int_bounds}}{}
\item\contentsline{section}{{\bf eo\-General\-Real\-Bounds} (A class that encapsulate all possible {\bf eo\-Int\-Bounds}{\rm (p.\,\pageref{classeo_int_bounds})} )}{\pageref{classeo_general_real_bounds}}{}
\item\contentsline{section}{{\bf eo\-Generational\-Replacement$<$ EOT $>$} (Generational replacement == swap populations )}{\pageref{classeo_generational_replacement}}{}
\item\contentsline{section}{{\bf eo\-Gen\-Op$<$ EOT $>$} (The base class for General Operators Subclass this operator is you want to define an operator that falls outside of the {\bf eo\-Mon\-Op}{\rm (p.\,\pageref{classeo_mon_op})}, {\bf eo\-Bin\-Op}{\rm (p.\,\pageref{classeo_bin_op})}, {\bf eo\-Quad\-Op}{\rm (p.\,\pageref{classeo_quad_op})} classification )}{\pageref{classeo_gen_op}}{}
\item\contentsline{section}{{\bf eo\-Gnuplot} (Base class for calls to gnuplot )}{\pageref{classeo_gnuplot}}{}
\item\contentsline{section}{{\bf eo\-Gnuplot1DMonitor} (Plot {\bf eo\-Stat}{\rm (p.\,\pageref{classeo_stat})} )}{\pageref{classeo_gnuplot1_d_monitor}}{}
\item\contentsline{section}{{\bf eo\-Gnuplot1DSnapshot} (Plot stats through gnuplot )}{\pageref{classeo_gnuplot1_d_snapshot}}{}
\item\contentsline{section}{{\bf eo\-Hamming\-Distance$<$ EOT $>$} (This is a generic class for L1 distance computation: assumes the 2 things are std::vectors of something that is double-castable For bitstrings, this is the Hamming distance )}{\pageref{classeo_hamming_distance}}{}
\item\contentsline{section}{{\bf eo\-Hoist\-Mutation$<$ FType, Node $>$} (Eo\-Hoist\-Mutation --$>$ replace the individual with one of its subtree's )}{\pageref{classeo_hoist_mutation}}{}
\item\contentsline{section}{{\bf eo\-How\-Many} (A helper class, to determine a number of individuals from another one Typically, is used in selection / replacement procedures, e.g )}{\pageref{classeo_how_many}}{}
\item\contentsline{section}{{\bf eo\-Incrementor$<$ T $>$} (Eo\-Updater that simply increments a counter )}{\pageref{classeo_incrementor}}{}
\item\contentsline{section}{{\bf eo\-Incrementor\-Param$<$ T $>$} (Eo\-Updater that is an {\bf eo\-Value\-Param}{\rm (p.\,\pageref{classeo_value_param})} (and thus OWNS its counter) Mandatory for generation counter in make\_\-checkpoint )}{\pageref{classeo_incrementor_param}}{}
\item\contentsline{section}{{\bf eo\-Init$<$ EOT $>$} (Base (name) class for Initialization of chromosomes, used in a population contructor )}{\pageref{classeo_init}}{}
\item\contentsline{section}{{\bf eo\-Init\-Adaptor$<$ EOT $>$} (Eo\-Init\-Adaptor changes the place in the hierarchy from {\bf eo\-Init}{\rm (p.\,\pageref{classeo_init})} to {\bf eo\-Mon\-Op}{\rm (p.\,\pageref{classeo_mon_op})} )}{\pageref{classeo_init_adaptor}}{}
\item\contentsline{section}{{\bf eo\-Init\-Fixed\-Length$<$ EOT $>$} (Initializer for fixed length representations with a single type )}{\pageref{classeo_init_fixed_length}}{}
\item\contentsline{section}{{\bf eo\-Init\-Generator$<$ EOT $>$} (Turning an {\bf eo\-Init}{\rm (p.\,\pageref{classeo_init})} into a generator probably we should only use genrators - and suppress {\bf eo\-Init}{\rm (p.\,\pageref{classeo_init})} ??? MS - July 2001 )}{\pageref{classeo_init_generator}}{}
\item\contentsline{section}{{\bf eo\-Init\-Variable\-Length$<$ EOT $>$} (Initializer for variable length representations with a single type )}{\pageref{classeo_init_variable_length}}{}
\item\contentsline{section}{{\bf eo\-Init\-Virus$<$ Fit\-T $>$} (Initializer for binary chromosome with MGE )}{\pageref{classeo_init_virus}}{}
\item\contentsline{section}{{\bf eo\-Init\-Virus1bit$<$ Fit\-T $>$} (Inits the virus with one bit to the left set to one )}{\pageref{classeo_init_virus1bit}}{}
\item\contentsline{section}{{\bf eo\-Inner\-Exchange\-Quad\-Op$<$ EOT $>$} (Crossover using an Atom\-Crossover )}{\pageref{classeo_inner_exchange_quad_op}}{}
\item\contentsline{section}{{\bf eo\-Int\-Above\-Bound} (An eo\-Int\-Bound bounded from above only )}{\pageref{classeo_int_above_bound}}{}
\item\contentsline{section}{{\bf eo\-Int\-Below\-Bound} (Eo\-Int\-Bound bounded from below only )}{\pageref{classeo_int_below_bound}}{}
\item\contentsline{section}{{\bf eo\-Int\-Bounds} (Defines bound classes for real numbers )}{\pageref{classeo_int_bounds}}{}
\item\contentsline{section}{{\bf eo\-Int\-Interval} (Fully bounded eo\-Int\-Bound == interval )}{\pageref{classeo_int_interval}}{}
\item\contentsline{section}{{\bf eo\-Int\-No\-Bounds} (A default class for unbounded variables )}{\pageref{classeo_int_no_bounds}}{}
\item\contentsline{section}{{\bf eo\-Invalidate\-Bin\-Op$<$ EOT $>$} (One of the invalidator operators )}{\pageref{classeo_invalidate_bin_op}}{}
\item\contentsline{section}{{\bf eo\-Invalidate\-Mon\-Op$<$ EOT $>$} (One of the invalidator operators )}{\pageref{classeo_invalidate_mon_op}}{}
\item\contentsline{section}{{\bf eo\-Invalidate\-Quad\-Op$<$ EOT $>$} (One of the invalidator operators )}{\pageref{classeo_invalidate_quad_op}}{}
\item\contentsline{section}{{\bf eo\-Linear\-Fit\-Scaling$<$ EOT $>$} (An instance of {\bf eo\-Perf2Worth}{\rm (p.\,\pageref{classeo_perf2_worth})} COmputes the linearly scaled fitnesses with given selective pressure Pselect(Best) == pressure/size\-Pop Pselect(average) == 1.0/size\-Pop truncate negative values to 0 - )}{\pageref{classeo_linear_fit_scaling}}{}
\item\contentsline{section}{{\bf eo\-Linear\-Random\-Split$<$ EOT $>$} (Random truncation - linear version )}{\pageref{classeo_linear_random_split}}{}
\item\contentsline{section}{{\bf eo\-Linear\-Truncate$<$ EOT $>$} (Truncate class that does not sort, but repeatidely kills the worse )}{\pageref{classeo_linear_truncate}}{}
\item\contentsline{section}{{\bf eo\-Linear\-Truncate\-Split$<$ EOT $>$} (Reduce\-Split class that does not sort, but repeatidely kills the worse )}{\pageref{classeo_linear_truncate_split}}{}
\item\contentsline{section}{{\bf Mem\-Pool} (Pool allocator for the subtree and parse tree classes (homebrew and not compliant to ANSI allocator requirements) (c) copyright Maarten Keijzer 1999, 2000 )}{\pageref{class_mem_pool}}{}
\item\contentsline{section}{{\bf gp\_\-parse\_\-tree::Mem\-Pool} (Pool allocator for the subtree and parse tree classes (homebrew and not compliant to ANSI allocator requirements) (c) copyright Maarten Keijzer 1999, 2000 )}{\pageref{classgp__parse__tree_1_1_mem_pool}}{}
\item\contentsline{section}{{\bf eo\-Merge$<$ Chrom $>$} (Eo\-Merge: Base class for elitist replacement algorithms )}{\pageref{classeo_merge}}{}
\item\contentsline{section}{{\bf eo\-Merge\-Reduce$<$ EOT $>$} (Eo\-Merge\-Reduce: abstract replacement strategy that is just an application of an embedded merge, followed by an embedded reduce )}{\pageref{classeo_merge_reduce}}{}
\item\contentsline{section}{{\bf eo\-MGGReplacement$<$ EOT $>$} (Eo\-MGGReplacement is an {\bf eo\-Replacement}{\rm (p.\,\pageref{classeo_replacement})}: - choose N (2) parents RANDOMLY - remove them from the parent population - select best offspring, add to parents - merge (other?) offspring and the N removed parents - select best N-1 of this merged population (det\-Tournament only at the moment) - put them back into parent population )}{\pageref{classeo_m_g_g_replacement}}{}
\item\contentsline{section}{{\bf Minimizing\-Traits} (Test program for Pareto Fitness )}{\pageref{class_minimizing_traits}}{}
\item\contentsline{section}{{\bf eo\-MOFitness\-Stat$<$ EOT, Part\-Fit\-T $>$} (For multi-objective fitness, we need to translate a stat$<$vector$<$double$>$ $>$ into a vector$<$stat$>$, so each objective gets a seperate stat )}{\pageref{classeo_m_o_fitness_stat}}{}
\item\contentsline{section}{{\bf eo\-Mon\-Clone\-Op$<$ EOT $>$} (Mon clone: one argument )}{\pageref{classeo_mon_clone_op}}{}
\item\contentsline{section}{{\bf eo\-Mon\-Gen\-Op$<$ EOT $>$} (Wrapper for {\bf eo\-Mon\-Op}{\rm (p.\,\pageref{classeo_mon_op})} )}{\pageref{classeo_mon_gen_op}}{}
\item\contentsline{section}{{\bf eo\-Monitor} (The abstract monitor class is a std::vector of parameter pointers )}{\pageref{classeo_monitor}}{}
\item\contentsline{section}{{\bf eo\-Mon\-Op$<$ EOType $>$} (Eo\-Mon\-Op is the monary operator: genetic operator that takes only one {\bf EO}{\rm (p.\,\pageref{class_e_o})} )}{\pageref{classeo_mon_op}}{}
\item\contentsline{section}{{\bf eo\-NDPlus\-Replacement$<$ EOT, Worth\-T $>$} (An elitist non-dominated sorted replacement scheme )}{\pageref{classeo_n_d_plus_replacement}}{}
\item\contentsline{section}{{\bf eo\-NDSorting$<$ EOT $>$} (Non dominated sorting, it $\ast$is a$\ast$ std::vector of doubles, the integer part is the rank (to which front it belongs), the fractional part the niching penalty or distance penalty or whatever penalty you want to squeeze into the bits )}{\pageref{classeo_n_d_sorting}}{}
\item\contentsline{section}{{\bf eo\-NDSorting$<$ EOT $>$::Dummy\-EO} (Used in fast nondominated sorting {\bf Dummy\-EO}{\rm (p.\,\pageref{classeo_n_d_sorting_1_1_dummy_e_o})} is just a storage place for fitnesses and to store the original index )}{\pageref{classeo_n_d_sorting_1_1_dummy_e_o}}{}
\item\contentsline{section}{{\bf eo\-NDSorting\_\-I$<$ EOT $>$} (The original Non Dominated Sorting algorithm from Srinivas and Deb )}{\pageref{classeo_n_d_sorting___i}}{}
\item\contentsline{section}{{\bf eo\-NDSorting\_\-II$<$ EOT $>$} (Fast Elitist Non-Dominant Sorting Genetic Algorithm )}{\pageref{classeo_n_d_sorting___i_i}}{}
\item\contentsline{section}{{\bf negexp\_\-generator$<$ T $>$} (The class negexp\_\-generator can be used in the STL generate function to easily generate negative exponential distributed floats and doubles )}{\pageref{classnegexp__generator}}{}
\item\contentsline{section}{{\bf eo\-Neg\-Exp\-Generator$<$ T $>$} (The class {\bf negexp\_\-generator}{\rm (p.\,\pageref{classnegexp__generator})} can be used in the STL generate function to easily generate negative exponential distributed floats and doubles )}{\pageref{classeo_neg_exp_generator}}{}
\item\contentsline{section}{{\bf eo\-Neg\-Exp\-Init$<$ T $>$} (The class {\bf negexp\_\-generator}{\rm (p.\,\pageref{classnegexp__generator})} can be used in the STL generate function to easily generate negative exponential distributed floats and doubles )}{\pageref{classeo_neg_exp_init}}{}
\item\contentsline{section}{{\bf Node\-Selector} (Base class for selecting nodes )}{\pageref{class_node_selector}}{}
\item\contentsline{section}{{\bf eo\-No\-Elitism$<$ EOT $>$} (No elite )}{\pageref{classeo_no_elitism}}{}
\item\contentsline{section}{{\bf eo\-No\-Perf2Worth$<$ EOT $>$} (A dummy perf2worth, just in case you need it )}{\pageref{classeo_no_perf2_worth}}{}
\item\contentsline{section}{{\bf normal\_\-generator$<$ T $>$} (The class normal\_\-generator can be used in the STL generate function to easily generate gaussian distributed floats and doubles )}{\pageref{classnormal__generator}}{}
\item\contentsline{section}{{\bf eo\-Normal\-Generator$<$ T $>$} (The class {\bf normal\_\-generator}{\rm (p.\,\pageref{classnormal__generator})} can be used in the STL generate function to easily generate gaussian distributed floats and doubles )}{\pageref{classeo_normal_generator}}{}
\item\contentsline{section}{{\bf eo\-Normal\-Init$<$ T $>$} (The class {\bf normal\_\-generator}{\rm (p.\,\pageref{classnormal__generator})} can be used in the STL generate function to easily generate gaussian distributed floats and doubles )}{\pageref{classeo_normal_init}}{}
\item\contentsline{section}{{\bf eo\-Normal\-Mutation$<$ EOT $>$} (Simple normal mutation of a std::vector of real values )}{\pageref{classeo_normal_mutation}}{}
\item\contentsline{section}{{\bf eo\-Normal\-Vec\-Mutation$<$ EOT $>$} (Simple normal mutation of a std::vector of real values )}{\pageref{classeo_normal_vec_mutation}}{}
\item\contentsline{section}{{\bf eo\-No\-Select$<$ EOT $>$} (Eo\-No\-Select: returns all individual in order WITHOUT USING FITNESS!!! looping back to the beginning when exhasuted )}{\pageref{classeo_no_select}}{}
\item\contentsline{section}{{\bf eo\-NPts\-Bit\-Xover$<$ Chrom $>$} (Eo\-NPts\-Bit\-Xover --$>$ n-point crossover )}{\pageref{classeo_n_pts_bit_xover}}{}
\item\contentsline{section}{{\bf eo\-Nth\-Element\-Fitness\-Stat$<$ EOT $>$} (The n\_\-th element fitness in the population (see {\bf eo\-Best\-Fitness\-Stat}{\rm (p.\,\pageref{classeo_best_fitness_stat})}) )}{\pageref{classeo_nth_element_fitness_stat}}{}
\item\contentsline{section}{{\bf eo\-Object} (Eo\-Object used to be the base class for the whole hierarchy, but this has changed )}{\pageref{classeo_object}}{}
\item\contentsline{section}{{\bf eo\-One\-Fifth\-Mutation$<$ EOT $>$} (Dynamic version: just say it is updatable - and write the {\bf update()}{\rm (p.\,\pageref{classeo_one_fifth_mutation_a3})} method! here the 1 fifth rule: count the proportion of successful mutations, and increase sigma if more than threshold (1/5 !) )}{\pageref{classeo_one_fifth_mutation}}{}
\item\contentsline{section}{{\bf eo\-One\-Max$<$ Fit\-T $>$} (Always write a comment in this format before class definition if you want the class to be documented by Doxygen )}{\pageref{classeo_one_max}}{}
\item\contentsline{section}{{\bf eo\-One\-Max\-Eval\-Func$<$ EOT $>$} (Always write a comment in this format before class definition if you want the class to be documented by Doxygen )}{\pageref{classeo_one_max_eval_func}}{}
\item\contentsline{section}{{\bf eo\-One\-Max\-Init$<$ Genotype\-T $>$} (Always write a comment in this format before class definition if you want the class to be documented by Doxygen )}{\pageref{classeo_one_max_init}}{}
\item\contentsline{section}{{\bf eo\-One\-Max\-Mutation$<$ Genotype\-T $>$} (Always write a comment in this format before class definition if you want the class to be documented by Doxygen )}{\pageref{classeo_one_max_mutation}}{}
\item\contentsline{section}{{\bf eo\-One\-Max\-Quad\-Crossover$<$ Genotype\-T $>$} (Always write a comment in this format before class definition if you want the class to be documented by Doxygen )}{\pageref{classeo_one_max_quad_crossover}}{}
\item\contentsline{section}{{\bf eo\-Op$<$ EOType $>$} (Abstract data types for {\bf EO}{\rm (p.\,\pageref{class_e_o})} operators )}{\pageref{classeo_op}}{}
\item\contentsline{section}{{\bf eo\-Op\-Container$<$ EOT $>$} (Eo\-Op\-Container is a base class for the sequential and proportional selectors It takes care of wrapping the other operators, and deleting stuff that it has allocated )}{\pageref{classeo_op_container}}{}
\item\contentsline{section}{{\bf eo\-Op\-Sel\-Mason$<$ eo\-Class $>$} ({\bf EO}{\rm (p.\,\pageref{class_e_o})} Mason, or builder, for operator selectors )}{\pageref{classeo_op_sel_mason}}{}
\item\contentsline{section}{{\bf eo\-Param} (Eo\-Param: Base class for monitoring and parsing parameters )}{\pageref{classeo_param}}{}
\item\contentsline{section}{{\bf eo\-Parameter\-Loader} (Parameter saving and loading )}{\pageref{classeo_parameter_loader}}{}
\item\contentsline{section}{{\bf eo\-Param\-Param\-Type} (Another helper class for parsing parameters like Keyword(arg1, arg2, ...) )}{\pageref{classeo_param_param_type}}{}
\item\contentsline{section}{{\bf eo\-Pareto\-Fitness$<$ Fitness\-Traits $>$} (Eo\-Pareto\-Fitness class: std::vector of doubles with overloaded comparison operators )}{\pageref{classeo_pareto_fitness}}{}
\item\contentsline{section}{{\bf eo\-Pareto\-Fitness\-Traits} (Eo\-Fitness\-Traits: a traits class to specify the number of objectives and which one are maximizing or not See test/t-eo\-Pareto\-Fitness for its use )}{\pageref{classeo_pareto_fitness_traits}}{}
\item\contentsline{section}{{\bf eo\-Pareto\-One\-Constraint\-Fitness$<$ Fitness\-Traits $>$} (Eo\-Pareto\-One\-Constraint\-Fitness class: std::vector of doubles + constraint value )}{\pageref{classeo_pareto_one_constraint_fitness}}{}
\item\contentsline{section}{{\bf eo\-Pareto\-Ranking$<$ EOT $>$} (Straightforward pareto ranking )}{\pageref{classeo_pareto_ranking}}{}
\item\contentsline{section}{{\bf eo\-Parser} (Eo\-Parser: command line parser and configuration file reader This class is persistent, so it can be stored and reloaded to restore parameter settings )}{\pageref{classeo_parser}}{}
\item\contentsline{section}{{\bf eo\-Parse\-Tree$<$ FType, Node $>$} (Implementation of parse-tree for genetic programming )}{\pageref{classeo_parse_tree}}{}
\item\contentsline{section}{{\bf eo\-Parse\-Tree\-Depth\-Init$<$ FType, Node $>$} (Eo\-Parse\-Tree\-Depth\-Init : the initializer class for {\bf eo\-Parse\-Tree}{\rm (p.\,\pageref{classeo_parse_tree})} )}{\pageref{classeo_parse_tree_depth_init}}{}
\item\contentsline{section}{{\bf eo\-PBILAdditive$<$ EOT $>$} (Distribution Class for PBIL algorithm (Population-Based Incremental Learning, Baluja and Caruana 96) )}{\pageref{classeo_p_b_i_l_additive}}{}
\item\contentsline{section}{{\bf eo\-PBILDistrib$<$ EOT $>$} (Distribution Class for PBIL algorithm (Population-Based Incremental Learning, Baluja and Caruana 96) )}{\pageref{classeo_p_b_i_l_distrib}}{}
\item\contentsline{section}{{\bf eo\-PBILOrg$<$ EOT $>$} (Distribution Class for PBIL algorithm (Population-Based Incremental Learning, Baluja and Caruana 95) )}{\pageref{classeo_p_b_i_l_org}}{}
\item\contentsline{section}{{\bf eo\-Perf2Worth$<$ EOT, Worth\-T $>$} (Base class to transform raw fitnesses into fitness for selection )}{\pageref{classeo_perf2_worth}}{}
\item\contentsline{section}{{\bf eo\-Perf2Worth$<$ EOT, Worth\-T $>$::compare\_\-worth} (Helper class used to sort indices into populations/worths )}{\pageref{classeo_perf2_worth_1_1compare__worth}}{}
\item\contentsline{section}{{\bf eo\-Perf2Worth\-Cached$<$ EOT, Worth\-T $>$} (Perf2Worth with fitness cache )}{\pageref{classeo_perf2_worth_cached}}{}
\item\contentsline{section}{{\bf eo\-Perf2Worth\-Cached$<$ EOT, Worth\-T $>$::compare\_\-worth} (Helper class used to sort indices into populations/worths )}{\pageref{classeo_perf2_worth_cached_1_1compare__worth}}{}
\item\contentsline{section}{{\bf eo\-Persistent} (An persistent object that knows how to write (through functions inherited from {\bf eo\-Printable}{\rm (p.\,\pageref{classeo_printable})}\#) and read itself )}{\pageref{classeo_persistent}}{}
\item\contentsline{section}{{\bf eo\-Plus$<$ EOT $>$} (Very elitist class, copies entire population into next gen )}{\pageref{classeo_plus}}{}
\item\contentsline{section}{{\bf eo\-Plus\-Replacement$<$ EOT $>$} (ES type of replacement strategy: first add parents to population, then truncate )}{\pageref{classeo_plus_replacement}}{}
\item\contentsline{section}{{\bf eo\-Point\-Mutation$<$ FType, Node $>$} (Eo\-Point\-Mutation --$>$ replace a Node with a Node of the same arity )}{\pageref{classeo_point_mutation}}{}
\item\contentsline{section}{{\bf eo\-Pop$<$ EOT $>$} (A std::vector of {\bf EO}{\rm (p.\,\pageref{class_e_o})} object, to be used in all algorithms (selectors, operators, replacements, ...) )}{\pageref{classeo_pop}}{}
\item\contentsline{section}{{\bf eo\-Pop$<$ EOT $>$::Cmp} (Helper struct for comparing on pointers )}{\pageref{structeo_pop_1_1_cmp}}{}
\item\contentsline{section}{{\bf eo\-Pop$<$ EOT $>$::Ref} (Helper struct for getting a pointer )}{\pageref{structeo_pop_1_1_ref}}{}
\item\contentsline{section}{{\bf eo\-Pop\-Algo$<$ EOT $>$} (For all \char`\"{}population transforming\char`\"{} algos .. )}{\pageref{classeo_pop_algo}}{}
\item\contentsline{section}{{\bf eo\-Pop\-Eval\-Func$<$ EOT $>$} (Eo\-Pop\-Eval\-Func: This abstract class is for GLOBAL evaluators of a population after variation )}{\pageref{classeo_pop_eval_func}}{}
\item\contentsline{section}{{\bf eo\-Pop\-Loop\-Eval$<$ EOT $>$} (Eo\-Pop\-Loop\-Eval: an instance of {\bf eo\-Pop\-Eval\-Func}{\rm (p.\,\pageref{classeo_pop_eval_func})} that simply applies a private {\bf eo\-Eval\-Func}{\rm (p.\,\pageref{classeo_eval_func})} to all offspring )}{\pageref{classeo_pop_loop_eval}}{}
\item\contentsline{section}{{\bf eo\-Pop\-Stat$<$ EOT $>$} (Thanks to MS/VC++, {\bf eo\-Param}{\rm (p.\,\pageref{classeo_param})} mechanism is unable to handle std::vectors of stats )}{\pageref{classeo_pop_stat}}{}
\item\contentsline{section}{{\bf eo\-Populator$<$ EOT $>$} (Eo\-Populator is a helper class for general operators {\bf eo\-Gen\-Op}{\rm (p.\,\pageref{classeo_gen_op})} It is an {\bf eo\-Pop}{\rm (p.\,\pageref{classeo_pop})} but also behaves like an eo\-Pop::iterator as far as operator$\ast$ and operator++ are concerned )}{\pageref{classeo_populator}}{}
\item\contentsline{section}{{\bf eo\-Printable} (Base class for objects that can print themselves ({\bf print\-On}{\rm (p.\,\pageref{classeo_printable_a1})}\#) )}{\pageref{classeo_printable}}{}
\item\contentsline{section}{{\bf eo\-Procedure\-Counter$<$ Procedure $>$} (Generic counter class that counts the number of times a procedure is used )}{\pageref{classeo_procedure_counter}}{}
\item\contentsline{section}{{\bf eo\-Prop\-Combined\-Bin\-Op$<$ EOT $>$} (COmbined Binary genetic operator: operator() has two operands, only the first one can be modified )}{\pageref{classeo_prop_combined_bin_op}}{}
\item\contentsline{section}{{\bf eo\-Prop\-Combined\-Mon\-Op$<$ EOT $>$} (Eo\-Mon\-Op is the monary operator: genetic operator that takes only one {\bf EO}{\rm (p.\,\pageref{class_e_o})} )}{\pageref{classeo_prop_combined_mon_op}}{}
\item\contentsline{section}{{\bf eo\-Prop\-Combined\-Quad\-Op$<$ EOT $>$} (Combined quad genetic operator: operator() has two operands, both can be modified )}{\pageref{classeo_prop_combined_quad_op}}{}
\item\contentsline{section}{{\bf eo\-Prop\-GAGen\-Op$<$ EOT $>$} ($\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$ eo\-Prop\-GAGen\-Op (for Simple GA, but Proportional) choice between Crossover, mutation or cloining with respect to given relatve weights )}{\pageref{classeo_prop_g_a_gen_op}}{}
\item\contentsline{section}{{\bf eo\-Proportional\-Op$<$ EOT $>$} (The proportional versions: easy! )}{\pageref{classeo_proportional_op}}{}
\item\contentsline{section}{{\bf eo\-Proportional\-Select$<$ EOT $>$} (Eo\-Proportional\-Select: select an individual proportional to her stored fitness value )}{\pageref{classeo_proportional_select}}{}
\item\contentsline{section}{{\bf eo\-Quad2Bin\-Op$<$ EOT $>$} (Turning an {\bf eo\-Quad\-Op}{\rm (p.\,\pageref{classeo_quad_op})} into an {\bf eo\-Bin\-Op}{\rm (p.\,\pageref{classeo_bin_op})}: simply don't touch the second arg! )}{\pageref{classeo_quad2_bin_op}}{}
\item\contentsline{section}{{\bf eo\-Quad\-Clone\-Op$<$ EOT $>$} (Quad clone: two operands, both could be modified - but are not! )}{\pageref{classeo_quad_clone_op}}{}
\item\contentsline{section}{{\bf eo\-Quad\-Distance$<$ EOT $>$} (This is a generic class for Euclidain distance (L2 norm) computation: assumes the 2 things are std::vectors of something that is double-castable )}{\pageref{classeo_quad_distance}}{}
\item\contentsline{section}{{\bf eo\-Quad\-Gen\-Op$<$ EOT $>$} (Wrapper for quadop: easy as pie )}{\pageref{classeo_quad_gen_op}}{}
\item\contentsline{section}{{\bf eo\-Quad\-Op$<$ EOType $>$} (Quad genetic operator: subclasses {\bf eo\-Op}{\rm (p.\,\pageref{classeo_op})}, and defines basically the operator() with two operands, both can be modified )}{\pageref{classeo_quad_op}}{}
\item\contentsline{section}{{\bf random\_\-generator$<$ T $>$} (The class random\_\-generator can be used in the STL generate function to easily generate random ints either between [0, \_\-max) if only one value (\_\-max) is given to the ctor or in [\_\-min,\_\-max) if 2 values are given (\_\-min, \_\-max) )}{\pageref{classrandom__generator}}{}
\item\contentsline{section}{{\bf Random\-Node\-Selector} (Select nodes uniformly )}{\pageref{class_random_node_selector}}{}
\item\contentsline{section}{{\bf eo\-Random\-Reduce$<$ EOT $>$} (Random truncation )}{\pageref{classeo_random_reduce}}{}
\item\contentsline{section}{{\bf eo\-Random\-Select$<$ EOT $>$} (Eo\-Random\-Select: a selection method that selects ONE individual randomly )}{\pageref{classeo_random_select}}{}
\item\contentsline{section}{{\bf eo\-Random\-Split$<$ EOT $>$} (Random truncation - batch version )}{\pageref{classeo_random_split}}{}
\item\contentsline{section}{{\bf eo\-Ranking$<$ EOT $>$} (An instance of eo\-Perf\-From\-Worth COmputes the ranked fitness: fitnesses range in [m,M] with m=2-pressure/pop\-Size and M=pressure/pop\-Size )}{\pageref{classeo_ranking}}{}
\item\contentsline{section}{{\bf eo\-Ranking\-Select$<$ EOT $>$} (Eo\-Ranking\-Select: select an individual by roulette wheel on its rank is an {\bf eo\-Roulette\-Worth\-Select}{\rm (p.\,\pageref{classeo_roulette_worth_select})}, i.e )}{\pageref{classeo_ranking_select}}{}
\item\contentsline{section}{{\bf eo\-Real$<$ Fit\-T $>$} (Eo\-Real: implementation of simple real-valued chromosome )}{\pageref{classeo_real}}{}
\item\contentsline{section}{{\bf eo\-Real\-Above\-Bound} (An eo\-Real\-Bound bounded from above only )}{\pageref{classeo_real_above_bound}}{}
\item\contentsline{section}{{\bf eo\-Real\-Base\-Vector\-Bounds} (Vector type for bounds (see {\bf eo\-Real\-Bounds.h}{\rm (p.\,\pageref{eo_real_bounds_8h})} for scalar types) ------------ Class {\bf eo\-Real\-Vector\-Bounds}{\rm (p.\,\pageref{classeo_real_vector_bounds})} implements the std::vectorized version: it is basically a std::vector of {\bf eo\-Real\-Bounds}{\rm (p.\,\pageref{classeo_real_bounds})} $\ast$ and forwards all request to the elements of the std::vector )}{\pageref{classeo_real_base_vector_bounds}}{}
\item\contentsline{section}{{\bf eo\-Real\-Below\-Bound} (Eo\-Real\-Bound bounded from below only )}{\pageref{classeo_real_below_bound}}{}
\item\contentsline{section}{{\bf eo\-Real\-Bounds} (Defines bound classes for real numbers )}{\pageref{classeo_real_bounds}}{}
\item\contentsline{section}{{\bf eo\-Real\-Init\-Bounded$<$ EOT $>$} (Simple initialization for any EOT that derives from std::vector$<$double$>$ uniformly in some bounds )}{\pageref{classeo_real_init_bounded}}{}
\item\contentsline{section}{{\bf eo\-Real\-Interval} (Fully bounded eo\-Real\-Bound == interval )}{\pageref{classeo_real_interval}}{}
\item\contentsline{section}{{\bf eo\-Real\-No\-Bounds} (A default class for unbounded variables )}{\pageref{classeo_real_no_bounds}}{}
\item\contentsline{section}{{\bf eo\-Real\-Ux\-Over} (Eo\-Real\-Ux\-Over --$>$ Uniform crossover, also termed intermediate crossover )}{\pageref{classeo_real_ux_over}}{}
\item\contentsline{section}{{\bf eo\-Real\-Vector\-Bounds} (Now a derived class, for parser reading It holds some of the bounds (and destroy them when dying) )}{\pageref{classeo_real_vector_bounds}}{}
\item\contentsline{section}{{\bf eo\-Real\-Vector\-No\-Bounds} ({\bf Dummy}{\rm (p.\,\pageref{struct_dummy})} unbounded {\bf eo\-Real\-Vector\-Bounds}{\rm (p.\,\pageref{classeo_real_vector_bounds})}: usefull if you don't need bounds! everything is inlined )}{\pageref{classeo_real_vector_no_bounds}}{}
\item\contentsline{section}{{\bf eo\-Reduce$<$ EOT $>$} (Eo\-Reduce: .reduce the new generation to the specified size At the moment, limited to truncation - with 2 different methods, one that sorts the whole population, and one that repeatidely kills the worst )}{\pageref{classeo_reduce}}{}
\item\contentsline{section}{{\bf eo\-Reduce\-Merge$<$ EOT $>$} (Eo\-Reduce\-Merge: Replacement strategies that start by reducing the parents, then merge with the offspring )}{\pageref{classeo_reduce_merge}}{}
\item\contentsline{section}{{\bf eo\-Reduce\-Merge\-Reduce$<$ EOT $>$} (Eo\-Reduce\-Merge\-Reduce is an {\bf eo\-Replacement}{\rm (p.\,\pageref{classeo_replacement})}: - saves possible elite parents - reduces rest of parents - reduces offspring - merges reduced populations - reduces resulting merged pop if necessary )}{\pageref{classeo_reduce_merge_reduce}}{}
\item\contentsline{section}{{\bf eo\-Reduce\-Split$<$ EOT $>$} (Eo\-Reduce\-Split: reduce the pop to the specified size AND eventually returns the eliminated guys )}{\pageref{classeo_reduce_split}}{}
\item\contentsline{section}{{\bf eo\-Replacement$<$ EOT $>$} }{\pageref{classeo_replacement}}{}
\item\contentsline{section}{{\bf eo\-Rnd\-Generator$<$ T $>$} (By popular demand re-introducing a base class for a family of random number generators )}{\pageref{classeo_rnd_generator}}{}
\item\contentsline{section}{{\bf eo\-Rng} (Random Number Generator )}{\pageref{classeo_rng}}{}
\item\contentsline{section}{{\bf eo\-Roulette\-Worth\-Select$<$ EOT, Worth\-T $>$} (An instance of eo\-Select\-Perf2Worth that does selection from the Worthes using a .. )}{\pageref{classeo_roulette_worth_select}}{}
\item\contentsline{section}{{\bf eo\-Scalar\-Fitness$<$ Scalar\-Type, Compare $>$} (Eo\-Scalar\-Fitness$<$Scalar\-Type, Compare = less$<$Scalar\-Type$>$ $>$: Wraps a scalar fitness values such as a double or int, with the option of maximizing (using less$<$Scalar\-Type$>$) or minimizing (using greater$<$Scalar\-Type$>$) )}{\pageref{classeo_scalar_fitness}}{}
\item\contentsline{section}{{\bf eo\-Scalar\-Fitness\-Assembled$<$ Scalar\-Type, Compare, Fitness\-Traits $>$} (Implements fitness as std::vector, storing all values that might occur during fitness assembly )}{\pageref{classeo_scalar_fitness_assembled}}{}
\item\contentsline{section}{{\bf eo\-Scalar\-Fitness\-Assembled\-Traits} (Defines properties of {\bf eo\-Scalar\-Fitness\-Assembled}{\rm (p.\,\pageref{classeo_scalar_fitness_assembled})} )}{\pageref{classeo_scalar_fitness_assembled_traits}}{}
\item\contentsline{section}{{\bf eo\-Scalar\-Fitness\-Stat$<$ EOT, Fit\-T $>$} (The fitnesses of a whole population, as a std::vector )}{\pageref{classeo_scalar_fitness_stat}}{}
\item\contentsline{section}{{\bf eo\-Second\-Moment\-Stats$<$ EOT $>$} (Average fitness + Std )}{\pageref{classeo_second_moment_stats}}{}
\item\contentsline{section}{{\bf eo\-Segment\-Crossover$<$ EOT $>$} (Eo\-Segment\-Crossover --$>$ uniform choice in segment == arithmetical with same value along all coordinates )}{\pageref{classeo_segment_crossover}}{}
\item\contentsline{section}{{\bf eo\-Sel\-Bin\-Gen\-Op$<$ EOT $>$} (Wrapper for {\bf eo\-Bin\-Op}{\rm (p.\,\pageref{classeo_bin_op})} with a selector )}{\pageref{classeo_sel_bin_gen_op}}{}
\item\contentsline{section}{{\bf eo\-Select$<$ EOT $>$} (Eo\-Select selects a number of individuals from the first argument and puts it in the second )}{\pageref{classeo_select}}{}
\item\contentsline{section}{{\bf eo\-Select\-Factory$<$ EOT $>$} ({\bf EO}{\rm (p.\,\pageref{class_e_o})} Factory.An instance of the factory class to create selectors, that is, {\bf eo\-Select}{\rm (p.\,\pageref{classeo_select})} objects )}{\pageref{classeo_select_factory}}{}
\item\contentsline{section}{{\bf eo\-Select\-From\-Worth$<$ EOT, Worth\-Type $>$} (Selects one element from a population (is an {\bf eo\-Select\-One}{\rm (p.\,\pageref{classeo_select_one})}) but the selection is based on a std::vector of Worth that is different from the fitnesses (e.g )}{\pageref{classeo_select_from_worth}}{}
\item\contentsline{section}{{\bf eo\-Selective\-Populator$<$ EOT $>$} (Selective\-Populator an eo\-Poplator that uses an {\bf eo\-Select\-One}{\rm (p.\,\pageref{classeo_select_one})} to select guys )}{\pageref{classeo_selective_populator}}{}
\item\contentsline{section}{{\bf eo\-Select\-Many$<$ EOT $>$} (Eo\-Select\-Many selects many individuals using {\bf eo\-Select\-One}{\rm (p.\,\pageref{classeo_select_one})} as it's mechanism )}{\pageref{classeo_select_many}}{}
\item\contentsline{section}{{\bf eo\-Select\-Number$<$ EOT $>$} (Eo\-Select\-Number selects many individuals using {\bf eo\-Select\-One}{\rm (p.\,\pageref{classeo_select_one})} as it's mechanism )}{\pageref{classeo_select_number}}{}
\item\contentsline{section}{{\bf eo\-Select\-One$<$ EOT, Worth\-T $>$} (Eo\-Select\-One selects only one element from a whole population )}{\pageref{classeo_select_one}}{}
\item\contentsline{section}{{\bf eo\-Select\-Perc$<$ EOT $>$} (Eo\-Select\-Perc selects many individuals using {\bf eo\-Select\-One}{\rm (p.\,\pageref{classeo_select_one})} as it's mechanism )}{\pageref{classeo_select_perc}}{}
\item\contentsline{section}{{\bf eo\-Select\-Transform$<$ EOT $>$} (Embedded select, followed by an embedded transform )}{\pageref{classeo_select_transform}}{}
\item\contentsline{section}{{\bf eo\-Seq\-Populator$<$ EOT $>$} (Seq\-Populator: an {\bf eo\-Populator}{\rm (p.\,\pageref{classeo_populator})} that sequentially goes through the population is supposed to be used after a batch select of a whole bunch or genitors )}{\pageref{classeo_seq_populator}}{}
\item\contentsline{section}{{\bf eo\-Sequential\-Op$<$ EOT $>$} (Sequential selection: note the mark, rewind, unmark cycle here operators are repeatedly applied on the same individual(s) not all too elegant, but it sort of works.. )}{\pageref{classeo_sequential_op}}{}
\item\contentsline{section}{{\bf eo\-Sequential\-Select$<$ EOT $>$} (All Individuals in order )}{\pageref{classeo_sequential_select}}{}
\item\contentsline{section}{{\bf eo\-SGA$<$ EOT $>$} (The Simple Genetic Algorithm, following Holland and Goldberg )}{\pageref{classeo_s_g_a}}{}
\item\contentsline{section}{{\bf eo\-SGAGen\-Op$<$ EOT $>$} ($\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$$\ast$ eo\-SGAGen\-Op (for Simple GA) mimicks the usual crossover with proba p\-Cross + mutation with proba p\-Mut inside an eo\-General\-Op It does it exactly as class {\bf eo\-SGATransform}{\rm (p.\,\pageref{classeo_s_g_a_transform})}, i.e )}{\pageref{classeo_s_g_a_gen_op}}{}
\item\contentsline{section}{{\bf eo\-SGATransform$<$ EOT $>$} (Eo\-SGATransform: transforms a population using genetic operators )}{\pageref{classeo_s_g_a_transform}}{}
\item\contentsline{section}{{\bf eo\-Sharing$<$ EOT $>$} (Sharing is a perf2worth class that implements Goldberg and Richardson's basic sharing see {\bf eo\-Sharing\-Select}{\rm (p.\,\pageref{classeo_sharing_select})} for how to use it and test/t-eo\-Sharing.cpp for a sample use of both )}{\pageref{classeo_sharing}}{}
\item\contentsline{section}{{\bf eo\-Sharing\-Select$<$ EOT $>$} (Eo\-Sharing\-Select: select an individual by roulette wheel on its SHARED fitness )}{\pageref{classeo_sharing_select}}{}
\item\contentsline{section}{{\bf eo\-Simple\-EDA$<$ EOT $>$} (Eo\-Simple\-EDA: a very simple Estimation of Distribution Algorithm )}{\pageref{classeo_simple_e_d_a}}{}
\item\contentsline{section}{{\bf eo\-Sorted\-Pop\-Stat$<$ EOT $>$} (Thanks to MS/VC++, {\bf eo\-Param}{\rm (p.\,\pageref{classeo_param})} mechanism is unable to handle std::vectors of stats )}{\pageref{classeo_sorted_pop_stat}}{}
\item\contentsline{section}{{\bf eo\-Sorted\-Stat$<$ EOT, Param\-Type $>$} (The actual class that will be used as base for all statistics that need to be calculated over the sorted population It's an {\bf eo\-Sorted\-Stat\-Base}{\rm (p.\,\pageref{classeo_sorted_stat_base})} AND an {\bf eo\-Value\-Param}{\rm (p.\,\pageref{classeo_value_param})} so it can be used in Monitors )}{\pageref{classeo_sorted_stat}}{}
\item\contentsline{section}{{\bf eo\-Sorted\-Stat\-Base$<$ EOT $>$} (Base class for statistics calculated over a sorted snapshot of the population )}{\pageref{classeo_sorted_stat_base}}{}
\item\contentsline{section}{{\bf eo\-SSGADet\-Tournament\-Replacement$<$ EOT $>$} (SSGA deterministic tournament replacement )}{\pageref{classeo_s_s_g_a_det_tournament_replacement}}{}
\item\contentsline{section}{{\bf eo\-SSGAStoch\-Tournament\-Replacement$<$ EOT $>$} (SSGA stochastic tournament replacement )}{\pageref{classeo_s_s_g_a_stoch_tournament_replacement}}{}
\item\contentsline{section}{{\bf eo\-SSGAWorse\-Replacement$<$ EOT $>$} (SSGA replace worst )}{\pageref{classeo_s_s_g_a_worse_replacement}}{}
\item\contentsline{section}{{\bf eo\-Stat$<$ EOT, T $>$} (The actual class that will be used as base for all statistics that need to be calculated over the (unsorted) population It is an {\bf eo\-Stat\-Base}{\rm (p.\,\pageref{classeo_stat_base})} AND an {\bf eo\-Value\-Param}{\rm (p.\,\pageref{classeo_value_param})} so it can be used in Monitors )}{\pageref{classeo_stat}}{}
\item\contentsline{section}{{\bf eo\-Stat\-Base$<$ EOT $>$} (Base class for all statistics that need to be calculated over the (unsorted) population (I guess it is not really necessary? MS )}{\pageref{classeo_stat_base}}{}
\item\contentsline{section}{{\bf eo\-State} (Eo\-State can be used to register derivants of {\bf eo\-Persistent}{\rm (p.\,\pageref{classeo_persistent})} )}{\pageref{classeo_state}}{}
\item\contentsline{section}{{\bf eo\-State::loading\_\-error} (Loading error thrown when nothing seems to work )}{\pageref{structeo_state_1_1loading__error}}{}
\item\contentsline{section}{{\bf eo\-St\-Branch\-Mutation$<$ FType, Node $>$} (Eo\-St\-Branch\-Mutation --$>$ replace a strongly typed subtree with a randomly created strongly typed subtree )}{\pageref{classeo_st_branch_mutation}}{}
\item\contentsline{section}{{\bf eo\-Stdout\-Monitor} (Prints statistics to stdout )}{\pageref{classeo_stdout_monitor}}{}
\item\contentsline{section}{{\bf eo\-Steady\-Fit\-Continue$<$ EOT $>$} (A continuator: does a minimum number of generations, then stops whenever a given number of generations takes place without improvement )}{\pageref{classeo_steady_fit_continue}}{}
\item\contentsline{section}{{\bf eo\-St\-Hoist\-Mutation$<$ FType, Node $>$} (Eo\-St\-Hoist\-Mutation --$>$ replace the individual with one of its strongly typed subtree's )}{\pageref{classeo_st_hoist_mutation}}{}
\item\contentsline{section}{{\bf eo\-STLBF$<$ A1, A2, R $>$} (Generic set of classes that wrap an {\bf eo\-F}{\rm (p.\,\pageref{classeo_f})}, {\bf eo\-UF}{\rm (p.\,\pageref{classeo_u_f})} or {\bf eo\-BF}{\rm (p.\,\pageref{classeo_b_f})} so that they have the copy semantics the STL functions usually require (i.e )}{\pageref{classeo_s_t_l_b_f}}{}
\item\contentsline{section}{{\bf eo\-STLF$<$ R $>$} (Generic set of classes that wrap an {\bf eo\-F}{\rm (p.\,\pageref{classeo_f})}, {\bf eo\-UF}{\rm (p.\,\pageref{classeo_u_f})} or {\bf eo\-BF}{\rm (p.\,\pageref{classeo_b_f})} so that they have the copy semantics the STL functions usually require (i.e )}{\pageref{classeo_s_t_l_f}}{}
\item\contentsline{section}{{\bf eo\-STLUF$<$ A1, R $>$} (Generic set of classes that wrap an {\bf eo\-F}{\rm (p.\,\pageref{classeo_f})}, {\bf eo\-UF}{\rm (p.\,\pageref{classeo_u_f})} or {\bf eo\-BF}{\rm (p.\,\pageref{classeo_b_f})} so that they have the copy semantics the STL functions usually require (i.e )}{\pageref{classeo_s_t_l_u_f}}{}
\item\contentsline{section}{{\bf eo\-Stochastic\-Universal\-Select$<$ EOT $>$} (Eo\-Stochastic\-Universal\-Select: select an individual proportional to her stored fitness value, but in contrast with eo\-Stochastic\-Universal\-Select, get rid of most finite sampling effects by doing all selections in one go, using a single random number )}{\pageref{classeo_stochastic_universal_select}}{}
\item\contentsline{section}{{\bf eo\-Stoch\-Tournament\-Select$<$ EOT $>$} (Eo\-Stoch\-Tournament\-Select: a selection method that selects ONE individual by binary stochastic tournament -MS- 24/10/99 )}{\pageref{classeo_stoch_tournament_select}}{}
\item\contentsline{section}{{\bf eo\-Stoch\-Tournament\-Truncate$<$ EOT $>$} (Truncate class based on a repeated deterministic (reverse!) tournament To be used in SSGA-like replacements (e.g )}{\pageref{classeo_stoch_tournament_truncate}}{}
\item\contentsline{section}{{\bf eo\-Stoch\-Tournament\-Truncate\-Split$<$ EOT $>$} (Reduce\-Split class based on a repeated deterministic (reverse!) tournament To be used in SSGA-like replacements (e.g )}{\pageref{classeo_stoch_tournament_truncate_split}}{}
\item\contentsline{section}{{\bf eo\-Stoch\-Tournament\-Worth\-Select$<$ EOT, Worth\-T $>$} (An instance of eo\-Select\-Perf2Worth that does selection from the Worthes using a .. )}{\pageref{classeo_stoch_tournament_worth_select}}{}
\item\contentsline{section}{{\bf eo\-St\-Parse\-Tree\-Depth\-Init$<$ FType, Node $>$} (Eo\-St\-Parse\-Tree\-Depth\-Init : the initializer class for strongly typed tree-based genetic programming )}{\pageref{classeo_st_parse_tree_depth_init}}{}
\item\contentsline{section}{{\bf eo\-St\-Point\-Mutation$<$ FType, Node $>$} (Eo\-St\-Point\-Mutation --$>$ replace a Node with a Node of the same arity and type )}{\pageref{classeo_st_point_mutation}}{}
\item\contentsline{section}{{\bf eo\-String$<$ fitness\-T $>$} (Adaptor that turns an STL std::string into an {\bf EO}{\rm (p.\,\pageref{class_e_o})} )}{\pageref{classeo_string}}{}
\item\contentsline{section}{{\bf eo\-St\-Subtree\-XOver$<$ FType, Node $>$} (Eo\-St\-Subtree\-XOver --$>$ subtree xover for strongly typed tree-based genetic programming )}{\pageref{classeo_st_subtree_x_over}}{}
\item\contentsline{section}{{\bf eo\-Subtree\-XOver$<$ FType, Node $>$} (Eo\-Subtree\-XOver --$>$ subtree xover )}{\pageref{classeo_subtree_x_over}}{}
\item\contentsline{section}{{\bf eo\-Survive\-And\-Die$<$ EOT $>$} (Eo\-Survive\-And\-Die A pure abstract class, to store the howmany's )}{\pageref{classeo_survive_and_die}}{}
\item\contentsline{section}{{\bf eo\-Sym\-Init$<$ Eo\-Type $>$} (Default initializer, Koza style )}{\pageref{classeo_sym_init}}{}
\item\contentsline{section}{{\bf T\_\-pickle\_\-suite$<$ T $>$} (Implements pickle support for {\bf eo\-Persistent}{\rm (p.\,\pageref{classeo_persistent})} derivatives )}{\pageref{struct_t__pickle__suite}}{}
\item\contentsline{section}{{\bf eo\-Time\-Counter} (An {\bf eo\-Stat}{\rm (p.\,\pageref{classeo_stat})} that simply gives the user time since first generation It has to be tempatized by EOT because it must be an {\bf eo\-Stat}{\rm (p.\,\pageref{classeo_stat})} )}{\pageref{classeo_time_counter}}{}
\item\contentsline{section}{{\bf eo\-Timed\-Dyn\-Update} (An {\bf eo\-Updater}{\rm (p.\,\pageref{classeo_updater})} to update an {\bf eo\-Updatable}{\rm (p.\,\pageref{classeo_updatable})} object every given time interval )}{\pageref{classeo_timed_dyn_update}}{}
\item\contentsline{section}{{\bf eo\-Timed\-Monitor} (Holds a collection of monitors and only fires them when a time limit has been reached )}{\pageref{classeo_timed_monitor}}{}
\item\contentsline{section}{{\bf eo\-Timed\-State\-Saver} (Eo\-Updater that saves a state every given time interval )}{\pageref{classeo_timed_state_saver}}{}
\item\contentsline{section}{{\bf eo\-Time\-Varying\-Loop\-Eval$<$ EOT $>$} (Eo\-Pop\-Loop\-Eval: an instance of {\bf eo\-Pop\-Eval\-Func}{\rm (p.\,\pageref{classeo_pop_eval_func})} that simply applies a private {\bf eo\-Eval\-Func}{\rm (p.\,\pageref{classeo_eval_func})} to all offspring AND ALL PARENTS as the fitness is supposed here to vary )}{\pageref{classeo_time_varying_loop_eval}}{}
\item\contentsline{section}{{\bf eo\-Transform$<$ EOT $>$} (Eo\-Transform transforms a population by applying genetic operators on it )}{\pageref{classeo_transform}}{}
\item\contentsline{section}{{\bf eo\-Truncate$<$ EOT $>$} (Truncation method using sort )}{\pageref{classeo_truncate}}{}
\item\contentsline{section}{{\bf eo\-Truncated\-Select\-Many$<$ EOT $>$} (Eo\-Truncated\-Select\-Many selects many individuals using {\bf eo\-Select\-One}{\rm (p.\,\pageref{classeo_select_one})} as it's mechanism )}{\pageref{classeo_truncated_select_many}}{}
\item\contentsline{section}{{\bf eo\-Truncated\-Select\-One$<$ EOT $>$} (Eo\-Truncated\-Select\-One selects one individual using {\bf eo\-Select\-One}{\rm (p.\,\pageref{classeo_select_one})} as it's mechanism )}{\pageref{classeo_truncated_select_one}}{}
\item\contentsline{section}{{\bf eo\-Truncate\-Split$<$ EOT $>$} (Deterministic truncation method using sort )}{\pageref{classeo_truncate_split}}{}
\item\contentsline{section}{{\bf eo\-Trunc\-Select$<$ EOT $>$} (Eo\-Trunc\-Select selects individuals after truncating the population using {\bf eo\-Select\-One}{\rm (p.\,\pageref{classeo_select_one})} as it's mechanism )}{\pageref{classeo_trunc_select}}{}
\item\contentsline{section}{{\bf eo\-UBit\-Xover$<$ Chrom $>$} (Eo\-UBit\-Xover --$>$ classic Uniform crossover )}{\pageref{classeo_u_bit_xover}}{}
\item\contentsline{section}{{\bf eo\-UF$<$ A1, R $>$} (Basic Unary Functor )}{\pageref{classeo_u_f}}{}
\item\contentsline{section}{{\bf UF\_\-random\_\-generator$<$ T $>$} (Another class {\bf random\_\-generator}{\rm (p.\,\pageref{classrandom__generator})} that can be used in the STL random\_\-shuffle function (see {\bf eo\-Pop::shuffle}{\rm (p.\,\pageref{classeo_pop_a7})}): its operator() takes an unsigned argument m and must return an unsigned uniformly distributed in [0,m\} )}{\pageref{class_u_f__random__generator}}{}
\item\contentsline{section}{{\bf eo\-Unary\-Functor\-Counter$<$ Unary\-Functor $>$} (Generic counter class that counts the number of times a unary function is used )}{\pageref{classeo_unary_functor_counter}}{}
\item\contentsline{section}{{\bf uniform\_\-generator$<$ T $>$} (The class uniform\_\-generator can be used in the STL generate function to easily generate random floats and doubles either in [0, \_\-max) if only 1 value (\_\-max) is given (or none, as \_\-max defaults to 1.0) or in [\_\-min,\_\-max) if 2 values are given (\_\-min, \_\-max) )}{\pageref{classuniform__generator}}{}
\item\contentsline{section}{{\bf eo\-Uniform\-Atom\-Exchange$<$ Atom $>$} (Uniform crossover - well, not really, efficient for Fixed\-Length )}{\pageref{classeo_uniform_atom_exchange}}{}
\item\contentsline{section}{{\bf eo\-Uniform\-Gene\-Chooser$<$ EOT $>$} (Uniform choice of gene to delete )}{\pageref{classeo_uniform_gene_chooser}}{}
\item\contentsline{section}{{\bf eo\-Uniform\-Generator$<$ T $>$} (The class eo\-Uniform can be used in the STL generate function to easily generate random floats and doubles )}{\pageref{classeo_uniform_generator}}{}
\item\contentsline{section}{{\bf eo\-Uniform\-Init$<$ T $>$} (The class eo\-Uniform\-Init can be used in the STL apply function to easily randomize floats and doubles )}{\pageref{classeo_uniform_init}}{}
\item\contentsline{section}{{\bf eo\-Uniform\-Mutation$<$ EOT $>$} (Eo\-Uniform\-Mutation --$>$ changes all values of the std::vector by uniform choice with range epsilon with probability p\_\-change per variable )}{\pageref{classeo_uniform_mutation}}{}
\item\contentsline{section}{{\bf eo\-Updatable} (Eo\-Updatable is a generic class for adding updatation to an existing class Just says it has an update() method )}{\pageref{classeo_updatable}}{}
\item\contentsline{section}{{\bf eo\-Updater} (Eo\-Updater is a generic procudere for updating whatever you want )}{\pageref{classeo_updater}}{}
\item\contentsline{section}{{\bf eo\-Value\-Param$<$ Value\-Type $>$} (Eo\-Value\-Param$<$Value\-Type$>$: templatized derivation of {\bf eo\-Param}{\rm (p.\,\pageref{classeo_param})} )}{\pageref{classeo_value_param}}{}
\item\contentsline{section}{{\bf eo\-Variable\-Pareto\-Traits} (Eo\-Variable\-Pareto\-Traits : an {\bf eo\-Pareto\-Fitness\-Traits}{\rm (p.\,\pageref{classeo_pareto_fitness_traits})} whose characteristics can be set at run-time (nb objectives and min/max's) Why bother? For didactical purposes (and EASEA implementation :-) )}{\pageref{classeo_variable_pareto_traits}}{}
\item\contentsline{section}{{\bf eo\-Vector$<$ Fit\-T, Gene\-Type $>$} (Base class for fixed length chromosomes, just derives from {\bf EO}{\rm (p.\,\pageref{class_e_o})} and std::vector and redirects the smaller than operator to EO (fitness based comparison) )}{\pageref{classeo_vector}}{}
\item\contentsline{section}{{\bf Virus\-Bit\-Flip$<$ Fit\-T $>$} (Virus\-Bit\-Flip --$>$ changes 1 bit )}{\pageref{class_virus_bit_flip}}{}
\item\contentsline{section}{{\bf Virus\-Shift\-Mutation$<$ Fit\-T $>$} (Works for 1-bit virus; shifts the one to the right or left )}{\pageref{class_virus_shift_mutation}}{}
\item\contentsline{section}{{\bf eo\-Vl\-Add\-Mutation$<$ EOT $>$} (Addition of a gene Is inserted at a random position - so can be applied to both order-dependent and order-independent )}{\pageref{classeo_vl_add_mutation}}{}
\item\contentsline{section}{{\bf eo\-Vl\-Atom\-Exchange\-Quad\-Op$<$ EOT $>$} (Exchange Crossover using an Atom\-Exchange )}{\pageref{classeo_vl_atom_exchange_quad_op}}{}
\item\contentsline{section}{{\bf eo\-Vl\-Del\-Mutation$<$ EOT $>$} (Deletion of a gene By default at a random position, but a \char`\"{}chooser\char`\"{} can be specified can of course be applied to both order-dependent and order-independent )}{\pageref{classeo_vl_del_mutation}}{}
\item\contentsline{section}{{\bf eo\-Vl\-Uniform\-Bin\-Op$<$ EOT $>$} (Direct Uniform Exchange of genes for Variable Length, BINARY version )}{\pageref{classeo_vl_uniform_bin_op}}{}
\item\contentsline{section}{{\bf eo\-Vl\-Uniform\-Quad\-Op$<$ EOT $>$} (Direct Uniform Exchange of genes (obsolete, already :-) stays there for historical reasons )}{\pageref{classeo_vl_uniform_quad_op}}{}
\item\contentsline{section}{{\bf eo\-Weak\-Elitist\-Replacement$<$ EOT $>$} (Eo\-Weak\-Elitist\-Replacement: a wrapper for other replacement procedures )}{\pageref{classeo_weak_elitist_replacement}}{}
\end{CompactList}
