Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

Open BEAGLE Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
Beagle::GP::AbsT< T >GP templated absolute class
Beagle::AbstractAllocT< T, BaseType >Abstract templated allocator class
Beagle::AbstractContainerAllocT< T, BaseType, ContainerTypeAllocType >Templated class defining a T-type abstract container allocator
Beagle::GP::AddT< T >GP generic 2 arguments addition primitive class
Beagle::GP::ADFGP automatically defined function (ADF) primitive
Beagle::AllocatorBasic Beagle allocator class
Beagle::AllocatorT< T, BaseType >Templated class defining a T-type allocator
Beagle::GP::AndGP boolean AND primitive class
Beagle::GP::ArgumentGP generic arguments for invokable primitive
Beagle::GP::Argument::SharedDataClass defining an internal data structure of the arguments
Beagle::GP::ArgumentT< T >GP generic arguments for invokable primitive
Beagle::ArrayT< T >Template of an ArrayT that adapt an array type (std::vector of the parametrized type) to the Beagle Object interface
Beagle::AssertExceptionBeagle exception indicating an badly asserted condition
Beagle::BadCastExceptionBeagle exception indicating that a bad cast (by a call to castObjectT) happen
Beagle::GA::BitStringBit string GA genotype class
Beagle::GA::BitString::DecodingKeyDecoding key to tranform a bit string genotype into a vector of numbers
Beagle::BreederNodeBreeder node class, the skeleton of the breeder trees
Beagle::BreederOpBreeder operator abstract class.

A breeder is an operator that can process individuals in an evolution at the individual level. Breeders are hierachically organized into trees. A breeder receive a breeding pool to process, and must return from it one bred individual

Beagle::ComponentSystem component base class
Beagle::ComponentMapAssociative container using a string as key accessors to the Component::Handle instances
Beagle::ConfigurationDumperConfiguration dumper class parameter
Beagle::ContainerBasic container data structure, implemented as a vector of smart pointers
Beagle::ContainerAllocatorBasic container allocator
Beagle::ContainerAllocatorT< T, BaseType, ContainerTypeAllocType >Templated class defining a T-type container allocator
Beagle::ContainerT< T, BaseType >Templated class defining a T-type uniform bag, inheriting from BaseType uniform bag
Beagle::ContextEvolutionary context
Beagle::GP::ContextThe GP context class
Beagle::GP::CosGP cosinus primitive class
CoSymEvalOpAbstract co-evolution evaluation class operator for the co-evolutionary symbolic regression
Beagle::GA::CrossoverBlendESVecOpES blend crossover operator class.

Real-valued ES blend crossover (BLX-alpha) proceed by blending two ES individuals, with values $(x^{(1,t)},x^{(2,t)})$ and strategy parameters $(s^{(1,t)},s^{(2,t)})$ , using a parameter $\alpha\in[0,1]$ . The resulting children $(x^{(1,t+1)},x^{(2,t+1)})$ are equal to $x^{(1,t+1)}_i=(1-\gamma^x_i) x^{(1,t)}_i+\gamma^x_i x^{(2,t)}_i$ , $x^{(2,t+1)}_i=\gamma^x_i x^{(1,t)}_i+(1-\gamma^x_i) x^{(2,t)}_i$ , $s^{(1,t+1)}_i=(1-\gamma^s_i) s^{(1,t)}_i+\gamma^s_i s^{(2,t)}_i$ , and $s^{(2,t+1)}_i=\gamma^s_i s^{(1,t)}_i+(1-\gamma^s_i) s^{(2,t)}_i$ , where $u^x_i\in[0,1]$ and $u^s_i\in[0,1]$ are a random value, $\gamma^x_i=(1 + 2\alpha)u^x_i-\alpha$ , and $\gamma^s_i=(1 + 2\alpha)u^s_i-\alpha$

Beagle::GA::CrossoverBlendFltVecOpReal-valued GA blend crossover (BLX-alpha) operator class.

