Uses of Interface
ec.Setup

Packages that use Setup
com.parabon.ec   
com.parabon.ec.simple   
ec   
ec.app.ant   
ec.app.ant.func   
ec.app.coevolve1   
ec.app.coevolve2   
ec.app.ecsuite   
ec.app.edge   
ec.app.edge.func   
ec.app.lawnmower   
ec.app.lawnmower.func   
ec.app.multiplexer The Koza-I Boolean-Multiplexer problem. 
ec.app.multiplexer.func   
ec.app.parity   
ec.app.parity.func   
ec.app.regression   
ec.app.regression.func   
ec.app.sum   
ec.app.twobox   
ec.app.twobox.func   
ec.breed   
ec.coevolve   
ec.de Differential Evolution Algorithms. 
ec.es   
ec.eval   
ec.exchange   
ec.gp   
ec.gp.breed   
ec.gp.build   
ec.gp.koza   
ec.multiobjective   
ec.multiobjective.spea2 Strength Pareto Evolutionary Algorithm implementation. 
ec.parsimony   
ec.pso   
ec.rule   
ec.rule.breed   
ec.select   
ec.simple   
ec.spatial   
ec.steadystate   
ec.vector   
ec.vector.breed   
 

Uses of Setup in com.parabon.ec
 

Classes in com.parabon.ec that implement Setup
 class DummyStatistics
          This is a dummy object whose methods do nothing.
 

Uses of Setup in com.parabon.ec.simple
 

Classes in com.parabon.ec.simple that implement Setup
 class FinalStatistics
          Like SimpleStatistics, but also prints out all individuals in the population.
 class SimpleBoundedFitness
          A SimpleBoundedFitness is a SimpleFitness with an arbitrary upper bound.
 

Uses of Setup in ec
 

Subinterfaces of Setup in ec
 interface Clique
          Clique is a class pattern marking classes which create only a few instances, generally accessible through some global mechanism, and every single one of which gets its own distinct setup(...) call.
 interface Group
          Groups are used for populations and subpopulations.
 interface Prototype
          Prototype classes typically have one or a few prototype instances created during the course of a run.
 interface Singleton
          A Singleton is a class for which there will be only one instance in the entire course of a run, and which will exist for pretty much the entire run.
 

Classes in ec that implement Setup
 class Breeder
          A Breeder is a singleton object which is responsible for the breeding process during the course of an evolutionary run.
 class BreedingPipeline
          A BreedingPipeline is a BreedingSource which provides "fresh" individuals which can be used to fill a new population.
 class BreedingSource
          A BreedingSource is a Prototype which provides Individuals to populate new populations based on old ones.
 class Evaluator
          An Evaluator is a singleton object which is responsible for the evaluation process during the course of an evolutionary run.
 class EvolutionState
          An EvolutionState object is a singleton object which holds the entire state of an evolutionary run.
 class Exchanger
          The Exchanger is a singleton object whose job is to (optionally) perform individual exchanges between subpopulations in the run, or exchange individuals with other concurrent evolutionary run processes, using sockets or whatever.
 class Finisher
          Finisher is a singleton object which is responsible for cleaning up a population after a run has completed.
 class Fitness
          Fitness is a prototype which describes the fitness of an individual.
 class Individual
          An Individual is an item in the EC population stew which is evaluated and assigned a fitness which determines its likelihood of selection.
 class Initializer
          The Initializer is a singleton object whose job is to initialize the population at the beginning of the run.
 class Population
          A Population is the repository for all the Individuals being bred or evaluated in the evolutionary run at a given time.
 class Problem
          Problem is a prototype which defines the problem against which we will evaluate individuals in a population.
 class SelectionMethod
          A SelectionMethod is a BreedingSource which provides direct IMMUTABLE pointers to original individuals in an old population, not fresh mutable copies.
 class Species
          Species is a prototype which defines the features for a set of individuals in the population.
 class Statistics
          Statistics and its subclasses are Cliques which generate statistics during the run.
 class Subpopulation
          Subpopulation is a group which is basically an array of Individuals.
 

