| eoserial::Array | Represents a JSON array |
| eo::mpi::AssignmentAlgorithm | Contains informations on the available workers and allows to find assignees for jobs |
| gp_parse_tree::parse_tree< T >::base_const_iterator | |
| gp_parse_tree::parse_tree< T >::base_iterator | |
| eoserial::Array::BaseAlgorithm< Container > | Functor which determines how to retrieve the real value contained in a eoserial::Entity at a given place |
| binary_function | |
| eoFunctorBase::binary_function_tag | Tag to identify a binary function in compile time function selection |
| eoutils::BinaryWrapper< Binary > | |
| BinOpWrapper | |
| boolean_generator | The class boolean_generator can be used in the STL generate function to easily generate random booleans with a specified bias |
| CachedPerf2WorthWrapper | |
| MemPool::Chunk | |
| gp_parse_tree::MemPool::Chunk | |
| eo::CMAParams | |
| eo::CMAState | |
| eo::CMAStateImpl | |
| eoPop< EOT >::Cmp | Helper struct for comparing on pointers |
| eoEPReduce< EOT >::Cmp | |
| eoPop< EOT >::Cmp2 | Helper struct for comparing (EA or PSO) |
| eoNthElementFitnessStat< EOT >::CmpFitness | |
| eoBestFitnessStat< EOT >::CmpFitness | |
| eoNDSorting_II< EOT >::compare_nodes | |
| eoPerf2Worth< EOT, WorthT >::compare_worth | Helper class used to sort indices into populations/worths |
| eoPerf2WorthCached< EOT, WorthT >::compare_worth | Helper class used to sort indices into populations/worths |
| gp_parse_tree::parse_tree< T >::const_iterator | |
| dMatrix | Sharing is a perf2worth class that implements Goldberg and Richardson's basic sharing |
| eoSignal< EOT >::DummyContinue | |
| eoNDSorting< EOT >::DummyEO | Used in fast nondominated sorting DummyEO is just a storage place for fitnesses and to store the original index |
| eo::mpi::DummyHandleResponseFunction | Handle response functor which does nothing |
| eo::mpi::DummyIsFinishedFunction | Is finished functor which returns true everytime |
| eo::mpi::DummyJobStore | Job store containing all dummy functors and containing no data |
| eo::mpi::DummyProcessTaskFunction | Process task functor which does nothing |
| eo::mpi::DummySendTaskFunction | Send task functor which does nothing |
| eo::mpi::DynamicAssignmentAlgorithm | Assignment (scheduling) algorithm which handles workers in a queue |
| gp_parse_tree::parse_tree< T >::embedded_const_iterator | |
| gp_parse_tree::parse_tree< T >::embedded_iterator | |
| eo::mpi::EmptyJob | Job to run after a Multi Job, so as to indicate that every workers should terminate |
| eoserial::Entity | JSON entity |
| EO< F > | |
| eo1PtBitCrossover | Eo1PtBitXover --> classic 1-point crossover |
| eo1PtBitXover< Chrom > | |
| eoAlgo< EOT > | This is the base class for population-transforming algorithms |
| eoArithmeticCrossover | EoHypercubeCrossover --> uniform choice in hypercube == arithmetical with different values for each coordinate |
| eoAssembledFitnessAverageStat< EOT > | Average fitness values of a population, where the fitness is of type eoScalarAssembledFitness |
| eoAssembledFitnessBestStat< EOT > | Fitness values of best individuum in a population, where the fitness is of type eoScalarAssembledFitness |
| eoAtomExchange< Atom > | A helper class for choosing which genes to exchange |
| eoAverageSizeStat< EOT > | Compute the average size of indivudals over the population |
| eoAverageStat< EOT > | Average fitness of a population |
| eoBestFitnessStat< EOT > | Best fitness of a population |
| eoBestSelect< EOT > | EoBestSelect: a selection method that always return the best (mainly for testing purposes) |
| eoBF< A1, A2, R > | Basic Binary Functor |
| eoBinaryFlight< POT > | Abstract class for binary flight of particle swarms |
| eoBinaryFunctorCounter< BinaryFunctor > | Generic counter class that counts the number of times a binary function is used |
| eoBinCloneOp< EOT > | Binary clone: two operands, only the first could be modified |
| eoBinGenOp< EOT > | Wrapper for binop: here we use select method of eoPopulator but we could also have an embedded selector to select the second parent |
| eoBinOp< EOType > | Binary genetic operator: subclasses eoOp, 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 |
| eoBit< FitT > | Implementation of bitstring chromosome |
| eoBitGxOver< Chrom > | EoBitGxOver --> Npts crossover when bistd::string considered as a std::string of binary-encoded genes (exchanges genes) Is anybody still using it apart from historians ??? :-) |
| eoBitInversion< Chrom > | EoBitInversion: inverts the bits of the chromosome between an interval |
| eoBitMutation< Chrom > | EoBitMutation --> classical mutation |
| eoBitNext< Chrom > | EoBitNext --> next value when bitstring considered as binary value |
| eoBitOpFactory< EOT > | EO Factory |
| eoBitParticle< FitT > | EoBitParticle: Implementation of a bit-coded particle (swarm optimization) |
| eoBitPrev< Chrom > | EoBitPrev --> previous value when bitstring treated as binary value |
| eoBooleanGenerator | The class eoBooleanGenerator can be used in the STL generate function to easily generate random booleans with a specified bias |
| eoBooleanInit | The class eoBooleanInit can be used in the STL apply function to easily generate random booleans with a specified bias |
| eoBoolFlip | Simple boolean mutation - to be used in generic eoOp's |
| eoBranchMutation< FType, Node > | EoBranchMutation --> replace a subtree with a randomly created subtree |
| eoBreed< EOT > | Breeding: combination of selecting and transforming a population |
| eoCellularEasyEA< EOT > | The abstract cellular easy algorithm |
| eoCheckPoint< EOT > | EoCheckPoint is a container class |
| eoCMABreed< FitT > | |
| eoCMAInit< FitT > | |
| eoCollapseSubtreeMutation< FType, Node > | EoCollapseSubtree --> replace a subtree with a randomly chosen terminal |
| eoCombinedContinue< EOT > | Combined continuators - logical AND: Continues until one of the embedded continuators says halt! |
| eoCombinedInit< EOT > | Combined INIT: a proportional recombination of eoInit objects |
| eoCommaReplacement< EOT > | ES type of replacement strategy: ignore parents, truncate offspring |
| eoConstrictedVariableWeightVelocity< POT > | Inertia variable + constriction velocity for particle swarm optimization |
| eoConstrictedVelocity< POT > | Constricted velocity performer for particle swarm optimization |
| eoContinue< EOT > | Termination condition for the genetic algorithm Takes the population as input, returns true for continue, false for termination |
| eoCountedDynUpdate | An eoUpdater to update an eoUpdatable object every given tic |
| eoCountedStateSaver | EoUpdater that saves a state every given generations |
| eoCtrlCContinue< EOT > | Ctrl C handling: this eoContinue tells whether the user pressed Ctrl C |
| eoDetBitFlip< Chrom > | EoDetBitFlip --> changes exactly k bits |
| eoDeterministicSaDReplacement< EOT > | EoDeterministicSaDReplacement: 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 |
| eoDeterministicSurviveAndDie< EOT > | An instance (theonly one as of today, Dec |
| eoDetSelect< EOT > | EoDetSelect selects many individuals deterministically |
| eoDetSingleBitFlip< Chrom > | EoDetSingleBitFlip --> changes exactly k bits with checking for duplicate |
| eoDetTournamentSelect< EOT > | EoDetTournamentSelect: a selection method that selects ONE individual by deterministic tournament |
| eoDetTournamentTruncate< EOT > | Truncate class based on a repeated deterministic (reverse!) tournament To be used in SSGA-like replacements (e.g |
| eoDetTournamentTruncateSplit< EOT > | ReduceSplit class based on a repeated deterministic (reverse!) tournament To be used in SSGA-like replacements (e.g |
| eoDetTournamentWorthSelect< EOT, WorthT > | An instance of eoSelectPerf2Worth that does selection from the Worthes using a .. |
| eoDetUniformMutation< EOT > | EoDetUniformMutation --> changes exactly k values of the std::vector by uniform choice with range epsilon |
| eoDistance< EOT > | This is a generic class for distance functors: takes 2 things and returns a double |
| eoDistanceStat< EOT > | |
| eoDistribUpdater< EOT > | Base class for Distribution Evolution Algorithms within EO: the update rule of distribution |
| eoDistribution< EOT > | Abstract class for Distribution Evolution Algorithms within EO: the distribution itself |
| eoDoubleExchange | Some basic atomic crossovers for doubles |
| eoDoubleIntermediate | Intermediate crossover == linear combination |
| eoDualFitness< BaseType, Compare > | A fitness class that permits to compare feasible and unfeasible individuals and guaranties that a feasible individual will always be better than an unfeasible one |
| eoDualStatSwitch< EOT, EOSTAT > | Embed two eoStat and call the first one on the feasible individuals and the second one on the unfeasible ones, merge the two resulting value in a string, separated by a given marker |
| eoParticleInitializer< POT >::eoDummy | |
| eoInitializer< POT >::eoDummy | |
| eoParticleInitializer< POT >::eoDummyEval | |
| eoInitializer< POT >::eoDummyEval | |
| eoSyncEasyPSO< POT >::eoDummyEval | |
| eoEasyEA< EOT >::eoDummyEval | |
| eoEasyPSO< POT >::eoDummyFlight | |
| eoSyncEasyPSO< POT >::eoDummyFlight | |
| eoEasyPSO< POT >::eoDummyInitializer | |
| eoSyncEasyPSO< POT >::eoDummyInitializer | |
| eoDummyRealBoundModifier | An eoRealBoundModifier that modify nothing ! |
| eoEasyEA< EOT >::eoDummySelect | |
| eoEasyEA< EOT >::eoDummyTransform | |
| eoDynSGATransform< EOT > | EoDynSGATransform: transforms a population using genetic operators |
| eoDynUpdater | A base class to actually update an eoUpdatable object |
| eoEasyEA< 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 |
| eoEasyPSO< POT > | An easy-to-use particle swarm algorithm |
| eoEDA< EOT > | The abstract class for estimation of disribution algorithms |
| eoEliteSequentialSelect< EOT > | All Individuals in order |
| eoElitism< EOT > | Straightforward elitism class, specify the number of individuals to copy into new geneneration or the rate w.r.t |
| eoEPReduce< EOT > | EP truncation method (some global stochastic tournament + sort) Softer selective pressure than pure truncate |
| eoEPReplacement< EOT > | EP type of replacement strategy: first add parents to population, then truncate using EP tournament |
| eoEsChromInit< EOT > | Random Es-chromosome initializer (therefore derived from eoInit) |
| eoEsFull< Fit > | The most complex evolutionary strategy representation |
| eoEsGlobalXover< EOT > | Global crossover operator for ES genotypes |
| eoEsMutate< EOT > | ES-style mutation in the large |
| eoEsMutationInit | Initialize Mutation operator |
| eoEsSimple< Fit > | Simple Evolution Strategy |
| eoEsStandardXover< EOT > | Standard (i.e |
| eoEsStdev< Fit > | Evolutionary Strategy with a standard deviation per parameter |
| eoEvalContinue< EOT > | Continues until a number of evaluations has been made |
| eoEvalCounterThrowException< EOT > | |
| eoEvalFunc< EOT > | Evaluate: takes one EO and sets its "fitness" property returning this fitness also |
| eoEvalFuncCounter< EOT > | Counts the number of evaluations actually performed |
| eoEvalFuncCounterBounder< EOT > | Counts the number of evaluations actually performed and throw an eoEvalFuncCounterBounderException when the maximum number of allowed evaluations is reached |
| eoEvalFuncCounterBounderException | The exception raised by eoEvalFuncCounterBounder when the maximum number of allowed evaluations is reached |
| eoEvalFuncPtr< EOT, FitT, FunctionArg > | EOEvalFuncPtr: This class takes an existing function pointer and converts it into a evaluation function class |
| eoEvalTimeThrowException< EOT > | Check at each evaluation if a given tie contract has been reached |
| eoExpansionMutation< FType, Node > | EoExpansionMutation --> replace a terminal with a randomly created subtree |
| eoExpDecayingBoundModifier | Modify an eoReal(Base)VectorBounds : At iteration t, the interval I(t)=[min,max] is updated as: I(t)=[min,(1-(t/Nt)^alpha)*max] where |
| eoExtendedVelocity< POT > | Extended velocity performer for particle swarm optimization |
| eoExternalBinOp< F, External, ExternalEO > | Crossover of external struct, ctor expects a function of the following signature: |
| eoExternalEO< Fit, External > | Definition of an object that allows an external struct to be inserted in EO |
| eoExternalEvalFunc< F, External, ExternalEO > | Evaluation of external struct, ctor expects a function of the following signature: |
| eoExternalInit< F, External, ExternalEO > | Initialization of external struct, ctor expects a function of the following signature: |
| eoExternalMonOp< F, External, ExternalEO > | Mutation of external struct, ctor expects a function of the following signature: |
| eoExternalQuadOp< F, External, ExternalEO > | Crossover of external struct, ctor expects a function of the following signature: |
| eoF< R > | Basic Function |
| eoFactory< EOClass > | EO Factory |
| eoFDCFileSnapshot< EOT > | Specific class for FDCStat monitoring: As I failed to have FDC stat as an eoStat, this is the trick to put the 2 eoParam<std::vector<double> > into a monitor This class does nothing else |
| eoFDCStat< EOT > | The Fitness Distance Correlation computation |
| eoFeasibleRatioStat< EOT > | Ratio of the number of individuals with a feasible dual fitness in the population ( |
| eoFileMonitor | Prints statistics to file |
| eoFileSnapshot | Prints snapshots of fitnesses to a (new) file every N generations |
| eoFirstIsBestInit< POT > | Initializes the best positions of a particle as its current positions and set the particle best fitness |
| eoFitContinue< EOT > | Continues until the optimum fitness level is reached |
| eoFitnessDistance< EOT > | |
| eoFitnessScalingSelect< EOT > | EoFitnessScalingSelect: select an individual proportional to the linearly scaled fitness that is computed by the private eoLinearFitScaling object |
| eoFitnessStat< EOT, FitT > | The fitnesses of a whole population, as a vector |
| eoFixedInertiaWeightedVelocity< POT > | Inertia weight based velocity performer |
| eoFlight< POT > | Abstract class for particle swarm optimization flight |
| eoFlOr1ptBinOp< EOT > | The 1pt crossover (just in case someone wants it some day!) |
| eoFlOr1ptQuadOp< EOT > | The 1pt crossover (just in case someone wants it some day!) |
| eoFlOrAllAtomBinOp< EOT > | Generic eoBinOps on fixed length genotypes |
| eoFlOrAllAtomQuadOp< EOT > | Generic eoQuadOps on fixed length genotypes |
| eoFlOrAllMutation< EOT > | Base classes for generic mutations on fixed length chromosomes |
| eoFlOrKAtomBinOp< EOT > | Bin Crossover using an Atom Crossover that is applied to a FIXED NB of components |
| eoFlOrKAtomQuadOp< EOT > | Quad Crossover using an Atom Crossover that is applied to a FIXED NB of components |
| eoFlOrKMutation< EOT > | Applies an atomic mutation to a fixed number of components (1 by default) |
| eoFlOrUniformBinOp< EOT > | The uniform crossover - exchanges atoms uniformly ! |
| eoFlOrUniformQuadOp< EOT > | The uniform crossover - exchanges atoms uniformly ! |
| eoFuncPtrStat< EOT, T > | Wrapper to turn any stand-alone function and into an eoStat |
| eoFunctorBase | Base class for functors to get a nice hierarchy diagram |
| eoFunctorStat< EOT, T > | Wrapper to turn any stand-alone function and into an eoStat |
| eoFunctorStore | EoFunctorStore is a class that stores functors that are allocated on the heap |
| eoG3Replacement< EOT > | EoG3Replacement is an eoReplacement: |
| eoGaussRealWeightUp | Update an inertia weight by assigning it a Gaussian randomized value (used for the velocity in particle swarm optimization) |
| eoGenContinue< EOT > | Generational continuator: continues until a number of generations is reached |
| eoGenCounter | An eoStat that simply gives the current generation index |
| eoGeneDelChooser< EOT > | A helper class for choosing which site to delete |
| eoGeneralBreeder< EOT > | Base class for breeders using generalized operators |
| eoGeneralIntBounds | A class that encapsulate all possible eoIntBounds |
| eoGeneralRealBounds | A class that encapsulate all possible eoIntBounds |
| eoGenerationalReplacement< EOT > | Generational replacement == swap populations |
| eoGenOp< EOT > | The base class for General Operators Subclass this operator is you want to define an operator that falls outside of the eoMonOp, eoBinOp, eoQuadOp classification |
| eoGnuplot | Base class for calls to gnuplot |
| eoGnuplot1DMonitor | Plot eoStat |
| eoGnuplot1DSnapshot | Plot stats through gnuplot |
| eoHammingDistance< 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 |
| eoHoistMutation< FType, Node > | EoHoistMutation --> replace the individual with one of its subtree's |
| eoHowMany | A helper class, to determine a number of individuals from another one Typically, is used in selection / replacement procedures, e.g |
| eoHypercubeCrossover< EOT > | |
| eoIncrementor< T > | EoUpdater that simply increments a counter |
| eoIncrementorParam< T > | EoUpdater that is an eoValueParam (and thus OWNS its counter) Mandatory for generation counter in make_checkpoint |
| eoInit< EOT > | Base (name) class for Initialization of chromosomes, used in a population contructor |
| eoInitAdaptor< EOT > | EoInitAdaptor changes the place in the hierarchy from eoInit to eoMonOp |
| eoInitFixedLength< EOT > | Initializer for fixed length representations with a single type |
| eoInitGenerator< EOT > | Turning an eoInit into a generator probably we should only use genrators - and suppress eoInit ??? MS - July 2001 |
| eoInitializer< POT > | Base (name) class for Initialization of algorithm PSO |
| eoInitializerBase< POT > | Abstract class for initialization of algorithm PSO |
| eoInitPermutation< EOT > | Initializer for permutation (integer-based) representations |
| eoInitVariableLength< EOT > | Initializer for variable length representations with a single type |
| eoInnerExchangeQuadOp< EOT > | Crossover using an AtomCrossover |
| eoInt< FitT > | EoInt: implementation of simple integer-valued chromosome |
| eoIntAboveBound | An eoIntBound bounded from above only |
| eoIntBelowBound | EoIntBound bounded from below only |
| eoIntBounds | Defines bound classes for real numbers |
| eoIntegerVelocity< POT > | Integer velocity performer for particle swarm optimization |
| eoInterquartileRangeStat< EOT > | A robust measure of dispersion (also called midspread or middle fifty) that is the difference between the third and the first quartile |
| eoIntInterval | Fully bounded eoIntBound == interval |
| eoIntNoBounds | A default class for unbounded variables |
| eoInvalidateBinOp< EOT > | One of the invalidator operators |
| eoInvalidateMonOp< EOT > | |
| eoInvalidateQuadOp< EOT > | One of the invalidator operators |
| eoLinearDecreasingWeightUp< WeightType, StopCriteriaType > | Linear (inertia) weight updater for particle swarm optimization |
| eoLinearFitScaling< EOT > | An instance of eoPerf2Worth COmputes the linearly scaled fitnesses with given selective pressure Pselect(Best) == pressure/sizePop Pselect(average) == 1.0/sizePop truncate negative values to 0 - |
| eoLinearRandomSplit< EOT > | Random truncation - linear version |
| eoLinearTopology< POT > | One of the local best strategies for particle swarm optimization |
| eoLinearTruncate< EOT > | Truncate class that does not sort, but repeatidely kills the worse |
| eoLinearTruncateSplit< EOT > | ReduceSplit class that does not sort, but repeatidely kills the worse |
| eoLogger | EoLogger Class providing a verbose management through EO Use of a global variable eo::log to easily use the logger like std::cout |
| eoMaxEvalException | |
| eoMaxException | |
| eoMaxTimeException | |
| eoMerge< Chrom > | EoMerge: Base class for elitist replacement algorithms |
| eoMergeReduce< EOT > | EoMergeReduce: abstract replacement strategy that is just an application of an embedded merge, followed by an embedded reduce |
| eoMGGReplacement< EOT > | EoMGGReplacement is an eoReplacement: |
| eoMissingParamException | |
| eoMOFitnessStat< EOT, PartFitT > | For multi-objective fitness, we need to translate a stat<vector<double> > into a vector<stat>, so each objective gets a seperate stat |
| eoMonCloneOp< EOT > | Mon clone: one argument |
| eoMonGenOp< EOT > | Wrapper for eoMonOp |
| eoMonitor | The abstract monitor class is a std::vector of parameter pointers |
| eoMonOp< EOType > | EoMonOp is the monary operator: genetic operator that takes only one EO |
| eoNDSorting< EOT > | Non dominated sorting, it *is a* 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 |
| eoNDSorting_I< EOT > | The original Non Dominated Sorting algorithm from Srinivas and Deb |
| eoNDSorting_II< EOT > | Fast Elitist Non-Dominant Sorting Genetic Algorithm |
| eoNegExpGenerator< T > | The class negexp_generator can be used in the STL generate function to easily generate negative exponential distributed floats and doubles |
| eoNegExpInit< T > | The class negexp_generator can be used in the STL generate function to easily generate negative exponential distributed floats and doubles |
| eoNeighborhood< POT > | Abstract class for neighborboods |
| eoNoElitism< EOT > | No elite |
| eoNoPerf2Worth< EOT > | A dummy perf2worth, just in case you need it |
| eoNormalGenerator< T > | The class normal_generator can be used in the STL generate function to easily generate gaussian distributed floats and doubles |
| eoNormalInit< T > | The class normal_generator can be used in the STL generate function to easily generate gaussian distributed floats and doubles |
| eoNormalMutation< EOT > | Simple normal mutation of a std::vector of real values |
| eoNormalVecMutation< EOT > | Simple normal mutation of a std::vector of real values |
| eoNoSelect< EOT > | EoNoSelect: returns all individual in order WITHOUT USING FITNESS!!! looping back to the beginning when exhasuted |
| eoNPtsBitXover< Chrom > | EoNPtsBitXover --> n-point crossover |
| eoNthElementFitnessStat< EOT > | The n_th element fitness in the population (see eoBestFitnessStat) |
| eoObject | Defines a name (className#), used when loading or saving a state |
| eoOneBitFlip< Chrom > | EoOneBitFlip --> changes 1 bit |
| eoOneFifthMutation< EOT > | Dynamic version: just say it is updatable - and write the update() method! here the 1 fifth rule: count the proportion of successful mutations, and increase sigma if more than threshold (1/5 !) |
| eoOneToOneBreeder< EOT > | EoOneToOneBreeder: transforms a population using |
| eoOp< EOType > | Abstract data types for EO operators |
| eoOpContainer< EOT > | EoOpContainer 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 |
| eoOpSelMason< eoClass > | EO Mason, or builder, for operator selectors |
| eoOrderXover< Chrom > | Apply orderXover on two chromosomes |
| eoOStreamMonitor | Prints statistics to a given ostream |
| eoParallel | EoParallel Class providing parameters for parallelization Use of a global variable eo::parallel to easily use the parallelization parameters anywhere |
| eoParam | EoParam: Base class for monitoring and parsing parameters |
| eoParameterLoader | Parameter saving and loading |
| eoParamParamType | Another helper class for parsing parameters like Keyword(arg1, arg2, ...) |
| eoParser | EoParser: command line parser and configuration file reader This class is persistent, so it can be stored and reloaded to restore parameter settings |
| eoParseTree< FType, Node > | Implementation of parse-tree for genetic programming |
| eoParseTreeDepthInit< FType, Node > | EoParseTreeDepthInit : the initializer class for eoParseTree |
| eoParticleBestInit< POT > | Abstract class for particle best position initialization |
| eoParticleInitializer< POT > | Base (name) class for Initialization of algorithm PSO |
| eoPBILAdditive< EOT > | Distribution Class for PBIL algorithm (Population-Based Incremental Learning, Baluja and Caruana 96) |
| eoPBILDistrib< EOT > | Distribution Class for PBIL algorithm (Population-Based Incremental Learning, Baluja and Caruana 96) |
| eoPBILOrg< EOT > | Distribution Class for PBIL algorithm (Population-Based Incremental Learning, Baluja and Caruana 95) |
| eoPerf2Worth< EOT, WorthT > | Base class to transform raw fitnesses into fitness for selection |
| eoPerf2WorthCached< EOT, WorthT > | Perf2Worth with fitness cache |
| eoPeriodicContinue< EOT > | A continue that becomes true periodically |
| eoPersistent | An persistent object that knows how to write (through functions inherited from eoPrintable#) and read itself |
| eoPlus< EOT > | Very elitist class, copies entire population into next gen |
| eoPlusReplacement< EOT > | ES type of replacement strategy: first add parents to population, then truncate |
| eoPointMutation< FType, Node > | EoPointMutation --> replace a Node with a Node of the same arity |
| eoPop< EOT > | A std::vector of EO object, to be used in all algorithms (selectors, operators, replacements, ...) |
| eoPopEvalFunc< EOT > | EoPopEvalFunc: This abstract class is for GLOBAL evaluators of a population after variation |
| eoPopLoopEval< EOT > | EoPopLoopEval: an instance of eoPopEvalFunc that simply applies a private eoEvalFunc to all offspring |
| eoPopStat< EOT > | WARNING: this file contains 2 classes: |
| eoPopulator< EOT > | EoPopulator is a helper class for general operators eoGenOp It is an eoPop but also behaves like an eoPop::iterator as far as operator* and operator++ are concerned |
| eoPrintable | Base class for objects that can print themselves (printOn#) |
| eoProcedureCounter< Procedure > | Generic counter class that counts the number of times a procedure is used |
| eoPropCombinedBinOp< EOT > | COmbined Binary genetic operator: operator() has two operands, only the first one can be modified |
| eoPropCombinedMonOp< EOT > | EoMonOp is the monary operator: genetic operator that takes only one EO |
| eoPropCombinedQuadOp< EOT > | Quad genetic operator: subclasses eoOp, and defines basically the operator() with two operands, both can be modified |
| eoPropGAGenOp< EOT > | EoPropGAGenOp (for Simple GA, but Proportional) choice between Crossover, mutation or cloining with respect to given relatve weights |
| eoProportionalOp< EOT > | The proportional versions: easy! |
| eoProportionalSelect< EOT > | EoProportionalSelect: select an individual proportional to her stored fitness value |
| eoPSO< POT > | This is a generic class for particle swarm algorithms |
| eoQuad2BinOp< EOT > | Turning an eoQuadOp into an eoBinOp: simply don't touch the second arg! |
| eoQuadCloneOp< EOT > | Quad clone: two operands, both could be modified - but are not! |
| eoQuadDistance< 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 |
| eoQuadGenOp< EOT > | Wrapper for quadop: easy as pie |
| eoQuadOp< EOType > | Quad genetic operator: subclasses eoOp, and defines basically the operator() with two operands, both can be modified |
| eoRandomRealWeightUp | Update an inertia weight by assigning it an (uniform) random value |
| eoRandomReduce< EOT > | Random truncation |
| eoRandomSelect< EOT > | This file contains straightforward selectors: eoRandomSelect returns an individual uniformly selected eoBestSelect always return the best individual eoSequentialSelect returns all individuals in turn |
| eoRandomSplit< EOT > | Random truncation - batch version |
| eoRanking< EOT > | An instance of eoPerfFromWorth COmputes the ranked fitness: fitnesses range in [m,M] with m=2-pressure/popSize and M=pressure/popSize |
| eoRankingSelect< EOT > | EoRankingSelect: select an individual by roulette wheel on its rank is an eoRouletteWorthSelect, i.e |
| eoRankMuSelect< EOT > | Selects the "Mu" bests individuals |
| eoReal< FitT > | EoReal: implementation of simple real-valued chromosome |
| eoRealAboveBound | An eoRealBound bounded from above only |
| eoRealBaseVectorBounds | Vector type for bounds (see eoRealBounds.h for scalar types) |
| eoRealBelowBound | EoRealBound bounded from below only |
| eoRealBoundModifier | Abstract class for eoRealVectorBounds modifier |
| eoRealBounds | Defines bound classes for real numbers |
| eoRealInitBounded< EOT > | Simple initialization for any EOT that derives from std::vector<double> uniformly in some bounds |
| eoRealInterval | Fully bounded eoRealBound == interval |
| eoRealNoBounds | A default class for unbounded variables |
| eoRealParticle< FitT > | EoRealParticle: Implementation of a real-coded particle for particle swarm optimization |
| eoRealUxOver | EoRealUxOver --> Uniform crossover, also termed intermediate crossover |
| eoRealUXover< EOT > | |
| eoRealVectorBounds | Now a derived class, for parser reading It holds some of the bounds (and destroy them when dying) |
| eoRealVectorNoBounds | Dummy unbounded eoRealVectorBounds: usefull if you don't need bounds! everything is inlined |
| eoReduce< EOT > | EoReduce: .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 |
| eoReduceMerge< EOT > | EoReduceMerge: Replacement strategies that start by reducing the parents, then merge with the offspring |
| eoReduceMergeReduce< EOT > | EoReduceMergeReduce is an eoReplacement: |
| eoReduceSplit< EOT > | EoReduceSplit: reduce the pop to the specified size AND eventually returns the eliminated guys |
| eoReduceWrapper | |
| eoReplacement< EOT > | The base class for all replacement functors |
| eoRingTopology< POT > | Static ring topology for particle swarm optimization |
| eoRndGenerator< T > | By popular demand re-introducing a base class for a family of random number generators |
| eoRng | Random Number Generator |
| eoRouletteWorthSelect< EOT, WorthT > | An instance of eoSelectPerf2Worth that does selection from the Worthes using a .. |
| eoSBXCrossover< EOT > | |
| eoScalarFitness< ScalarType, Compare > | Wraps a scalar fitness values such as a double or int, with the option of maximizing (using less<ScalarType>) or minimizing (using greater<ScalarType>) |
| eoScalarFitnessAssembled< ScalarType, Compare, FitnessTraits > | Implements fitness as std::vector, storing all values that might occur during fitness assembly |
| eoScalarFitnessAssembledTraits | Defines properties of eoScalarFitnessAssembled |
| eoScalarFitnessStat< EOT, FitT > | The fitnesses of a whole population, as a std::vector |
| eoSecondMomentStats< EOT > | Average fitness + Std |
| eoSecondsElapsedContinue< EOT > | Timed continuator: continues until a number of seconds is used |
| eoSegmentCrossover< EOT > | EoSegmentCrossover --> uniform choice in segment == arithmetical with same value along all coordinates |
| eoSelBinGenOp< EOT > | Wrapper for eoBinOp with a selector |
| eoSelect< EOT > | EoSelect selects a number of individuals from the first argument and puts it in the second |
| eoSelectFactory< EOT > | EO Factory.An instance of the factory class to create selectors, that is, eoSelect objects |
| eoCellularEasyEA< EOT >::eoSelectFirstOne | |
| eoSelectFromWorth< EOT, WorthType > | Selects one element from a population (is an eoSelectOne) but the selection is based on a std::vector of Worth that is different from the fitnesses (e.g |
| eoSelectivePopulator< EOT > | SelectivePopulator an eoPoplator that uses an eoSelectOne to select guys |
| eoSelectMany< EOT > | EoSelectMany selects many individuals using eoSelectOne as it's mechanism |
| eoSelectNumber< EOT > | EoSelectNumber selects many individuals using eoSelectOne as it's mechanism |
| eoSelectOne< EOT, WorthT > | EoSelectOne selects only one element from a whole population |
| eoSelectOneWrapper | |
| eoSelectPerc< EOT > | EoSelectPerc selects many individuals using eoSelectOne as it's mechanism |
| eoSelectTransform< EOT > | Embedded select, followed by an embedded transform |
| eoSeqPopulator< EOT > | SeqPopulator: an eoPopulator that sequentially goes through the population is supposed to be used after a batch select of a whole bunch or genitors |
| eoSequentialOp< 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.. |
| eoSequentialSelect< EOT > | Contains the following classes: |
| eoSGA< EOT > | The Simple Genetic Algorithm, following Holland and Goldberg |
| eoSGAGenOp< EOT > | EoSGAGenOp (for Simple GA) mimicks the usual crossover with proba pCross + mutation with proba pMut inside an eoGeneralOp It does it exactly as class eoSGATransform, i.e |
| eoSGATransform< EOT > | EoSGATransform: transforms a population using genetic operators |
| eoSharing< EOT > | Sharing is a perf2worth class that implements Goldberg and Richardson's basic sharing see eoSharingSelect for how to use it and test/t-eoSharing.cpp for a sample use of both |
| eoSharingSelect< EOT > | EoSharingSelect: select an individual by roulette wheel on its SHARED fitness |
| eoShiftMutation< EOT > | Shift two components of a chromosome |
| eoSigBinaryFlight< POT > | Binary flight for particle swarm optimization based on the sigmoid function |
| eoSIGContinue< EOT > | A continuator that stops if a given signal is received during the execution |
| eoSignal< EOT > | EoSignal inherits from eoCheckPoint including signals handling (see signal(7)) |
| eoSimpleEDA< EOT > | A very simple Estimation of Distribution Algorithm |
| eoSocialNeighborhood< POT > | Derivated from eoNeighborhood |
| eoSortedPopStat< EOT > | Thanks to MS/VC++, eoParam mechanism is unable to handle std::vectors of stats |
| eoSortedStat< EOT, ParamType > | The actual class that will be used as base for all statistics that need to be calculated over the sorted population It's an eoSortedStatBase AND an eoValueParam so it can be used in Monitors |
| eoSortedStatBase< EOT > | Base class for statistics calculated over a sorted snapshot of the population |
| eoSSGADetTournamentReplacement< EOT > | SSGA deterministic tournament replacement |
| eoSSGAStochTournamentReplacement< EOT > | SSGA stochastic tournament replacement |
| eoSSGAWorseReplacement< EOT > | SSGA replace worst |
| eoStandardFlight< POT > | Standard flight for particle swarm optimization |
| eoStandardVelocity< POT > | Standard velocity performer for particle swarm optimization |
| eoStarTopology< POT > | Topology dedicated to "globest best" strategy for particle swarm optimization |
| eoStat< 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 eoStatBase AND an eoValueParam so it can be used in Monitors |
| eoStatBase< EOT > | Base class for all statistics that need to be calculated over the (unsorted) population (I guess it is not really necessary? MS |
| eoState | EoState can be used to register derivants of eoPersistent |
| eoStBranchMutation< FType, Node > | EoStBranchMutation --> replace a strongly typed subtree with a randomly created strongly typed subtree |
| eoStdoutMonitor | Prints statistics to stdout |
| eoSteadyFitContinue< EOT > | A continuator: does a minimum number of generations, then stops whenever a given number of generations takes place without improvement |
| eoStHoistMutation< FType, Node > | EoStHoistMutation --> replace the individual with one of its strongly typed subtree's |
| eoSTLBF< A1, A2, R > | Generic set of classes that wrap an eoF, eoUF or eoBF so that they have the copy semantics the STL functions usually require (i.e |
| eoSTLF< R > | Generic set of classes that wrap an eoF, eoUF or eoBF so that they have the copy semantics the STL functions usually require (i.e |
| eoSTLUF< A1, R > | Generic set of classes that wrap an eoF, eoUF or eoBF so that they have the copy semantics the STL functions usually require (i.e |
| eoStochasticUniversalSelect< EOT > | EoStochasticUniversalSelect: select an individual proportional to her stored fitness value, but in contrast with eoStochasticUniversalSelect, get rid of most finite sampling effects by doing all selections in one go, using a single random number |
| eoStochTournamentSelect< EOT > | EoStochTournamentSelect: a selection method that selects ONE individual by binary stochastic tournament |
| eoStochTournamentTruncate< EOT > | Truncate class based on a repeated deterministic (reverse!) tournament To be used in SSGA-like replacements (e.g |
| eoStochTournamentTruncateSplit< EOT > | ReduceSplit class based on a repeated deterministic (reverse!) tournament To be used in SSGA-like replacements (e.g |
| eoStochTournamentWorthSelect< EOT, WorthT > | An instance of eoSelectPerf2Worth that does selection from the Worthes using a .. |
| eoStParseTreeDepthInit< FType, Node > | EoStParseTreeDepthInit : the initializer class for strongly typed tree-based genetic programming |
| eoStPointMutation< FType, Node > | EoStPointMutation --> replace a Node with a Node of the same arity and type |
| eoString< fitnessT > | Adaptor that turns an STL std::string into an EO |
| eoStSubtreeXOver< FType, Node > | EoStSubtreeXOver --> subtree xover for strongly typed tree-based genetic programming |
| eoSubtreeXOver< FType, Node > | EoSubtreeXOver --> subtree xover |
| eoSurviveAndDie< EOT > | EoSurviveAndDie A pure abstract class, to store the howmany's |
| eoSwapMutation< Chrom > | Swap two components of a chromosome |
| eoSyncEasyPSO< POT > | An easy-to-use synchronous particle swarm algorithm; you can use any particle, any flight, any topology.. |
| eoTimeContinue< EOT > | Termination condition until a running time is reached |
| eoTimeCounter | An eoStat that simply gives the user time since first generation It has to be tempatized by EOT because it must be an eoStat |
| eoTimedDynUpdate | An eoUpdater to update an eoUpdatable object every given time interval |
| eoTimedMonitor | Holds a collection of monitors and only fires them when a time limit has been reached |
| eoTimedStateSaver | EoUpdater that saves a state every given time interval |
| eoTimer | Timer allowing to measure time between a start point and a stop point |
| eoTimerStat | Registers a group of statistics, each statistic corresponding to user, system and wallclock times distribution |
| eoTimeVaryingLoopEval< EOT > | EoPopLoopEval: an instance of eoPopEvalFunc that simply applies a private eoEvalFunc to all offspring AND ALL PARENTS as the fitness is supposed here to vary |
| eoTopology< POT > | Defines the interface of a swarm topology |
| eoTransform< EOT > | EoTransform transforms a population by applying genetic operators on it |
| eoTruncate< EOT > | Truncation method using sort |
| eoTruncatedSelectMany< EOT > | EoTruncatedSelectMany selects many individuals using eoSelectOne as it's mechanism |
| eoTruncatedSelectOne< EOT > | EoTruncatedSelectOne selects one individual using eoSelectOne as it's mechanism |
| eoTruncateSplit< EOT > | Deterministic truncation method using sort |
| eoTruncSelect< EOT > | EoTruncSelect selects individuals after truncating the population using eoSelectOne as it's mechanism |
| eoTwoOptMutation< EOT > | Especially designed for combinatorial problem such as the TSP |
| eoUBitXover< Chrom > | EoUBitXover --> classic Uniform crossover |
| eoUF< A1, R > | Basic Unary Functor |
| eoUnaryFunctorCounter< UnaryFunctor > | Generic counter class that counts the number of times a unary function is used |
| eoUniformAtomExchange< Atom > | Uniform crossover - well, not really, efficient for FixedLength |
| eoUniformGeneChooser< EOT > | Uniform choice of gene to delete |
| eoUniformGenerator< T > | The class eoUniform can be used in the STL generate function to easily generate random floats and doubles |
| eoUniformInit< T > | The class eoUniformInit can be used in the STL apply function to easily randomize floats and doubles |
| eoUniformMutation< EOT > | EoUniformMutation --> changes all values of the std::vector by uniform choice with range epsilon with probability p_change per variable |
| eoUpdatable | EoUpdatable is a generic class for adding updatation to an existing class Just says it has an update() method |
| eoUpdater | EoUpdater is a generic procudere for updating whatever you want |
| eoValueParam< ValueType > | EoValueParam<ValueType>: templatized derivation of eoParam |
| eoVariableInertiaWeightedVelocity< POT > | Inertia variable weight based velocity for particle swarm optimization |
| eoVector< FitT, GeneType > | Base class for fixed length chromosomes |
| eoVectorParticle< FitT, PositionType, VelocityType > | Main class for particle representation of particle swarm optimization |
| eoVelocity< POT > | Abstract class for velocities calculation (particle swarm optimization) |
| eoVelocityInit< POT > | Abstract class for velocities initilization of particle swarm optimization |
| eoVelocityInitFixedLength< POT > | Initializer for fixed length velocities with a single type |
| eoVelocityInitGenerator< POT > | Provides a particle initialized thanks to the eoVelocityInit object given |
| eoVelocityInitVariableLength< POT > | Initializer for variable length velocitys with a single type |
| eoVlAddMutation< EOT > | Base classes for generic mutations on variable length chromosomes |
| eoVlAtomExchangeQuadOp< EOT > | Exchange Crossover using an AtomExchange |
| eoVlDelMutation< EOT > | Deletion of a gene By default at a random position, but a "chooser" can be specified can of course be applied to both order-dependent and order-independent |
| eoVlUniformBinOp< EOT > | Direct Uniform Exchange of genes for Variable Length, BINARY version |
| eoVlUniformQuadOp< EOT > | Direct Uniform Exchange of genes (obsolete, already :-) stays there for historical reasons |
| eoWeakElitistReplacement< EOT > | EoWeakElitistReplacement: a wrapper for other replacement procedures |
| eoWeightUpdater< WeightType > | Abstract class for (inertia) weight updater (particle swarm optimization) |
| eoWrongParamTypeException | |
| eo::file | File this structure combined with the friend operator<< below is an easy way to select a file as output |
| eo::mpi::Job< JobData >::FinallyBlock | Finally block of the main algorithm |
| GenOpWrapper | |
| eoPop< EOT >::GetFitness | |
| eo::mpi::HandleResponseFunction< JobData > | Functor (master side) used to indicate what to do when receiving a response |
| eo::mpi::HandleResponseParallelApply< EOT > | Handle response functor implementation for the parallel apply (map) job |
| index_error | |
| eo::mpi::IsFinishedFunction< JobData > | Functor (master side) indicating whether the job is done or not |
| eo::mpi::IsFinishedParallelApply< EOT > | Is finished functor implementation for the parallel apply (map) job |
| gp_parse_tree::parse_tree< T >::iterator | |
| eo::mpi::Job< JobData > | Class implementing the centralized job algorithm |
| eo::mpi::JobStore< JobData > | Contains all the required data and the functors to launch a job |
| gp_parse_tree::MemPool::Link | |
| MemPool::Link | |
| eoState::loading_error | Loading error thrown when nothing seems to work |
| lower_triangular_matrix | |
| eoParseTreeDepthInit< FType, Node >::lt_arity | |
| eoserial::MakeAlgorithm< T > | Push algorithm for primitive variables |
| gp_parse_tree::MemPool | Pool allocator for the subtree and parse tree classes (homebrew and not compliant to ANSI allocator requirements) (c) copyright Maarten Keijzer 1999, 2000 |
| MemPool | Pool allocator for the subtree and parse tree classes (homebrew and not compliant to ANSI allocator requirements) (c) copyright Maarten Keijzer 1999, 2000 |
| MonitorWrapper | |
| MonOpWrapper | |
| eo::mpi::MultiJob< JobData > | Job that will be launched an unknown amount of times, in worker side |
| negexp_generator< T > | The class negexp_generator can be used in the STL generate function to easily generate negative exponential distributed floats and doubles |
| eo::mpi::Node | Global object used to reach boost::mpi::communicator everywhere |
| gp_parse_tree::Node_alloc< T > | |
| Node_alloc< T > | |
| normal_generator< T > | The class normal_generator can be used in the STL generate function to easily generate gaussian distributed floats and doubles |
| eoserial::Object | JSON Object |
| eo::mpi::OneShotJob< JobData > | Job that will be launched only once |
| eoLogger::outbuf | Outbuf this class inherits from std::streambuf which is used by eoLogger to write the buffer in an output stream |
| eoSeqPopulator< EOT >::OutOfIndividuals | |
| eoPopulator< EOT >::OutOfIndividuals | |
| eo::mpi::ParallelApply< EOT > | Parallel apply job |
| eo::mpi::ParallelApplyAssignment | Structure used to save assignment to a worker, i.e which slice of the table it has to process |
| eo::mpi::ParallelApplyData< EOT > | Data useful for a parallel apply (map) |
| eo::mpi::ParallelApplyStore< EOT > | Store containing all the datas and the functors for the parallel apply (map) job |
| ParamWrapper | |
| gp_parse_tree::parse_tree< T > | |
| eoserial::Parser | Parser from a JSON source |
| Perf2WorthWrapper | |
| eoserial::Persistent | Interface showing that object can be eoserialized (written and read from an input) |
| PipeCommunication | |
| PO< F > | PO inheriting from EO is specially designed for particle swarm optimization particle.POs have got a fitness, which at the same time needs to be only an object with the operation less than (<) defined |
| PopulatorWrapper | |
| eoserial::Printable | Interface showing that object can be written to a eoserial type (currently JSON) |
| eoFunctorBase::procedure_tag | Tag to identify a procedure in compile time function selection |
| eo::mpi::ProcessTaskFunction< JobData > | Functor (worker side) implementing the processing to do |
| eo::mpi::ProcessTaskParallelApply< EOT > | Process task functor implementation for the parallel apply (map) job |
| eoutils::ProcWrapper< Proc > | |
| eoserial::PushAlgorithm< T > | Functor which explains how to push the value into the eoserial::Array |
| PyEO | |
| PyEO_pickle_suite | |
| PyFitness | |
| pyPop_pickle_suite | |
| QuadOpWrapper | |
| 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) |
| eoPop< EOT >::Ref | Helper struct for getting a pointer |
| RNG_pickle_suite | |
| eo::mpi::SendTaskFunction< JobData > | Functor (master side) used to send a task to the worker |
| eo::mpi::SendTaskParallelApply< EOT > | Send task functor implementation for the parallel apply (map) job |
| eoserial::SerializablePushAlgorithm< T > | Push algorithm for eoserial::Persistent variables |
| eo::setlevel | Setlevel this structure combined with the friend operator<< below is an easy way to set a verbose level |
| eo::mpi::SharedDataFunction< JobData, Wrapped > | Base class for the 4 algorithm functors |
| SortedStatBaseWrapper | |
| eoNDSorting< EOT >::Sorter | |
| square_matrix | |
| gp_parse_tree::Standard_alloc< T > | |
| Standard_alloc< T > | |
| Standard_Node_alloc< T > | |
| gp_parse_tree::Standard_Node_alloc< T > | |
| eoTimerStat::Stat | Statistic related to a key (name) |
| StatBaseWrapper | |
| eo::mpi::StaticAssignmentAlgorithm | Assignment algorithm which gives to each worker a precise number of tasks to do, in a round robin fashion |
| eoserial::String | JSON String |
| gp_parse_tree::parse_tree< T >::subtree | |
| T_pickle_suite< T > | Implements pickle support for eoPersistent derivatives |
| Tree_alloc< T > | |
| gp_parse_tree::Tree_alloc< T > | |
| UF_random_generator< T > | Another class random_generator that can be used in the STL random_shuffle function (see eoPop::shuffle): its operator() takes an unsigned argument m and must return an unsigned uniformly distributed in [0,m} |
| unary_function | |
| eoFunctorBase::unary_function_tag | Tag to identify a unary function in compile time function selection |
| eoutils::UnaryWrapper< Unary > | |
| 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) |
| eoserial::Array::UnpackAlgorithm< C > | BaseAlgorithm for retrieving primitive variables |
| eoserial::Array::UnpackObjectAlgorithm< C > | BaseAlgorithm for retrieving eoserial::Persistent objects |
| ValueParam | |
| ValueParam_pickle_suite< T > | |
| vector | |
1.7.6.1 