Real-valued GA blend crossover (BLX-alpha) proceed by blending two float vectors, $(x^{(1,t)},x^{(2,t)})$ , using a parameter $\alpha\in[0,1]$ . The resulting children $(x^{(1,t+1)},x^{(2,t+1)})$ are equal to $x^{(1,t+1)}_i=(1-\gamma_i) x^{(1,t)}_i+\gamma_i x^{(2,t)}_i$ and $x^{(2,t+1)}_i=\gamma_i x^{(1,t)}_i+(1-\gamma_i) x^{(2,t)}_i$ , where $u_i\in[0,1]$ is a random value and $\gamma_i=(1 + 2\alpha)u_i-\alpha$

Beagle::GP::CrossoverConstrainedOpGP crossover for constrained trees operator class
Beagle::GA::CrossoverIndicesIntVecOpIndices integer vector GA crossover operator class
Beagle::GA::CrossoverOnePointBitStrOpBit string GA one point crossover operator class
Beagle::GA::CrossoverOnePointESVecOpEvolution strategy one point crossover operator class
Beagle::GA::CrossoverOnePointFltVecOpReal-valued GA one point crossover operator class
Beagle::GA::CrossoverOnePointIntVecOpInteger-valued GA one point crossover operator class
Beagle::GA::CrossoverOnePointOpT< T >GA one point crossover operator class
Beagle::CrossoverOpAbstract crossover operator class
Beagle::GP::CrossoverOpGP crossover operator class
Beagle::GA::CrossoverSBXFltVecOpReal-valued GA simulated binary crossover (SBX) operator class.

Real-valued GA simulated binary crossover (SBX) proceed by mating two float vectors, $(x^{(1,t)},x^{(2,t)})$ . The resulting children $(x^{(1,t+1)},x^{(2,t+1)})$ are equal to $x^{(1,t+1)}_i=0.5((1+\beta_i) x^{(1,t)}_i+(1-\beta_i) x^{(2,t)}_i)$ and $x^{(2,t+1)}_i=0.5((1-\beta_i) x^{(1,t)}_i+(1+\beta_i) x^{(2,t)}_i)$ , where $u_i\in[0,1]$ is a random value, $\beta_i=(2u_i)^{1/\nu+1}$ if $u_i\le0.5$ otherwize $(\frac{1}{2(1-u_i)})^{1/\nu+1}$ , and $\nu>0$ is user-configurable parameter

Beagle::GA::CrossoverTwoPointsBitStrOpBit string GA two points crossover operator class
Beagle::GA::CrossoverTwoPointsESVecOpEvolution strategy two points crossover operator class
Beagle::GA::CrossoverTwoPointsFltVecOpReal-valued GA two points crossover operator class
Beagle::GA::CrossoverTwoPointsIntVecOpInteger-valued GA two points crossover operator class
Beagle::GA::CrossoverTwoPointsOpT< T >GA two points crossover operator class
Beagle::GA::CrossoverUniformBitStrOpBit string GA uniform crossover operator class
Beagle::GA::CrossoverUniformESVecOpEvolution strategy uniform crossover operator class
Beagle::GA::CrossoverUniformFltVecOpReal-valued GA uniform crossover operator class
Beagle::GA::CrossoverUniformIntVecOpInteger-valued GA uniform crossover operator class
Beagle::GA::CrossoverUniformOpT< T >GA uniform crossover operator class
Beagle::DecimateOpPopulation decimation operator class.

This operator shrinks the population size (i.e. it "decimates" the population). The decimation is done by keeping the n best individuals of the population, where n is $ratio \times population size$ and ratio is the decimation ratio, which is less than or equal to 1.0