Uses of Setup in ec.app.ant
 

Classes in ec.app.ant that implement Setup
 class Ant
          Ant implements the Artificial Ant problem.
 class AntData
          Since Ant doesn't actually pass any information, this object is effectively empty.
 class AntStatistics
           
 

Uses of Setup in ec.app.ant.func
 

Classes in ec.app.ant.func that implement Setup
 class IfFoodAhead
           
 class Left
           
 class Move
           
 class Progn2
           
 class Progn3
           
 class Progn4
           
 class Right
           
 

Uses of Setup in ec.app.coevolve1
 

Classes in ec.app.coevolve1 that implement Setup
 class CompetitiveMaxOne
           
 

Uses of Setup in ec.app.coevolve2
 

Classes in ec.app.coevolve2 that implement Setup
 class CoevolutionaryRosenbrock
           
 

Uses of Setup in ec.app.ecsuite
 

Classes in ec.app.ecsuite that implement Setup
 class ECSuite
          Several standard Evolutionary Computation functions are implemented: Rastrigin, De Jong's test suite F1-F4 problems (Sphere, Rosenbrock, Step, Noisy-Quartic), Booth (from [Schwefel, 1995]), and Griewangk.
 

Uses of Setup in ec.app.edge
 

Classes in ec.app.edge that implement Setup
 class Edge
          Edge implements the Symbolic Edge problem.
 class EdgeData
           
 class EdgeShortStatistics
           
 class EdgeStatistics
           
 

Uses of Setup in ec.app.edge.func
 

Classes in ec.app.edge.func that implement Setup
 class Accept
           
 class BAccept
           
 class BBud
           
 class BLoop
           
 class BStart
           
 class Bud
           
 class Double
           
 class Epsilon
           
 class Loop
           
 class One
           
 class Reverse
           
 class Split
           
 class Start
           
 class Zero
           
 

Uses of Setup in ec.app.lawnmower
 

Classes in ec.app.lawnmower that implement Setup
 class Lawnmower
          Lawnmower implements the Koza-II Lawnmower problem.
 class LawnmowerData
           
 class LawnmowerStatistics
           
 

Uses of Setup in ec.app.lawnmower.func
 

Classes in ec.app.lawnmower.func that implement Setup
 class Frog
           
 class LawnERC
           
 class Mow
           
 class V8a
           
 

Uses of Setup in ec.app.multiplexer
 

Classes in ec.app.multiplexer that implement Setup
 class Multiplexer
          Multiplexer implements the family of n-Multiplexer problems.
 class MultiplexerData
          This is ugly and complicated because it needs to hold a variety of different-length bitstrings, including temporary ones held while computing subtrees.
 

Uses of Setup in ec.app.multiplexer.func
 

Classes in ec.app.multiplexer.func that implement Setup
 class A0
           
 class A1
           
 class A2
           
 class And
           
 class D0
           
 class D1
           
 class D2
           
 class D3
           
 class D4
           
 class D5
           
 class D6
           
 class D7
           
 class If
           
 class Not
           
 class Or
           
 

Uses of Setup in ec.app.parity
 

Classes in ec.app.parity that implement Setup
 class Parity
          Parity implements the family of n-[even|odd]-Parity problems up to 32-parity.
 class ParityData
           
 

Uses of Setup in ec.app.parity.func
 

Classes in ec.app.parity.func that implement Setup
 class D10
           
 class D11
           
 class D12
           
 class D13
           
 class D14
           
 class D15
           
 class D16
           
 class D17
           
 class D18
           
 class D19
           
 class D20
           
 class D21
           
 class D22
           
 class D23
           
 class D24
           
 class D25
           
 class D26
           
 class D27
           
 class D28
           
 class D29
           
 class D30
           
 class D31
           
 class D8
           
 class D9
           
 class Nand
           
 class Nor
           
 

Uses of Setup in ec.app.regression
 

