EvolvingObjects
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
eoserial::ArrayRepresents a JSON array
eo::mpi::AssignmentAlgorithmContains 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_tagTag to identify a binary function in compile time function selection
eoutils::BinaryWrapper< Binary >
BinOpWrapper
boolean_generatorThe 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 >::CmpHelper struct for comparing on pointers
eoEPReduce< EOT >::Cmp
eoPop< EOT >::Cmp2Helper struct for comparing (EA or PSO)
eoNthElementFitnessStat< EOT >::CmpFitness
eoBestFitnessStat< EOT >::CmpFitness
eoNDSorting_II< EOT >::compare_nodes
eoPerf2Worth< EOT, WorthT >::compare_worthHelper class used to sort indices into populations/worths
eoPerf2WorthCached< EOT, WorthT >::compare_worthHelper class used to sort indices into populations/worths
gp_parse_tree::parse_tree< T >::const_iterator
dMatrixSharing is a perf2worth class that implements Goldberg and Richardson's basic sharing
eoSignal< EOT >::DummyContinue
eoNDSorting< EOT >::DummyEOUsed in fast nondominated sorting DummyEO is just a storage place for fitnesses and to store the original index
eo::mpi::DummyHandleResponseFunctionHandle response functor which does nothing
eo::mpi::DummyIsFinishedFunctionIs finished functor which returns true everytime
eo::mpi::DummyJobStoreJob store containing all dummy functors and containing no data
eo::mpi::DummyProcessTaskFunctionProcess task functor which does nothing
eo::mpi::DummySendTaskFunctionSend task functor which does nothing
eo::mpi::DynamicAssignmentAlgorithmAssignment (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::EmptyJobJob to run after a Multi Job, so as to indicate that every workers should terminate
eoserial::EntityJSON entity
EO< F >
eo1PtBitCrossoverEo1PtBitXover --> classic 1-point crossover
eo1PtBitXover< Chrom >
eoAlgo< EOT >This is the base class for population-transforming algorithms
eoArithmeticCrossoverEoHypercubeCrossover --> 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
eoBooleanGeneratorThe class eoBooleanGenerator can be used in the STL generate function to easily generate random booleans with a specified bias
eoBooleanInitThe class eoBooleanInit can be used in the STL apply function to easily generate random booleans with a specified bias
eoBoolFlipSimple 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
eoCountedDynUpdateAn eoUpdater to update an eoUpdatable object every given tic
eoCountedStateSaverEoUpdater 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
eoDoubleExchangeSome basic atomic crossovers for doubles
eoDoubleIntermediateIntermediate 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
eoDummyRealBoundModifierAn eoRealBoundModifier that modify nothing !
eoEasyEA< EOT >::eoDummySelect
eoEasyEA< EOT >::eoDummyTransform
eoDynSGATransform< EOT >EoDynSGATransform: transforms a population using genetic operators
eoDynUpdaterA 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
eoEsMutationInitInitialize 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
eoEvalFuncCounterBounderExceptionThe 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
eoExpDecayingBoundModifierModify 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 (
eoFileMonitorPrints statistics to file
eoFileSnapshotPrints 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
eoFunctorBaseBase class for functors to get a nice hierarchy diagram
eoFunctorStat< EOT, T >Wrapper to turn any stand-alone function and into an eoStat
eoFunctorStoreEoFunctorStore is a class that stores functors that are allocated on the heap
eoG3Replacement< EOT >EoG3Replacement is an eoReplacement:
eoGaussRealWeightUpUpdate 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
eoGenCounterAn 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
eoGeneralIntBoundsA class that encapsulate all possible eoIntBounds
eoGeneralRealBoundsA 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
eoGnuplotBase class for calls to gnuplot
eoGnuplot1DMonitorPlot eoStat
eoGnuplot1DSnapshotPlot 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
eoHowManyA 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
eoIntAboveBoundAn eoIntBound bounded from above only
eoIntBelowBoundEoIntBound bounded from below only
eoIntBoundsDefines 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
eoIntIntervalFully bounded eoIntBound == interval
eoIntNoBoundsA 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
eoLoggerEoLogger 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
eoMonitorThe 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)
eoObjectDefines 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
eoOStreamMonitorPrints statistics to a given ostream
eoParallelEoParallel Class providing parameters for parallelization Use of a global variable eo::parallel to easily use the parallelization parameters anywhere
eoParamEoParam: Base class for monitoring and parsing parameters
eoParameterLoaderParameter saving and loading
eoParamParamTypeAnother helper class for parsing parameters like Keyword(arg1, arg2, ...)
eoParserEoParser: 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
eoPersistentAn 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
eoPrintableBase 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
eoRandomRealWeightUpUpdate 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
eoRealAboveBoundAn eoRealBound bounded from above only
eoRealBaseVectorBoundsVector type for bounds (see eoRealBounds.h for scalar types)
eoRealBelowBoundEoRealBound bounded from below only
eoRealBoundModifierAbstract class for eoRealVectorBounds modifier
eoRealBoundsDefines bound classes for real numbers
eoRealInitBounded< EOT >Simple initialization for any EOT that derives from std::vector<double> uniformly in some bounds
eoRealIntervalFully bounded eoRealBound == interval
eoRealNoBoundsA default class for unbounded variables
eoRealParticle< FitT >EoRealParticle: Implementation of a real-coded particle for particle swarm optimization
eoRealUxOverEoRealUxOver --> Uniform crossover, also termed intermediate crossover
eoRealUXover< EOT >
eoRealVectorBoundsNow a derived class, for parser reading It holds some of the bounds (and destroy them when dying)
eoRealVectorNoBoundsDummy 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
eoRngRandom 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
eoScalarFitnessAssembledTraitsDefines 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
eoStateEoState can be used to register derivants of eoPersistent
eoStBranchMutation< FType, Node >EoStBranchMutation --> replace a strongly typed subtree with a randomly created strongly typed subtree
eoStdoutMonitorPrints 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
eoTimeCounterAn eoStat that simply gives the user time since first generation It has to be tempatized by EOT because it must be an eoStat
eoTimedDynUpdateAn eoUpdater to update an eoUpdatable object every given time interval
eoTimedMonitorHolds a collection of monitors and only fires them when a time limit has been reached
eoTimedStateSaverEoUpdater that saves a state every given time interval
eoTimerTimer allowing to measure time between a start point and a stop point
eoTimerStatRegisters 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
eoUpdatableEoUpdatable is a generic class for adding updatation to an existing class Just says it has an update() method
eoUpdaterEoUpdater 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::fileFile this structure combined with the friend operator<< below is an easy way to select a file as output
eo::mpi::Job< JobData >::FinallyBlockFinally 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_errorLoading 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::MemPoolPool allocator for the subtree and parse tree classes (homebrew and not compliant to ANSI allocator requirements) (c) copyright Maarten Keijzer 1999, 2000
MemPoolPool 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::NodeGlobal 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::ObjectJSON Object
eo::mpi::OneShotJob< JobData >Job that will be launched only once
eoLogger::outbufOutbuf 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::ParallelApplyAssignmentStructure 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::ParserParser from a JSON source
Perf2WorthWrapper
eoserial::PersistentInterface 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::PrintableInterface showing that object can be written to a eoserial type (currently JSON)
eoFunctorBase::procedure_tagTag 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 >::RefHelper 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::setlevelSetlevel 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::StatStatistic related to a key (name)
StatBaseWrapper
eo::mpi::StaticAssignmentAlgorithmAssignment algorithm which gives to each worker a precise number of tasks to do, in a round robin fashion
eoserial::StringJSON 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_tagTag 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
 All Classes Namespaces Files Functions Variables Typedefs Friends