Beagle::DemeA deme is a population of individuals, a "hall of fame", and some statistics
Beagle::GP::DemeA GP deme is a population of GP individual
Beagle::DemeAllocDeme specific allocator type
Beagle::DemeAllocT< T, BaseType, IndividualAllocType >Allocator template class for deme derived types
Beagle::GP::DivideT< T >GP generic 2 arguments protected division primitive class
Beagle::GP::EphemeralDoubleDouble ephemeral constants uniformly generated in [-1,1]
EphemeralPercentEphemeral constant of Double randomly generated in [0,100]
Beagle::GP::EphemeralT< T >Generic randomly generated ephemeral constant primitive
EqualToEqualTo primitive that compare equality of two Double and return a Bool
Beagle::GA::ESPairEvolution strategy (value, strategy parameter) pair composing ES genotypes
Beagle::GA::ESVectorEvolution strategy genotype class
Beagle::EvaluationMultipleOpMultiple individual evaluation operator class
Beagle::EvaluationMultipleOp::Case
Beagle::Coev::EvaluationOpAbstract co-evolution evaluation operator class.

For its application co-evolution fitness evaluation operators, the user must over-defined the pure virtual methods makeSets and evaluateSets. The makeSets method is called to ask the evaluation operator to make evaluation sets from the actual deme. An evaluation set corresponds to a group of individuals than can be mated with groups of individual from other population for co-evolutionary fitness evaluation. The groups of individuals created in method makeSets are added to the shared structure by a call to the method addSets. This method takes a second optionnal argument which indicated whether or not the call is blocking. If the call is blocking, the call to addSets will return only when the set will be evaluated. Otherwize, the evaluation set return immediatly after the set is added to the shared structure. Once the number of evaluation sets added to the shared structure is equal to the trigger value, the problem-specific co-evolutionary fitness evaluation is done by a call to the pure virtual method evaluateSets

Beagle::EvaluationOpAbstract evaluation operator class
Beagle::GP::EvaluationOpAbstract GP evaluation operator class
Beagle::Coev::EvaluationOp::EvalSetEvaluation set association used in co-evolution evaluation operator
Beagle::EvolverBeagle's basic evolver class
Beagle::GP::EvolverStandard GP Generational evolver class
Beagle::GA::EvolverBitStringBit string GA evolver class
Beagle::GA::EvolverESEvolution strategy evolver class
Beagle::GA::EvolverFloatVectorReal-valued GA evolver class
Beagle::GA::EvolverIntegerVectorInteger-valued GA evolver class
Beagle::ExceptionBasic Beagle exception class
Beagle::Exception::StackTraceItemInternal struct to store stack trace elements
Beagle::GP::ExecutionExceptionBasic class of GP exception related to individuals execution
Beagle::GP::ExpGP exponential primitive class
Beagle::FitnessAbstract individual's fitness class
Beagle::GP::FitnessKozaKoza's fitness class
Beagle::FitnessMultiObjMultiobjective fitness measure class
Beagle::FitnessMultiObjMinMinimization multiobjective fitness measure class
Beagle::FitnessSimpleSimple fitness class, made of a unique measure
Beagle::FitnessSimpleMinSimple fitness class for minimization problems
Beagle::GA::FloatVectorReal-valued GA genotype class
Beagle::GenerationalOpGenerational replacement strategy operator class.

A generational operator process deme with a breeding tree following a generation by generation replacement strategy

Beagle::GenotypeA plain empty genotype
Beagle::Coev::GPEvaluationOpAbstract co-evolution GP evaluation operator class
Beagle::HallOfFameA hall-of-fame is a population of the best-of-run individuals
Beagle::HallOfFame::MemberA member of the hall-of-fame, that is a best-of-run individual
Beagle::HierarchicalFairCompetitionOpHierarchical fair competition replacement strategy operator class.

Hierachical Fair Competition (HCF) operator inspired by the work of Jianjun Hu and Erik Goodman (Michigan State University). The operator is actually implemented as a migration operator that is at the same time a replacement strategy. The breeder tree of the replacement strategy is called to generate the new individuals