Classes in ec.app.regression that implement Setup
 class Quintic
          Quintic implements a Symbolic Regression problem.
 class Regression
          Regression implements the Koza (quartic) Symbolic Regression problem.
 class RegressionData
           
 class Sextic
          Sextic implements a Symbolic Regression problem.
 

Uses of Setup in ec.app.regression.func
 

Classes in ec.app.regression.func that implement Setup
 class Add
           
 class Cos
           
 class Div
           
 class Exp
           
 class Log
           
 class Mul
           
 class RegERC
           
 class Sin
           
 class Sub
           
 class X
           
 

Uses of Setup in ec.app.sum
 

Classes in ec.app.sum that implement Setup
 class Sum
          Sum is a simple example of the ec.Vector package, implementing the very simple sum problem (fitness = sum over vector).
 

Uses of Setup in ec.app.twobox
 

Classes in ec.app.twobox that implement Setup
 class TwoBox
          TwoBox implements the TwoBox problem, with or without ADFs, as discussed in Koza-II.
 class TwoBoxData
           
 

Uses of Setup in ec.app.twobox.func
 

Classes in ec.app.twobox.func that implement Setup
 class H0
           
 class H1
           
 class L0
           
 class L1
           
 class W0
           
 class W1
           
 

Uses of Setup in ec.breed
 

Classes in ec.breed that implement Setup
 class BufferedBreedingPipeline
          If empty, a BufferedBreedingPipeline makes a request of exactly num-inds individuals from a single child source; it then uses these individuals to fill requests (returning min each time), until the buffer is emptied, at which time it grabs exactly num-inds more individuals, and so on.
 class ForceBreedingPipeline
          ForceBreedingPipeline has one source.
 class GenerationSwitchPipeline
          GenerationSwitchPipeline is a simple BreedingPipeline which switches its source depending on the generation.
 class MultiBreedingPipeline
          MultiBreedingPipeline is a BreedingPipeline stores some n child sources; each time it must produce an individual or two, it picks one of these sources at random and has it do the production.
 class ReproductionPipeline
          ReproductionPipeline is a BreedingPipeline which simply makes a copy of the individuals it recieves from its source.
 

Uses of Setup in ec.coevolve
 

Classes in ec.coevolve that implement Setup
 class CompetitiveEvaluator
          CompetitiveEvaluator.java
 class MultiPopCoevolutionaryEvaluator
          MultiPopCoevolutionaryEvaluator.java
 

Uses of Setup in ec.de
 

Classes in ec.de that implement Setup
 class Best1BinDEBreeder
          Best1BinDEBreeder implements the DE/best/1/bin Differential Evolution algorithm.
 class DEBreeder
          DEBreeder provides a straightforward Differential Evolution (DE) breeder for the ECJ system.
 class DEStatistics
          DEStatistics provides a straightforward solution to one problem many existing ECJ statistics classes have when used in conjunction with Differential Evolution (DE), namely reporting the fitness of individuals after they have been evaluated.
 class Rand1EitherOrDEBreeder
          Rand1EitherOrDEBreeder implements the DE/rand/1/either-or Differential Evolution Algorithm, explored recently in the "Differential Evolution: A Practical Approach to Global Optimization" book by Kenneth Price, Rainer Storn, and Jouni Lampinen.
 class Rand1ExpDEBreeder
          Rand1ExpDEBreeder implements the DE/rand/1/exp Differential Evolution Algorithm, explored recently in the "Differential Evolution: A Practical Approach to Global Optimization" book by Kenneth Price, Rainer Storn, and Jouni Lampinen.
 

Uses of Setup in ec.es
 

Classes in ec.es that implement Setup
 class ESSelection
          ESSelection is a special SelectionMethod designed to be used with evolutionary strategies-type breeders.
 class MuCommaLambdaBreeder
          MuCommaLambdaBreeder is a Breeder which, together with ESSelection, implements the (mu,lambda) breeding strategy and gathers the comparison data you can use to implement a 1/5-rule mutation mechanism.
 class MuPlusLambdaBreeder
          MuPlusLambdaBreeder is a subclass of MuCommaLambdaBreeder which, together with ESSelection, implements the (mu + lambda) breeding strategy and gathers the comparison data you can use to implement a 1/5-rule mutation mechanism.
 