IfThenElseIfThenElse primitive that test 1st argument, return 2nd if true, 3rd if not
Beagle::IfThenElseOpIf-then-else operator class
Beagle::GP::IfThenElseT< ProcessedType, ConditionType >GP templated if-then-else class
Beagle::GP::IndividualAn individual inherits from a uniform bag of genotypes and has a fitness member
Beagle::IndividualAn individual inherits from a container of genotypes and has a fitness member
Beagle::IndividualAllocIndividual specific allocator type
Beagle::IndividualAllocT< T, BaseType, GenotypeAllocType >Allocator template class for individual derived types
Beagle::IndividualBagContainer of individuals
Beagle::IndividualSizeFrequencyStatsOpThe individual size frequence usage statistics operator class. Report size frequency of the individuals
Beagle::GA::InitBitStrOpGA bit string initialization operator class
Beagle::GA::InitESVecOpES genotype initialization operator class.

Initialization is based on one parameter, the initial strategy value (es.init.strategy). Each strategy parameters ($sigma_{init}$ ) are initialized to this value, while the value of the ES vector is randomly initialized to a value following a Gaussian distribution ($N(\mu,\sigma)$ ) of zero mean ($\mu=0.0$ ) and a standard deviation of the initial stategy parameter value ($\sigma=\sigma_{init}$ )

Beagle::GA::InitFltVecOpReal-valued GA genotype uniformly distributed initialization operator class
Beagle::GP::InitFullConstrainedOpConstrained GP trees "full" initialization operator class
Beagle::GP::InitFullOpGP trees "full" initialization operator class
Beagle::GP::InitGrowConstrainedOpConstrained GP trees "grow" initialization operator class
Beagle::GP::InitGrowOpGP trees "grow" initialization operator class
Beagle::GP::InitHalfConstrainedOpGP trees "half-and-half" initialization operator class
Beagle::GP::InitHalfOpGP trees "half-and-half" initialization operator class
Beagle::GP::InitializationOpAbstract initialization operator class
Beagle::InitializationOpAbstract initialization operator class
Beagle::GA::InitIndicesIntVecOpInteger-valued GA genotype uniformly distributed initialization operator class
Beagle::GA::InitIntVecOpInteger-valued GA genotype uniformly distributed initialization operator class
Beagle::GA::IntegerVectorInteger-valued GA genotype class
Beagle::InternalExceptionIndication of an internal Beagle exception
Beagle::InvalidateFitnessOpInvalidate individual's fitness operator class
Beagle::GP::InvokerGeneric GP tree invoker primitive
Beagle::IOExceptionBeagle exception indicating that a parameter, or such, is invalid
IPDEvalOpCo-evolution evaluation class operator for the iterated prisoner's dilemma
IPDThreadCo-evolution thread class for the iterated prisoner's dilemma
Beagle::IsEqualMapPairPredicateBinary predicate functor that test if two std::pair<string,Object::Handle> are equals
Beagle::IsEqualPointerPredicateBinary predicate functor that test if two pointed Objects are equals
Beagle::IsLessMapPairPredicateBinary predicate functor testing the ordering of two std::pair<string,Object::Handle>
Beagle::IsLessPointerPredicateBinary predicate functor that test the ordering of two pointed Objects
Beagle::IsMorePointerPredicateBinary predicate functor that test the ordering of two pointed Objects
KnapsackEvalOpThe individual evaluation class operator for the Knapsack problem
LessThanLessThan primitive that compare the order of two Double and return a Bool
Beagle::GP::LogGP neperian logarithm primitive class
Beagle::LoggerBeagle's logger class. Log to a file
Beagle::Logger::Message
Beagle::LoggerXMLBeagle's XML logger class. Log to in a XML format to file or console
Beagle::MapAssociative container using a string as key accessors to the Object::Handle instances
Beagle::MatrixAdapt the PACC::Matrix class to the Beagle Object interface
MaxFctESEvalOpThe individual evaluation class operator for the problem of ES function maximisation
MaxFctEvalOpThe individual evaluation class operator for the problem of function maximisation
MaxFctFloatEvalOpThe individual evaluation class operator for the problem of real-valued GA function maximisation
Beagle::GP::MaxNodesExecutionExceptionThrowed when the maximum number of GP nodes in an individual execution is overpassed
Beagle::GP::MaxTimeExecutionExceptionThrowed when the maximum time allowed to an individual execution is overpassed
Beagle::MeasureStatistical measure of an evolution
Beagle::MigrationOpIndividuals migration operator class
Beagle::MigrationRandomRingOpMigrate individuals choosen randomly, following a ring topology, operator class
Beagle::MilestoneReadOpRead a milestone operator class
Beagle::MilestoneWriteOpWrite a milestone operator class
Beagle::GP::ModuleGP generic module primitive
Beagle::GP::ModuleCompressOpCompress operator for evolutionary module acquisition
Beagle::GP::ModuleExpandOpExpand operator for evolutionary module acquisition, expand an existing module in a tree
Beagle::GP::ModuleVectorComponentVector of modules for evolutionary module acquisition
Beagle::MuCommaLambdaOpMu comma lambda (Mu,Lambda) replacement strategy operator class.

A (Mu,Lambda) operator generates Lambda children individuals from a population of Mu parents (where Lambda > Mu). From these Lambda individual, it keeps the Mu best to constitute the new generation

Beagle::GP::MultiplyT< T >GP generic 2 arguments multiplication primitive class
Beagle::MuPlusLambdaOpMu plus lambda (Mu+Lambda) replacement strategy operator class.

A (Mu+Lambda) operator generates Lambda children individuals from a population of Mu parents (usually where Lambda > Mu). From the Mu parents and the Lambda individual, it keeps the Mu best individuals to constitute the new generation

Beagle::GA::MutationCMAFltVecOpCMA-ES float vector mutation operator class.

This mutation operator is intended to be used in a breeder tree in conjunction of the GA::MuWCommaLambdaCMAFltVecOp replacement strategy. The parameters of the mutation are adaptively modified by this replacement strategy following the CMA-ES algorithm

Beagle::GP::MutationEphemeralDoubleOpGP ephemeral mutation operator class, change value of Double-typed ephemeral constants
Beagle::GP::MutationEphemeralOpT< T >GP ephemeral mutation operator class, change value of ephemeral constants
Beagle::GA::MutationESVecOpEvolution strategy mutation operator class.

The evolution strategy simple mutation operator apply mutation on the individuals using the following equations:

\[\sigma^{\prime}_i = \sigma_i \exp^{\tau^{\prime} N(0,1) + \tau N_i(0,1)}\]

\[x^{\prime}_i = x_i + \sigma_i N_i(0,1)\]

\[\tau^{\prime} = 1 / \sqrt{2n}\]

\[\tau = 1 / \sqrt{2\sqrt{n}}\]

where $N(0,1)$ is a random number generated using a Gaussian probability density function with a zero mean and a standard deviation of 1.0, $x^{\prime}_i$ is the new value of parameter i, and $\sigma^{\prime}_i$ the new mutation strategy parameter value of parameter i

Beagle::GA::MutationFlipBitStrOpBit string GA flip bit mutation operator class
Beagle::GA::MutationGaussianFltVecOpReal-valued GA Gaussian mutation operator class
Beagle::MutationOpAbstract mutation operator class
Beagle::GP::MutationShrinkConstrainedOpConstrained GP tree shrink mutation operator class
Beagle::GP::MutationShrinkOpGP Shrink mutation operator class
Beagle::GA::MutationShuffleIntVecOpInteger vector GA shuffle mutation operator class
Beagle::GP::MutationStandardConstrainedOpGP standard mutation operator class, as described in Genetic Programming I
Beagle::GP::MutationStandardOpGP standard mutation operator class, as described in Genetic Programming I
Beagle::GP::MutationSwapConstrainedOpConstrained GP tree swap mutation operator class
Beagle::GP::MutationSwapOpGP swap mutation operator class
Beagle::GP::MutationSwapSubtreeConstrainedOpConstrained GP tree swap subtree mutation operator class
Beagle::GP::MutationSwapSubtreeOpGP swap subtree mutation operator class
Beagle::GA::MutationUniformIntVecOpInteger vector GA uniform mutation operator class
Beagle::GA::MuWCommaLambdaCMAFltVecOpCMA-ES (Mu_W+Lambda) replacement strategy operator class.