Uses of Setup in ec.eval
 

Classes in ec.eval that implement Setup
 class MasterProblem
          MasterProblem.java
 

Uses of Setup in ec.exchange
 

Classes in ec.exchange that implement Setup
 class InterPopulationExchange
          InterPopulationExchange is an Exchanger which implements a simple exchanger between subpopulations.
 class IslandExchange
          IslandExchange is an Exchanger which implements a simple but quite functional asynchronous island model for doing massive parallel distribution of evolution across beowulf clusters.
 

Uses of Setup in ec.gp
 

Subinterfaces of Setup in ec.gp
 interface GPNodeSelector
          GPNodeSelector is a Prototype which describes algorithms which select random nodes out of trees, typically marking them for mutation, crossover, or whatnot.
 

Classes in ec.gp that implement Setup
 class ADF
          An ADF is a GPNode which implements an "Automatically Defined Function", as described in Koza II.
 class ADFArgument
          An ADFArgument is a GPNode which represents an ADF's argument terminal, its counterpart which returns argument values in its associated function tree.
 class ADFContext
          ADFContext is the object pushed onto an ADF stack which represents the current context of an ADM or ADF function call, that is, how to get the argument values that argument_terminals need to return.
 class ADFStack
          ADFStack is a special data object used to hold ADF data.
 class ADM
          An ADM is an ADF which doesn't evaluate its arguments beforehand, but instead only evaluates them (and possibly repeatedly) when necessary at runtime.
 class ERC
          ERC is an abstract GPNode which implements Ephemeral Random Constants, as described in Koza I.
 class GPAtomicType
          A GPAtomicType is a simple, atomic GPType.
 class GPBreedingPipeline
          A GPBreedingPipeline is a BreedingPipeline which produces only members of some subclass of GPSpecies.
 class GPData
          GPData is the parent class of data transferred between GPNodes.
 class GPFunctionSet
          GPFunctionSet is a Clique which represents a set of GPNode prototypes forming a standard function set for forming certain trees in individuals.
 class GPIndividual
          GPIndividual is an Individual used for GP evolution runs.
 class GPInitializer
          GPInitializer is a SimpleInitializer which sets up all the Cliques, ( the initial [tree/node]constraints, types, and function sets) for the GP system.
 class GPNode
          GPNode is a GPNodeParent which is the abstract superclass of all GP function nodes in trees.
 class GPNodeBuilder
          GPNodeBuilder is a Prototype which defines the superclass for objects which create ("grow") GP trees, whether for population initialization, subtree mutation, or whatnot.
 class GPNodeConstraints
          A GPNodeConstraints is a Clique which defines constraint information common to many different GPNode functions, namely return types, child types, and number of children.
 class GPProblem
          A GPProblem is a Problem which is meant to efficiently handle GP evaluation.
 class GPSetType
          A GPSetType is a GPType which contains GPAtomicTypes in a set, and is used as a generic GP type.
 class GPSpecies
          GPSpecies is a simple individual which is suitable as a species for GP subpopulations.
 class GPTree
          GPTree is a GPNodeParent which holds the root GPNode of a tree of GPNodes.
 class GPTreeConstraints
          A GPTreeConstraints is a Clique which defines constraint information common to many different GPTree trees, namely the tree type, builder, and function set.
 class GPType
          GPType is a Clique which represents types in Strongly-Typed Genetic Programming (STGP).
 

Uses of Setup in ec.gp.breed
 