CMA-ES (Mu_W,Lambda) replacement strategy class. Apply the CMA-ES algorithm (except mutation) on a population of GA float vectors. Use in conjunction of the CMA-ES mutation operator defined in class GA::MutationCMAFltVecOp

Beagle::NamedObjectAn Object with a name
Beagle::GP::NandGP boolean NAND primitive class
Beagle::GP::NodeGP tree node structure
Beagle::GP::NorGP boolean NOR primitive class
Beagle::GP::NotGP boolean NOT primitive class
Beagle::NPGA2OpNPGA2 multiobjective selection operator class.

The NPGA2 operator implement the multiobjective evolutionary algorithm NPGA 2 (Niched Pareto Genetic Algorithm) of Erickson, Mayer, and Horn

Beagle::NSGA2OpNSGA2 multiobjective replacement strategy operator class.

The NSGA2 replacement strategy implement the elitist multiobjective evolutionary algorithm NSGA2 (Non-dominating Sorting Genetic Algorithm) of Deb, Pratap, Agarwal, and Meyarivan

Beagle::NSGA2Op::IsLessCrowdingPairPredicateUsed internally to sort solutions over their different objectives
Beagle::ObjectBase class for common Beagle objects
Beagle::ObjectExceptionBeagle exception relative to a erroneous state of an Object
OneMaxEvalOpThe individual evaluation class operator for the OneMax problem
Beagle::OperatorEvolutionary operator abstract class
Beagle::OperatorMapAssociative container using a string as key accessors to the Operator::Handle instances
Beagle::GP::OrGP boolean OR primitive class
Beagle::OversizeOpOversize population replacement strategy operator class.

An oversize operator generates (ratio * population size) children individuals from a population of Mu parents

Beagle::ParetoFrontCalculateOpEvaluate Pareto front operator class.

Evaluate Pareto front from demes and vivarium and put it in place of the actual hall-of-fame. The Pareto front is evaluated just before milestones are written. If previous hall-of-fame are presents in the demes/vivarium, they are erased. This operator must be in the evolver's operator sets between the termination criterion check operators and the MilestoneWriteOp operator

Beagle::ParetoFrontHOFA Pareto front hall-of-fame for multiobjective optimization
ParityEvalOpThe individual evaluation class operator for the parity-6 problem
Beagle::PointerBasic class describing a smart pointer to an object
Beagle::PointerT< T, BaseType >Templated class defining a T-type smart pointer
Beagle::GP::PrimitiveThe GP primitive class
Beagle::GP::PrimitiveMapAssociative container using a string as key accessors to the GP::Primitive::Handle instances
Beagle::GP::PrimitiveSetThe GP primitive set class
Beagle::GP::PrimitiveSuperSetThe GP primitive super set class
Beagle::GP::PrimitiveUsageStatsOpThe GP primitive usage statistics operator class. Report usage of primitives
Beagle::RandomizerRandom number generator class
Beagle::RandomShuffleDemeOpRandom shuffle a deme operator class.

Random shuffle order of individuals in the actual deme

Beagle::RegisterRegister implementation, where all the parameters of the framework are centralized
Beagle::Register::DescriptionParameter extensive description
Beagle::RegisterReadOpRead evolution parameters operator class
Beagle::ReplacementStrategyOpReplacement strategy operator abstract class.

The ReplacementStrategyOp class is the entry point the a breeding tree, and have a breeder root node. Each breeder are hierachically organized into a tree. A breeder receive a breeding pool to process, and must return from it one bred individual

Beagle::GP::ResourcesExceededExecutionExceptionBasic GP exception related to resources management in individuals execution
Beagle::RouletteT< T >Templated class defining a T-type roulette wheel
Beagle::RunTimeExceptionRun time checking exception
Beagle::SelectionOpAbstract selection operator class
Beagle::SelectParsimonyTournOpLexicographic parsimony pressure tournament selection operator class.

A simple lexicographic parsimony pressure tournament selection operator, based an idea presented in: Luke, S., and L. Panait. 2002. Lexicographic Parsimony Pressure. In GECCO-2002: Proceedings of the Genetic and Evolutionary Computation Conference. W. B. Langdon et al, eds. Morgan Kauffman. 829-836

Beagle::SelectRandomOpSelect an individual in a population randomly operator class (uniform distribution)
Beagle::SelectRouletteOpProportionnal roulette selection operator class
Beagle::SelectTournamentOpTournament selection operator class
Beagle::GP::SinGP sinus primitive class
SpambaseEvalOpThe individual evaluation class operator for the spambase problem
Beagle::StatsGeneration statistics measure
Beagle::GP::StatsCalcFitnessKozaOpCalculate statistics of a GP deme, for a generation, operator class
Beagle::StatsCalcFitnessMultiObjOpCalculate statistics of a deme operator class for individual fitness is of the type FitnessMultiObj
Beagle::StatsCalcFitnessSimpleOpCalculate statistics of a deme operator class for individual fitness is of the type FitnessSimple
Beagle::GP::StatsCalcFitnessSimpleOpCalculate statistics of a deme operator class for individual fitness is of the type FitnessSimple with individuals made of GP trees
Beagle::StatsCalculateOpCalculate statistics of a deme, for a generation, operator class
Beagle::SteadyStateOpSteady state replacement strategy operator
Beagle::GP::SubtractT< T >GP generic 2 arguments subtraction primitive class
SymbRegEvalOpThe individual evaluation class operator for the problem of symbolic regression
SymGPEvalOpGP evaluation class operator for the co-evolutionary symbolic regression
SymGPThreadCo-evolution thread class for the GP population
Beagle::GP::SystemThe GP system class
Beagle::SystemEvolutionary system
Beagle::TargetedExceptionTargeted Beagle exception that indicate a precise line number in a source file
Beagle::Coev::TermBroadcastOpBroadcast termination criterion amoung coevolution threads operator class
Beagle::TerminationOpCheck for termination criterion reached operator class
Beagle::TermMaxEvalsOpMaximum number of fitness evaluations termination criterion operator
Beagle::TermMaxFitnessOpMaximum fitness value termination criterion operator class
Beagle::TermMaxGenOpMaximum generation termination criterion operator
Beagle::GP::TermMaxHitsOpMaximum number of hits termination operator
Beagle::TermMinFitnessOpMinimum fitness value termination criterion operator class
Beagle::GP::TokenT< T >GP simple token terminal primitive class
TrainSetEvalOp
TrainSetThreadThread class for the training set population
Beagle::GP::TreeThe GP tree class, the genotype used in GP
TSPEvalOpThe individual evaluation class operator for the TSP problem
Beagle::GP::ValidateOpOperator used primarily for debugging. It checks that every individual is valid
Beagle::ValidationExceptionBeagle exception indicating that a parameter, or such, is invalid
Beagle::VectorAdapt the PACC::Vector class to the Beagle Object interface
vector
Beagle::GP::VivariumGP vivarium with default constructor, part of the GP framework
Beagle::VivariumA vivarium is a set of demes
Beagle::VivariumAllocVivarium specific allocator type
Beagle::VivariumAllocT< T, BaseType, DemeAllocType >Allocator template class for vivarium derived types
Beagle::WrapperT< T >Template of an Wrapper that adapt a type to the Beagle Object interface
Beagle::GP::XorGP boolean XOR primitive class
ZeroMinEvalOpThe individual evaluation class operator for the ZeroMin minimization problem
Generated on Wed Oct 5 17:03:04 2005 for Open BEAGLE by  doxygen 1.4.4