Classes in ec.gp.breed that implement Setup
 class InternalCrossoverPipeline
          InternalCrossoverPipeline picks two subtrees from somewhere within an individual, and crosses them over.
 class MutateAllNodesPipeline
          MutateAllNodesPipeline implements the AllNodes mutation algorithm described in Kumar Chellapilla, "A Preliminary Investigation into Evolving Modular Programs without Subtree Crossover", GP98.
 class MutateDemotePipeline
          MutateDemotePipeline works very similarly to the DemoteNode algorithm described in Kumar Chellapilla, "A Preliminary Investigation into Evolving Modular Programs without Subtree Crossover", GP98, and is also similar to the "insertion" operator found in Una-May O'Reilly's thesis, "An Analysis of Genetic Programming".
 class MutateERCPipeline
          MutateERCPipeline works very similarly to the "Gaussian" algorithm described in Kumar Chellapilla, "A Preliminary Investigation into Evolving Modular Programs without Subtree Crossover", GP98.
 class MutateOneNodePipeline
          MutateOneNodesPipeline implements the OneNode mutation algorithm described in Kumar Chellapilla, "A Preliminary Investigation into Evolving Modular Programs without Subtree Crossover", GP98.
 class MutatePromotePipeline
          MutatePromotePipeline works very similarly to the PromoteNode algorithm described in Kumar Chellapilla, "A Preliminary Investigation into Evolving Modular Programs without Subtree Crossover", GP98, and is also similar to the "deletion" operator found in Una-May O'Reilly's thesis, "An Analysis of Genetic Programming".
 class MutateSwapPipeline
          MutateSwapPipeline works very similarly to the Swap algorithm described in Kumar Chellapilla, "A Preliminary Investigation into Evolving Modular Programs without Subtree Crossover", GP98.
 class RehangPipeline
          RehangPipeline picks a nonterminal node other than the root and "rehangs" it as a new root.
 

Uses of Setup in ec.gp.build
 

Classes in ec.gp.build that implement Setup
 class PTC1
          PTC1 implements the "Strongly-typed Probabilistic Tree Creation 1 (PTC1)" algorithm described in
 class PTC2
          PTC2 implements the "Strongly-typed Probabilistic Tree Creation 2 (PTC2)" algorithm described in
 class PTCFunctionSet
          PTCFunctionSet is a GPFunctionSet which adheres to PTCFunctionSetForm, and thus can be used with the PTC1 and PTC2 methods.
 class RandomBranch
          RandomBranch implements the Random_Branch tree generation method described in
 class RandTree
           
 class Uniform
          Uniform implements the algorithm described in
 

Uses of Setup in ec.gp.koza
 

Classes in ec.gp.koza that implement Setup
 class CrossoverPipeline
          CrossoverPipeline is a GPBreedingPipeline which performs a strongly-typed version of Koza-style "Subtree Crossover".
 class FullBuilder
          FullBuilder is a GPNodeBuilder which implements the FULL tree building method described in Koza I/II.
 class GrowBuilder
          GrowBuilder is a GPNodeBuilder which implements the GROW tree building method described in Koza I/II.
 class HalfBuilder
          HalfBuilder is a GPNodeBuilder which implements the RAMPED HALF-AND-HALF tree building method described in Koza I/II.
 class KozaBuilder
           
 class KozaFitness
          KozaFitness is a Fitness which stores an individual's fitness as described in Koza I.
 class KozaNodeSelector
          KozaNodeSelector is a GPNodeSelector which picks nodes in trees a-la Koza I, with the addition of having a probability of always picking the root.
 class KozaShortStatistics
          A Koza-style statistics generator, intended to be easily parseable with awk or other Unix tools.
 class KozaStatistics
          A simple Koza-style statistics generator.
 class MutationPipeline
          MutationPipeline is a GPBreedingPipeline which implements a strongly-typed version of the "Point Mutation" operator as described in Koza I.
 

Uses of Setup in ec.multiobjective
 

Classes in ec.multiobjective that implement Setup
 class MultiObjectiveFitness
          MultiObjectiveFitness is a subclass of Fitness which implements basic multi-objective mechanisms suitable for being used with a variety of multi-objective selection mechanisms, including ones using pareto-optimality.
 

Uses of Setup in ec.multiobjective.spea2
 

Classes in ec.multiobjective.spea2 that implement Setup
 class SPEA2Breeder
          Breeds each subpopulation separately, with no inter-population exchange, and using the SPEA2 approach.
 class SPEA2Evaluator
          The SPEA2Evaluator is a simple, non-coevolved generational evaluator which evaluates every single member of every subpopulation individually in its own problem space.
 class SPEA2MultiObjectiveFitness
          SPEA2MultiObjectiveFitness is a subclass of Fitness which implements basic multiobjective fitness functions along with support for the ECJ SPEA2 (Strength Pareto Evolutionary Algorithm) extensions.
 class SPEA2Subpopulation
          SPEA2Subpopulation is a simple subclass of Subpopulation which adds the archiveSize field.
 class SPEA2TournamentSelection
          Does a simple tournament selection, limited to the subpopulation it's working in at the time and only within the boundry of the SPEA2 archive (between 0-archiveSize).
 

Uses of Setup in ec.parsimony
 

Classes in ec.parsimony that implement Setup
 class BucketTournamentSelection
          Does a tournament selection, limited to the subpopulation it's working in at the time.
 class DoubleTournamentSelection
           
 class LexicographicTournamentSelection
          Does a simple tournament selection, limited to the subpopulation it's working in at the time.
 class ProportionalTournamentSelection
          This selection method adds parsimony pressure to the regular tournament selection.
 class RatioBucketTournamentSelection
          Does a tournament selection, limited to the subpopulation it's working in at the time.
 class TarpeianStatistics
          This Statistics subclass implements Poli's "Tarpeian" method of parsimony control, whereby some kill-proportion of above-average-sized individuals in each subpopulation have their fitnesses set to a very bad value, and marks them as already evaluated (so the Evaluator can skip them).
 

Uses of Setup in ec.pso
 

Classes in ec.pso that implement Setup
 class PSOBreeder
          PSOBreeder.java
 class PSOSubpopulation
          PSOSubpopulation.java
 

Uses of Setup in ec.rule
 

Classes in ec.rule that implement Setup
 class Rule
          Rule is an abstract class for describing rules.
 class RuleConstraints
          RuleConstraints is a class for constraints applicable to rules.
 class RuleIndividual
          RuleIndividual is an Individual with an array of RuleSets, each of which is a set of Rules.
 class RuleInitializer
          A SimpleInitializer subclass designed to be used with rules.
 class RuleSet
          RuleSet is a set of Rules, implemented straightforwardly as an arbitrary-length array of Rules.
 class RuleSetConstraints
          RuleSetConstraints is an basic class for constraints applicable to rulesets.
 class RuleSpecies
          RuleSpecies is a simple individual which is suitable as a species for rule sets subpopulations.
 

Uses of Setup in ec.rule.breed
 

Classes in ec.rule.breed that implement Setup
 class RuleCrossoverPipeline
          RuleCrossoverPipeline is a BreedingPipeline which implements a simple default crossover for RuleIndividuals.
 class RuleMutationPipeline
          RuleMutationPipeline is a BreedingPipeline which implements a simple default Mutation for RuleIndividuals.
 

Uses of Setup in ec.select
 

Classes in ec.select that implement Setup
 class BestSelection
          Picks among the best n individuals in a population in direct proportion to their absolute fitnesses as returned by their fitness() methods relative to the fitnesses of the other "best" individuals in that n.
 class FirstSelection
          Always picks the first individual in the subpopulation.
 class FitProportionateSelection
          Picks individuals in a population in direct proportion to their fitnesses as returned by their fitness() methods.
 class GreedyOverselection
          GreedyOverselection is a SelectionMethod which implements Koza-style fitness-proportionate greedy overselection.
 class MultiSelection
          MultiSelection is a SelectionMethod which stores some n subordinate SelectionMethods.
 class RandomSelection
          Picks a random individual in the subpopulation.
 class TournamentSelection
          Does a simple tournament selection, limited to the subpopulation it's working in at the time.
 

Uses of Setup in ec.simple
 

Classes in ec.simple that implement Setup
 class SimpleBreeder
          Breeds each subpopulation separately, with no inter-population exchange, and using a generational approach.
 class SimpleEvaluator
          The SimpleEvaluator is a simple, non-coevolved generational evaluator which evaluates every single member of every subpopulation individually in its own problem space.
 class SimpleEvolutionState
          A SimpleEvolutionState is an EvolutionState which implements a simple form of generational evolution.
 class SimpleExchanger
          A SimpleExchanger is a default Exchanger which, well, doesn't do anything.
 class SimpleFinisher
          SimpleFinisher is a default Finisher which doesn't do anything.
 class SimpleFitness
          A simple default fitness, consisting of a single floating-point value where fitness A is superior to fitness B if and only if A > B.
 class SimpleInitializer
          SimpleInitializer is a default Initializer which initializes a Population by calling the Population's populate(...) method.
 class SimpleShortStatistics
          A Simple-style statistics generator, intended to be easily parseable with awk or other Unix tools.
 class SimpleStatistics
          A basic Statistics class suitable for simple problem applications.
 

Uses of Setup in ec.spatial
 

Classes in ec.spatial that implement Setup
 class Spatial1DSubpopulation
          A Spatial1DSubpopulation is an EC subpopulation that is additionally embedded into a one-dimmensional space.
 class SpatialBreeder
          A slight modification of the simple breeder for spatially-embedded EAs.
 class SpatialMultiPopCoevolutionaryEvaluator
          SpatialMultiPopCoevolutionaryEvaluator implements a coevolutionary evaluator involving multiple spatially-embedded subpopulations.
 class SpatialTournamentSelection
          A slight modification of the tournament selection procedure for use with spatially-embedded EAs.
 

Uses of Setup in ec.steadystate
 

Classes in ec.steadystate that implement Setup
 class SteadyStateBreeder
           
 class SteadyStateEvaluator
           
 class SteadyStateEvolutionState
           
 

Uses of Setup in ec.vector
 

Classes in ec.vector that implement Setup
 class BitVectorIndividual
          BitVectorIndividual is a VectorIndividual whose genome is an array of booleans.
 class ByteVectorIndividual
          ByteVectorIndividual is a VectorIndividual whose genome is an array of bytes.
 class DoubleVectorIndividual
          DoubleVectorIndividual is a VectorIndividual whose genome is an array of doubles.
 class FloatVectorIndividual
          FloatVectorIndividual is a VectorIndividual whose genome is an array of floats.
 class FloatVectorSpecies
          FloatVectorSpecies is a subclass of VectorSpecies with special constraints for floating-point vectors, namely FloatVectorIndividual and DoubleVectorIndividual.
 class GeneVectorIndividual
          GeneVectorIndividual is a VectorIndividual whose genome is an array of VectorGenes.
 class GeneVectorSpecies
          GeneVectorSpecies is a subclass of VectorSpecies with special constraints for GeneVectorIndividuals.
 class IntegerVectorIndividual
          IntegerVectorIndividual is a VectorIndividual whose genome is an array of ints.
 class IntegerVectorSpecies
          IntegerVectorSpecies is a subclass of VectorSpecies with special constraints for integral vectors, namely ByteVectorIndividual, ShortVectorIndividual, IntegerVectorIndividual, and LongVectorIndividual.
 class LongVectorIndividual
          LongVectorIndividual is a VectorIndividual whose genome is an array of longs.
 class ShortVectorIndividual
          ShortVectorIndividual is a VectorIndividual whose genome is an array of shorts.
 class VectorGene
          VectorGene is an abstract superclass of objects which may be used in the genome array of GeneVectorIndividuals.
 class VectorIndividual
          VectorIndividual is the abstract superclass of simple individual representations which consist of vectors of values (booleans, integers, floating-point, etc.)
 class VectorSpecies
          VectorSpecies is a species which can create VectorIndividuals.
 

Uses of Setup in ec.vector.breed
 

Classes in ec.vector.breed that implement Setup
 class VectorCrossoverPipeline
          VectorCrossoverPipeline is a BreedingPipeline which implements a simple default crossover for VectorIndividuals.
 class VectorMutationPipeline
          VectorMutationPipeline is a BreedingPipeline which implements a simple default Mutation for VectorIndividuals.