Uses of Class
ec.EvolutionState

Packages that use EvolutionState
com.parabon.ec   
com.parabon.ec.simple   
com.parabon.ec.steadystate Opportunistic Evolution state classes. 
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.multiplexerslow The original ECJ implementation of the Koza-I Boolean-Multiplexer problem. 
ec.app.multiplexerslow.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.util   
ec.vector   
ec.vector.breed   
 

Uses of EvolutionState in com.parabon.ec
 

Methods in com.parabon.ec that return EvolutionState
 EvolutionState Evolve.getState()
          Gets the evolution state
 

Methods in com.parabon.ec with parameters of type EvolutionState
 void DummyStatistics.finalStatistics(EvolutionState state, int result)
           
 void DummyStatistics.generationBoundaryStatistics(EvolutionState state)
           
 void DummyStatistics.postBreedingStatistics(EvolutionState state)
           
 void DummyStatistics.postCheckpointStatistics(EvolutionState state)
           
 void DummyStatistics.postEvaluationStatistics(EvolutionState state)
           
 void DummyStatistics.postInitializationStatistics(EvolutionState state)
           
 void DummyStatistics.postPostBreedingExchangeStatistics(EvolutionState state)
           
 void DummyStatistics.postPreBreedingExchangeStatistics(EvolutionState state)
           
 void DummyStatistics.preBreedingStatistics(EvolutionState state)
           
 void DummyStatistics.preCheckpointStatistics(EvolutionState state)
           
 void DummyStatistics.preEvaluationStatistics(EvolutionState state)
           
 void DummyStatistics.preInitializationStatistics(EvolutionState state)
           
 void DummyStatistics.prePostBreedingExchangeStatistics(EvolutionState state)
           
 void DummyStatistics.prePreBreedingExchangeStatistics(EvolutionState state)
           
 void Evolve.setState(EvolutionState state)
          Sets the evolution state
 void DummyStatistics.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in com.parabon.ec.simple
 

Methods in com.parabon.ec.simple with parameters of type EvolutionState
 void FinalStatistics.finalStatistics(EvolutionState state, int result)
          Prints the usual final statistics and then prints all individuals and their fitness scores.
 void SimpleBoundedFitness.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in com.parabon.ec.steadystate
 

Methods in com.parabon.ec.steadystate with parameters of type EvolutionState
 void SteadyStateEvolutionState.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec
 

Methods in ec that return EvolutionState
static EvolutionState Evolve.initialize(ParameterDatabase parameters, int randomSeedOffset)
          Initializes an evolutionary run given the parameters and a random seed adjustment (added to each random seed).
static EvolutionState Evolve.possiblyRestoreFromCheckpoint(java.lang.String[] args)
          Restores an EvolutionState from checkpoint if "-checkpoint FILENAME" is in the command-line arguments.
 

Methods in ec with parameters of type EvolutionState
abstract  Population Breeder.breedPopulation(EvolutionState state)
          Breeds state.population, returning a new population.
static void Evolve.cleanup(EvolutionState state)
          Begins a fresh evolutionary run with a given state.
 void Problem.closeContacts(EvolutionState state, int result)
          Called to shut down remote evaluation network contacts when the run is completed.
 void Evaluator.closeContacts(EvolutionState state, int result)
          Called to shut down remote evaluation network contacts when the run is completed.
abstract  void Exchanger.closeContacts(EvolutionState state, int result)
          Closes contacts with other processes, if that's what you're doing.
 void Problem.describe(Individual ind, EvolutionState state, int threadnum, int log, int verbosity)
          Deprecated. 
 void Problem.describe(Individual ind, EvolutionState state, int subpopulation, int threadnum, int log, int verbosity)
           
 void Problem.evaluate(EvolutionState state, Individual ind, int threadnum)
          Deprecated. 
 void Problem.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
           
abstract  void Evaluator.evaluatePopulation(EvolutionState state)
          Evaluates the fitness of an entire population.
 void Statistics.finalStatistics(EvolutionState state, int result)
          Called immediately after the run has completed.
 void Problem.finishEvaluating(EvolutionState state, int threadnum)
          Will be called by the Evaluator after prepareToEvaluate(...) is called and then a series of individuals are evaluated.
abstract  void Finisher.finishPopulation(EvolutionState state, int result)
          Cleans up the population after the run has completed.
 void SelectionMethod.finishProducing(EvolutionState s, int subpopulation, int thread)
          A default version of finishProducing, which does nothing.
abstract  void BreedingSource.finishProducing(EvolutionState s, int subpopulation, int thread)
          Called after produce(...), usually once a generation, or maybe only once if you're doing steady-state evolution (at the end of the run).
 void BreedingPipeline.finishProducing(EvolutionState state, int subpopulation, int thread)
           
 void Statistics.generationBoundaryStatistics(EvolutionState state)
          STEADY-STATE: called each time the generation count increments
 void Problem.initializeContacts(EvolutionState state)
          Called to set up remote evaluation network contacts when the run is started.
 void Evaluator.initializeContacts(EvolutionState state)
          Called to set up remote evaluation network contacts when the run is started.
abstract  void Exchanger.initializeContacts(EvolutionState state)
          Initializes contacts with other processes, if that's what you're doing.
abstract  Population Initializer.initialPopulation(EvolutionState state, int thread)
          Creates and returns a new initial population for the evolutionary run.
 Individual Species.newIndividual(EvolutionState state, java.io.DataInput dataInput)
          Provides an individual read from a DataInput source, including the fitness.
 Individual Species.newIndividual(EvolutionState state, int thread)
          Provides a brand-new individual to fill in a population.
 Individual Species.newIndividual(EvolutionState state, java.io.LineNumberReader reader)
          Provides an individual read from a stream, including the fitness; the individual will appear as it was written by printIndividual(...).
protected  void Individual.parseGenotype(EvolutionState state, java.io.LineNumberReader reader)
          This method is used only by the default version of readIndividual(state,reader), and it is intended to be overridden to parse in that part of the individual that was outputted in the genotypeToString() method.
 void Population.populate(EvolutionState state, int thread)
          Populates the population with new random individuals.
 void Subpopulation.populate(EvolutionState state, int thread)
           
abstract  Population Exchanger.postBreedingExchangePopulation(EvolutionState state)
          Performs exchanges after the population has been bred but before it has been evaluated, once every generation (or pseudogeneration).
 void Statistics.postBreedingStatistics(EvolutionState state)
          GENERATIONAL: Called immediately after breeding occurs.
 void Statistics.postCheckpointStatistics(EvolutionState state)
          Called immediately after checkpointing occurs.
 void Statistics.postEvaluationStatistics(EvolutionState state)
          GENERATIONAL: Called immediately after evaluation occurs.
 void Statistics.postInitializationStatistics(EvolutionState state)
          GENERATIONAL: Called immediately after population initialization occurs.
 void Statistics.postPostBreedingExchangeStatistics(EvolutionState state)
          Called immediately after the post-breeding exchange occurs.
 void Statistics.postPreBreedingExchangeStatistics(EvolutionState state)
          Called immediately after the pre-breeding exchange occurs.
abstract  Population Exchanger.preBreedingExchangePopulation(EvolutionState state)
          Performs exchanges after the population has been evaluated but before it has been bred, once every generation (or pseudogeneration).
 void Statistics.preBreedingStatistics(EvolutionState state)
          GENERATIONAL: Called immediately before breeding occurs.
 void Statistics.preCheckpointStatistics(EvolutionState state)
          Called immediately before checkpointing occurs.
 void Statistics.preEvaluationStatistics(EvolutionState state)
          GENERATIONAL: Called immediately before evaluation occurs.
 void Statistics.preInitializationStatistics(EvolutionState state)
          Called immediately before population initialization occurs.
 void Problem.prepareToEvaluate(EvolutionState state, int threadnum)
          May be called by the Evaluator prior to a series of individuals to evaluate, and then ended with a finishEvaluating(...).
 void SelectionMethod.prepareToProduce(EvolutionState s, int subpopulation, int thread)
          A default version of prepareToProduce which does nothing.
abstract  void BreedingSource.prepareToProduce(EvolutionState state, int subpopulation, int thread)
          Called before produce(...), usually once a generation, or maybe only once if you're doing steady-state evolution, to let the breeding source "warm up" prior to producing.
 void BreedingPipeline.prepareToProduce(EvolutionState state, int subpopulation, int thread)
           
 void Statistics.prePostBreedingExchangeStatistics(EvolutionState state)
          Called immediately before the post-breeding exchange occurs.
 void Statistics.prePreBreedingExchangeStatistics(EvolutionState state)
          Called immediately before the pre-breeding exchange occurs.
 void Fitness.printFitness(EvolutionState state, int log, int verbosity)
          Should print the fitness out in a computer-readable fashion, using state.output.println(...,verbosity,log).
 void Fitness.printFitness(EvolutionState state, java.io.PrintWriter writer)
          Should print the fitness out in a computer-readable fashion, using writer.println(...).
 void Fitness.printFitnessForHumans(EvolutionState state, int log, int verbosity)
          Should print the fitness out fashion pleasing for humans to read, using state.output.println(...,verbosity,log).
 void Individual.printIndividual(EvolutionState state, int log, int verbosity)
          Should print the individual in a way that can be read by computer, including its fitness, using state.output.println(...,verbosity,log) You can get fitness to print itself at the appropriate time by calling fitness.printFitness(state,log,verbosity);
 void Individual.printIndividual(EvolutionState state, java.io.PrintWriter writer)
          Should print the individual in a way that can be read by computer, including its fitness.
 void Individual.printIndividualForHumans(EvolutionState state, int log, int verbosity)
          Should print the individual out in a pleasing way for humans, including its fitness, using state.output.println(...,verbosity,log) You can get fitness to print itself at the appropriate time by calling fitness.printFitnessForHumans(state,log,verbosity);
 void Population.printPopulation(EvolutionState state, int log, int verbosity)
          Prints an entire population in a form readable by humans but also parseable by the computer using readPopulation(EvolutionState, LineNumberReader).
 void Population.printPopulation(EvolutionState state, java.io.PrintWriter writer)
          Prints an entire population in a form readable by humans but also parseable by the computer using readPopulation(EvolutionState, LineNumberReader).
 void Population.printPopulationForHumans(EvolutionState state, int log, int verbosity)
          Prints an entire population in a form readable by humans.
 void Subpopulation.printSubpopulation(EvolutionState state, int log, int verbosity)
          Prints an entire subpopulation in a form readable by humans but also parseable by the computer using readSubpopulation(EvolutionState, LineNumberReader).
 void Subpopulation.printSubpopulation(EvolutionState state, java.io.PrintWriter writer)
          Prints an entire subpopulation in a form readable by humans but also parseable by the computer using readSubpopulation(EvolutionState, LineNumberReader).
 void Subpopulation.printSubpopulationForHumans(EvolutionState state, int log, int verbosity)
          Prints an entire subpopulation in a form readable by humans.
abstract  int SelectionMethod.produce(int subpopulation, EvolutionState state, int thread)
          An alternative form of "produce" special to Selection Methods; selects an individual from the given subpopulation and returns its position in that subpopulation.
 int SelectionMethod.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
abstract  int BreedingSource.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
          Produces n individuals from the given subpopulation and puts them into inds[start...start+n-1], where n = Min(Max(q,min),max), where q is the "typical" number of individuals the BreedingSource produces in one shot, and returns n.
 boolean SelectionMethod.produces(EvolutionState state, Population newpop, int subpopulation, int thread)
          A default version of produces -- this method always returns true under the assumption that the selection method works with all Fitnesses.
abstract  boolean BreedingSource.produces(EvolutionState state, Population newpop, int subpopulation, int thread)
          Returns true if this BreedingSource, when attached to the given subpopulation, will produce individuals of the subpopulation's species.
 boolean BreedingPipeline.produces(EvolutionState state, Population newpop, int subpopulation, int thread)
           
 void Fitness.readFitness(EvolutionState state, java.io.DataInput dataInput)
          Reads the binary form of an individual from a DataInput.
 void Fitness.readFitness(EvolutionState state, java.io.LineNumberReader reader)
          Reads in the fitness from a form outputted by fitnessToString() and thus printFitnessForHumans(...).
 void Individual.readGenotype(EvolutionState state, java.io.DataInput dataInput)
          Reads in the genotypic information from a DataInput, erasing the previous genotype of this Individual.
 void Individual.readIndividual(EvolutionState state, java.io.DataInput dataInput)
          Reads the binary form of an individual from a DataInput, erasing the previous information stored in this Individual.
 void Individual.readIndividual(EvolutionState state, java.io.LineNumberReader reader)
          Reads in the individual from a form printed by printIndividual(), erasing the previous information stored in this Individual.
 void Population.readPopulation(EvolutionState state, java.io.DataInput dataInput)
          Reads a population in binary form, from the format generated by writePopulation(...).
 void Population.readPopulation(EvolutionState state, java.io.LineNumberReader reader)
          Reads a population from the format generated by printPopulation(....).
 void Subpopulation.readSubpopulation(EvolutionState state, java.io.DataInput dataInput)
          Reads a subpopulation in binary form, from the format generated by writeSubpopulation(...).
 void Subpopulation.readSubpopulation(EvolutionState state, java.io.LineNumberReader reader)
          Reads a subpopulation from the format generated by printSubpopulation(....).
 void Problem.reinitializeContacts(EvolutionState state)
          Called to reinitialize remote evaluation network contacts when the run is restarted from checkpoint.
 void Evaluator.reinitializeContacts(EvolutionState state)
          Called to reinitialize remote evaluation network contacts when the run is restarted from checkpoint.
abstract  void Exchanger.reinitializeContacts(EvolutionState state)
          Initializes contacts with other processes, if that's what you're doing.
abstract  boolean Evaluator.runComplete(EvolutionState state)
          Returns true if an ideal individual has been found or some other run result has shortcircuited the run so that it should end prematurely right now.
abstract  java.lang.String Exchanger.runComplete(EvolutionState state)
          Called after preBreedingExchangePopulation(...) to evaluate whether or not the exchanger wishes the run to shut down (with ec.EvolutionState.R_FAILURE) -- returns a String (which will be printed out as a message) if the exchanger wants to shut down, else returns null if the exchanger does NOT want to shut down.
 void Prototype.setup(EvolutionState state, Parameter base)
          Sets up the object by reading it from the parameters stored in state, built off of the parameter base base.
 void Fitness.setup(EvolutionState state, Parameter base)
           
 void Problem.setup(EvolutionState state, Parameter base)
           
 void Individual.setup(EvolutionState state, Parameter base)
           
 void Statistics.setup(EvolutionState state, Parameter base)
           
 void Population.setup(EvolutionState state, Parameter base)
           
 void BreedingSource.setup(EvolutionState state, Parameter base)
          Sets up the BreedingPipeline.
 void Species.setup(EvolutionState state, Parameter base)
          The default version of setup(...) loads requested pipelines and calls setup(...) on them and normalizes their probabilities.
 void Evaluator.setup(EvolutionState state, Parameter base)
           
 void Setup.setup(EvolutionState state, Parameter base)
          Sets up the object by reading it from the parameters stored in state, built off of the parameter base base.
 void BreedingPipeline.setup(EvolutionState state, Parameter base)
           
 void Subpopulation.setup(EvolutionState state, Parameter base)
           
 void EvolutionState.setup(EvolutionState state, Parameter base)
           
abstract  Population Initializer.setupPopulation(EvolutionState state, int thread)
           
 void Fitness.writeFitness(EvolutionState state, java.io.DataOutput dataOutput)
          Writes the binary form of an individual out to a DataOutput.
 void Individual.writeGenotype(EvolutionState state, java.io.DataOutput dataOutput)
          Writes the genotypic information to a DataOutput.
 void Individual.writeIndividual(EvolutionState state, java.io.DataOutput dataOutput)
          Writes the binary form of an individual out to a DataOutput.
 void Population.writePopulation(EvolutionState state, java.io.DataOutput dataOutput)
          Writes a population in binary form, in a format readable by readPopulation(EvolutionState, DataInput).
 void Subpopulation.writeSubpopulation(EvolutionState state, java.io.DataOutput dataOutput)
          Writes a subpopulation in binary form, in a format readable by readSubpopulation(EvolutionState, DataInput).
 

Uses of EvolutionState in ec.app.ant
 

Methods in ec.app.ant with parameters of type EvolutionState
 void Ant.describe(Individual ind, EvolutionState state, int threadnum, int log, int verbosity)
           
 void Ant.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
           
 void AntStatistics.finalStatistics(EvolutionState state, int result)
           
 void Ant.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.app.ant.func
 

Methods in ec.app.ant.func with parameters of type EvolutionState
 void Progn2.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Right.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Move.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void IfFoodAhead.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Left.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Progn4.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Progn3.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Progn2.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Right.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Move.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void IfFoodAhead.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Left.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Progn4.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Progn3.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void EvalPrint.evalPrint(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem, int[][] map2)
           
 void Progn2.evalPrint(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem, int[][] map2)
           
 void Right.evalPrint(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem, int[][] map2)
           
 void Move.evalPrint(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem, int[][] map2)
          Just like eval, but it retraces the map and prints out info
 void IfFoodAhead.evalPrint(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem, int[][] map2)
           
 void Left.evalPrint(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem, int[][] map2)
           
 void Progn4.evalPrint(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem, int[][] map2)
           
 void Progn3.evalPrint(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem, int[][] map2)
           
 

Uses of EvolutionState in ec.app.coevolve1
 

Methods in ec.app.coevolve1 with parameters of type EvolutionState
 void CompetitiveMaxOne.evaluate(EvolutionState state, Individual[] ind, boolean[] updateFitness, boolean countVictoriesOnly, int threadnum)
           
 void CompetitiveMaxOne.evaluate(EvolutionState state, Individual[] ind, boolean[] updateFitness, boolean countVictoriesOnly, int[] subpops, int threadnum)
           
 void CompetitiveMaxOne.postprocessPopulation(EvolutionState state, Population pop)
           
 void CompetitiveMaxOne.preprocessPopulation(EvolutionState state, Population pop)
           
 

Uses of EvolutionState in ec.app.coevolve2
 

Methods in ec.app.coevolve2 with parameters of type EvolutionState
 void CoevolutionaryRosenbrock.evaluate(EvolutionState state, Individual[] ind, boolean[] updateFitness, boolean countVictoriesOnly, int threadnum)
           
 void CoevolutionaryRosenbrock.evaluate(EvolutionState state, Individual[] ind, boolean[] updateFitness, boolean countVictoriesOnly, int[] subpops, int threadnum)
           
 void CoevolutionaryRosenbrock.postprocessPopulation(EvolutionState state, Population pop)
           
 void CoevolutionaryRosenbrock.preprocessPopulation(EvolutionState state, Population pop)
           
 

Uses of EvolutionState in ec.app.ecsuite
 

Methods in ec.app.ecsuite with parameters of type EvolutionState
 void ECSuite.describe(Individual ind, EvolutionState state, int threadnum, int log, int verbosity)
           
 void ECSuite.describe(Individual ind, EvolutionState state, int subpopulation, int threadnum, int log, int verbosity)
           
 void ECSuite.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
           
 void ECSuite.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.app.edge
 

Methods in ec.app.edge with parameters of type EvolutionState
 void EdgeShortStatistics._postEvaluationStatistics(EvolutionState state)
           
 void Edge.describe(Individual ind, EvolutionState state, int threadnum, int log, int verbosity)
           
 java.lang.String Edge.describeShortGeneralized(Individual ind, EvolutionState state, int threadnum)
           
 void Edge.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
           
 void EdgeStatistics.finalStatistics(EvolutionState state, int result)
           
 void Edge.fullTest(EvolutionState state, Individual ind, int threadnum, boolean[][] pos, boolean[][] neg)
          Tests an individual, returning its successful positives in totpos and its successful negatives in totneg.
 void Edge.printBits(EvolutionState state, boolean[][] bits)
           
 boolean[][] Edge.restrictToSize(int size, boolean[][] cases, EvolutionState state, int thread)
           
 void Edge.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.app.edge.func
 

Methods in ec.app.edge.func with parameters of type EvolutionState
 void Double.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Reverse.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void BLoop.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Split.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Loop.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Bud.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void BAccept.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Accept.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Epsilon.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void BBud.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Zero.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void BStart.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Start.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void One.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Double.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Reverse.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void BLoop.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Split.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Loop.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Bud.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void BAccept.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Accept.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Epsilon.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void BBud.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Zero.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void BStart.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Start.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void One.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 

Uses of EvolutionState in ec.app.lawnmower
 

Methods in ec.app.lawnmower with parameters of type EvolutionState
 void Lawnmower.describe(Individual ind, EvolutionState state, int threadnum, int log, int verbosity)
           
 void Lawnmower.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
           
 void LawnmowerStatistics.finalStatistics(EvolutionState state, int result)
           
 void Lawnmower.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.app.lawnmower.func
 

Methods in ec.app.lawnmower.func with parameters of type EvolutionState
 void V8a.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Progn2.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Frog.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Left.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Mow.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void V8a.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Progn2.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Frog.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void LawnERC.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Left.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Mow.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void LawnERC.readNode(EvolutionState state, java.io.DataInput dataInput)
           
 void LawnERC.resetNode(EvolutionState state, int thread)
           
 void LawnERC.setup(EvolutionState state, Parameter base)
           
 void LawnERC.writeNode(EvolutionState state, java.io.DataOutput dataOutput)
           
 

Uses of EvolutionState in ec.app.multiplexer
 

Methods in ec.app.multiplexer with parameters of type EvolutionState
 void Multiplexer.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
           
 void Multiplexer.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.app.multiplexer.func
 

Methods in ec.app.multiplexer.func with parameters of type EvolutionState
 void A0.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Or.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void And.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D1.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D7.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D0.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D6.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void If.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D5.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D4.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void A2.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Not.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D3.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void A1.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D2.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void A0.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Or.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void And.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D1.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D7.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D0.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D6.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void If.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D5.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D4.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void A2.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Not.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D3.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void A1.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D2.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 

Uses of EvolutionState in ec.app.multiplexerslow
 

Methods in ec.app.multiplexerslow with parameters of type EvolutionState
 void Multiplexer.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
           
 void Multiplexer.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.app.multiplexerslow.func
 

Methods in ec.app.multiplexerslow.func with parameters of type EvolutionState
 void A0.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Or.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void And.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D1.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D7.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D0.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D6.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void If.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D5.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D4.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void A2.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Not.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D3.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void A1.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D2.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void A0.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Or.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void And.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D1.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D7.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D0.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D6.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void If.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D5.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D4.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void A2.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Not.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D3.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void A1.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D2.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 

Uses of EvolutionState in ec.app.parity
 

Methods in ec.app.parity with parameters of type EvolutionState
 void Parity.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
           
 void Parity.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.app.parity.func
 

Methods in ec.app.parity.func with parameters of type EvolutionState
 void Nor.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D27.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Or.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D20.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void And.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D8.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D14.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D1.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D26.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D7.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D13.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D0.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D31.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D25.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D19.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D6.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D12.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D30.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D24.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D18.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D5.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D11.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D23.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D17.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D4.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D10.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D29.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D22.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D16.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D3.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D28.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D21.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D9.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D15.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void D2.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Nand.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Nor.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D27.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Or.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D20.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void And.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D8.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D14.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D1.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D26.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D7.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D13.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D0.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D31.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D25.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D19.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D6.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D12.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D30.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D24.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D18.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D5.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D11.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D23.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D17.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D4.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D10.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D29.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D22.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D16.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D3.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D28.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D21.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D9.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D15.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void D2.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Nand.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 

Uses of EvolutionState in ec.app.regression
 

Methods in ec.app.regression with parameters of type EvolutionState
 void Regression.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
           
 void Regression.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.app.regression.func
 

Methods in ec.app.regression.func with parameters of type EvolutionState
 void Add.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Cos.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Sin.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void X.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Div.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Sub.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Log.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Mul.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Exp.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Add.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void RegERC.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Cos.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Sin.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void X.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Div.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Sub.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Log.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Mul.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Exp.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void RegERC.readNode(EvolutionState state, java.io.DataInput dataInput)
           
 void RegERC.resetNode(EvolutionState state, int thread)
           
 void RegERC.writeNode(EvolutionState state, java.io.DataOutput dataOutput)
           
 

Uses of EvolutionState in ec.app.sum
 

Methods in ec.app.sum with parameters of type EvolutionState
 void Sum.describe(Individual ind, EvolutionState state, int threadnum, int log, int verbosity)
           
 void Sum.evaluate(EvolutionState state, Individual ind, int subpop, int threadnum)
           
 

Uses of EvolutionState in ec.app.twobox
 

Methods in ec.app.twobox with parameters of type EvolutionState
 void TwoBox.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
           
 void TwoBox.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.app.twobox.func
 

Methods in ec.app.twobox.func with parameters of type EvolutionState
 void Add.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void L1.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void L0.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void W1.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void H1.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Div.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Sub.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void W0.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Mul.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void H0.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
           
 void Add.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void L1.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void L0.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void W1.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void H1.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Div.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Sub.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void W0.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void Mul.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void H0.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 

Uses of EvolutionState in ec.breed
 

Methods in ec.breed with parameters of type EvolutionState
 void BufferedBreedingPipeline.prepareToProduce(EvolutionState state, int subpopulation, int thread)
           
 int ReproductionPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int MultiBreedingPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int ForceBreedingPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int GenerationSwitchPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int BufferedBreedingPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 void ReproductionPipeline.setup(EvolutionState state, Parameter base)
           
 void MultiBreedingPipeline.setup(EvolutionState state, Parameter base)
           
 void ForceBreedingPipeline.setup(EvolutionState state, Parameter base)
           
 void GenerationSwitchPipeline.setup(EvolutionState state, Parameter base)
           
 void BufferedBreedingPipeline.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.coevolve
 

Methods in ec.coevolve with parameters of type EvolutionState
 void MultiPopCoevolutionaryEvaluator.afterCoevolutionaryEvaluation(EvolutionState state, Population population, GroupedProblemForm prob)
           
 void MultiPopCoevolutionaryEvaluator.beforeCoevolutionaryEvaluation(EvolutionState state, Population population, GroupedProblemForm prob)
           
 void CompetitiveEvaluator.evalNRandomOneWay(EvolutionState state, int[] from, int[] numinds, Individual[] individuals, GroupedProblemForm prob)
           
 void CompetitiveEvaluator.evalNRandomOneWayPopChunk(EvolutionState state, int from, int numinds, int threadnum, Individual[] individuals, GroupedProblemForm prob)
           
 void CompetitiveEvaluator.evalNRandomTwoWay(EvolutionState state, int[] from, int[] numinds, Individual[] individuals, GroupedProblemForm prob)
           
 void CompetitiveEvaluator.evalNRandomTwoWayPopChunk(EvolutionState state, int from, int numinds, int threadnum, Individual[] individuals, GroupedProblemForm prob)
           
 void CompetitiveEvaluator.evalPseudoRoundRobin(EvolutionState state, Individual[] individuals, GroupedProblemForm prob)
           
 void CompetitiveEvaluator.evalPseudoRoundRobinPopChunk(EvolutionState state, int from, int numinds, int threadnum, Individual[] individuals, GroupedProblemForm prob)
           
 void CompetitiveEvaluator.evalRoundRobin(EvolutionState state, int[] from, int[] numinds, Individual[] individuals, GroupedProblemForm prob)
           
 void CompetitiveEvaluator.evalRoundRobinPopChunk(EvolutionState state, int from, int numinds, int threadnum, Individual[] individuals, GroupedProblemForm prob)
          A private helper function for evalutatePopulation which evaluates a chunk of individuals in a subpopulation for a given thread.
 void CompetitiveEvaluator.evalSingleElimination(EvolutionState state, Individual[] individuals, GroupedProblemForm prob)
           
 void GroupedProblemForm.evaluate(EvolutionState state, Individual[] ind, boolean[] updateFitness, boolean countVictoriesOnly, int threadnum)
          Deprecated. 
 void GroupedProblemForm.evaluate(EvolutionState state, Individual[] ind, boolean[] updateFitness, boolean countVictoriesOnly, int[] subpops, int threadnum)
          Evaluates the individuals found in ind together.
 void MultiPopCoevolutionaryEvaluator.evaluatePopulation(EvolutionState state)
           
 void CompetitiveEvaluator.evaluatePopulation(EvolutionState state)
          An evaluator that performs coevolutionary evaluation.
 void MultiPopCoevolutionaryEvaluator.loadElites(EvolutionState state, Subpopulation subpop, int whichSubpop)
           
 void MultiPopCoevolutionaryEvaluator.performCoevolutionaryEvaluation(EvolutionState state, Population population, GroupedProblemForm prob)
           
 void GroupedProblemForm.postprocessPopulation(EvolutionState state, Population pop)
          Finish processing the population (such as fitness information) after evaluation.
 void GroupedProblemForm.preprocessPopulation(EvolutionState state, Population pop)
          Set up the population pop (such as fitness information) prior to evaluation.
 void CompetitiveEvaluator.randomizeOrder(EvolutionState state, Individual[] individuals)
           
 boolean MultiPopCoevolutionaryEvaluator.runComplete(EvolutionState state)
           
 boolean CompetitiveEvaluator.runComplete(EvolutionState state)
           
 void MultiPopCoevolutionaryEvaluator.setup(EvolutionState state, Parameter base)
           
 void CompetitiveEvaluator.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.de
 

Methods in ec.de with parameters of type EvolutionState
 Population DEBreeder.breedPopulation(EvolutionState state)
           
 Individual Best1BinDEBreeder.createIndividual(EvolutionState state, int subpop, Individual[] inds, int index, int thread)
           
 Individual Rand1EitherOrDEBreeder.createIndividual(EvolutionState state, int subpop, Individual[] inds, int index, int thread)
           
 Individual DEBreeder.createIndividual(EvolutionState state, int subpop, Individual[] inds, int index, int thread)
           
 Individual Rand1ExpDEBreeder.createIndividual(EvolutionState state, int subpop, Individual[] inds, int index, int thread)
           
 void DEStatistics.postEvaluationStatistics(EvolutionState state)
           
 void Best1BinDEBreeder.prepareDEBreeder(EvolutionState state)
           
 void DEBreeder.prepareDEBreeder(EvolutionState state)
           
 void Best1BinDEBreeder.setup(EvolutionState state, Parameter base)
           
 void Rand1EitherOrDEBreeder.setup(EvolutionState state, Parameter base)
           
 void DEBreeder.setup(EvolutionState state, Parameter base)
           
 void Rand1ExpDEBreeder.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.es
 

Methods in ec.es with parameters of type EvolutionState
 void MuCommaLambdaBreeder.breedPopChunk(Population newpop, EvolutionState state, int[] numinds, int[] from, int threadnum)
          A private helper function for breedPopulation which breeds a chunk of individuals in a subpopulation for a given thread.
 Population MuCommaLambdaBreeder.breedPopulation(EvolutionState state)
           
 Population MuCommaLambdaBreeder.postProcess(Population newpop, Population oldpop, EvolutionState state)
          A hook for Mu+Lambda, not used in Mu,Lambda
 Population MuPlusLambdaBreeder.postProcess(Population newpop, Population oldpop, EvolutionState state)
           
 void ESSelection.prepareToProduce(EvolutionState state, int subpopulation, int thread)
           
 int ESSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int ESSelection.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 Population MuCommaLambdaBreeder.setToLambda(Population pop, EvolutionState state)
          Sets all subpopulations in pop to the expected lambda size.
 Population MuPlusLambdaBreeder.setToMuPlusLambda(Population pop, EvolutionState state)
          Sets all subpopulations in pop to the expected mu+lambda size.
 void MuCommaLambdaBreeder.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.eval
 

Fields in ec.eval declared as EvolutionState
 EvolutionState MasterProblemServer.state
           
 EvolutionState SlaveMonitor.state
           
 

Methods in ec.eval with parameters of type EvolutionState
 void MasterProblem.closeContacts(EvolutionState state, int result)
          Gracefully close contacts with the slaves
 void MasterProblem.describe(Individual ind, EvolutionState state, int threadnum, int log, int verbosity)
           
 void MasterProblem.describe(Individual ind, EvolutionState state, int subpopulation, int threadnum, int log, int verbosity)
           
 void MasterProblem.evaluate(EvolutionState state, Individual[] ind, boolean[] updateFitness, boolean countVictoriesOnly, int threadnum)
           
 void MasterProblem.evaluate(EvolutionState state, Individual[] inds, boolean[] updateFitness, boolean countVictoriesOnly, int[] subpops, int threadnum)
           
 void MasterProblem.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
           
static void Slave.evaluateGroupedProblemForm(EvolutionState state, boolean returnIndividuals, java.io.DataInputStream dataIn, java.io.DataOutputStream dataOut)
           
static void Slave.evaluateSimpleProblemForm(EvolutionState state, boolean returnIndividuals, java.io.DataInputStream dataIn, java.io.DataOutputStream dataOut, java.lang.String[] args)
           
 void MasterProblem.finishEvaluating(EvolutionState state, int threadnum)
           
 void MasterProblem.flush(EvolutionState state, int threadnum)
           
 QueueIndividual MasterProblemServer.getEvaluatedIndividual(EvolutionState state)
           
 QueueIndividual IMasterProblemServer.getEvaluatedIndividual(EvolutionState state)
           
 Individual MasterProblem.getNextEvaluatedIndividual(EvolutionState state)
          This method blocks until an individual is available from the slaves (which will cause evaluatedIndividualAvailable() to return true), at which time it returns the individual.
 void MasterProblem.initializeContacts(EvolutionState state)
          Initialize contacts with the slaves
 QueueIndividual MasterProblemServer.pollNextEvaluatedIndividual(EvolutionState state, long timeoutInMilliseconds)
           
 QueueIndividual IMasterProblemServer.pollNextEvaluatedIndividual(EvolutionState state, long timeoutInMilliseconds)
          Polls for the next evaluated individual.
 void MasterProblem.postprocessPopulation(EvolutionState state, Population pop)
           
 void MasterProblem.prepareToEvaluate(EvolutionState state, int threadnum)
           
 void MasterProblem.preprocessPopulation(EvolutionState state, Population pop)
           
 void SlaveMonitor.registerSlave(EvolutionState state, java.lang.String name, java.net.Socket socket, java.io.DataOutputStream out, java.io.DataInputStream in)
          Registers a new slave with the monitor.
 void MasterProblem.reinitializeContacts(EvolutionState state)
          Reinitialize contacts with the slaves
 void MasterProblemServer.scheduleJobForEvaluation(EvolutionState state, Job ed)
           
 void SlaveMonitor.scheduleJobForEvaluation(EvolutionState state, Job job)
          Schedules a job for execution on one of the available slaves.
 void IMasterProblemServer.scheduleJobForEvaluation(EvolutionState state, Job ed)
          Schedules a remote evaluation.
 void MasterProblem.setup(EvolutionState state, Parameter base)
           
 void MasterProblemServer.setupServerFromDatabase(EvolutionState state)
          After the MasterProblemServer is created, it needs to be told to initialize itself from information in the parameter database.
 void IMasterProblemServer.setupServerFromDatabase(EvolutionState state)
          Initializes the server
 void MasterProblemServer.waitForAllSlavesToFinishEvaluating(EvolutionState state)
           
 void SlaveMonitor.waitForAllSlavesToFinishEvaluating(EvolutionState state)
          This method returns only when all slaves have finished the jobs that they were assigned.
 void IMasterProblemServer.waitForAllSlavesToFinishEvaluating(EvolutionState state)
          Wait for remote evaluation to complete.
 Individual MasterProblemServer.waitForIndividual(EvolutionState state)
           
 Individual IMasterProblemServer.waitForIndividual(EvolutionState state)
          Wait for one individual to complete evaluation.
 

Uses of EvolutionState in ec.exchange
 

Methods in ec.exchange with parameters of type EvolutionState
 void InterPopulationExchange.closeContacts(EvolutionState state, int result)
          Closes contacts with other processes, if that's what you're doing.
 void IslandExchange.closeContacts(EvolutionState state, int result)
          Closes contacts with other processes, if that's what you're doing.
 void IslandExchange.fireUpServer(EvolutionState state, Parameter serverBase)
          Fires up the server.
 void InterPopulationExchange.initializeContacts(EvolutionState state)
          Initializes contacts with other processes, if that's what you're doing.
 void IslandExchange.initializeContacts(EvolutionState state)
          Initializes contacts with other processes, if that's what you're doing.
 Population InterPopulationExchange.postBreedingExchangePopulation(EvolutionState state)
           
 Population IslandExchange.postBreedingExchangePopulation(EvolutionState state)
           
 Population InterPopulationExchange.preBreedingExchangePopulation(EvolutionState state)
           
 Population IslandExchange.preBreedingExchangePopulation(EvolutionState state)
           
 void InterPopulationExchange.reinitializeContacts(EvolutionState state)
          Initializes contacts with other processes, if that's what you're doing.
 void IslandExchange.reinitializeContacts(EvolutionState state)
          Initializes contacts with other processes, if that's what you're doing.
 java.lang.String InterPopulationExchange.runComplete(EvolutionState state)
          Called after preBreedingExchangePopulation(...) to evaluate whether or not the exchanger wishes the run to shut down (with ec.EvolutionState.R_FAILURE).
 java.lang.String IslandExchange.runComplete(EvolutionState state)
          Called after preBreedingExchangePopulation(...) to evaluate whether or not the exchanger wishes the run to shut down (with ec.EvolutionState.R_FAILURE).
 void InterPopulationExchange.setup(EvolutionState state, Parameter _base)
           
 void IslandExchange.setup(EvolutionState state, Parameter _base)
           
protected  IslandInfo IslandExchangeServer.setupIslandInfo(EvolutionState state, Parameter localBase, Parameter islandBase)
          Populates ECJ island info.
protected abstract  D AbstractIslandExchangeServer.setupIslandInfo(EvolutionState state, Parameter localBase, Parameter islandBase)
           
 void IslandExchangeServer.setupServerFromDatabase(EvolutionState state_p, Parameter base)
          This setup should get called from the IslandExchange setup method.
 void AbstractIslandExchangeServer.setupServerFromDatabase(EvolutionState state, Parameter base)
           
protected  void AbstractIslandExchangeServer.setupStandardIslandInfo(EvolutionState state, Parameter localBase, IslandInfo ieii)
          Populates island info from parameter database
 

Uses of EvolutionState in ec.gp
 

Methods in ec.gp with parameters of type EvolutionState
 void GPTree.buildTree(EvolutionState state, int thread)
          Builds a new randomly-generated rooted tree and attaches it to the GPTree.
 void ERC.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
          Checks to make certain that the ERC has no children.
 void GPNode.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
          You ought to override this method to check to make sure that the constraints are valid as best you can tell.
 void ADF.checkConstraints(EvolutionState state, int tree, GPIndividual typicalIndividual, Parameter individualBase)
          Checks type-compatibility constraints between the ADF, its argument terminals, and the tree type of its associated tree, and also checks to make sure the tree exists, there aren't invalid argument terminals in it, and there are sufficient argument terminals (a warning).
static GPNodeConstraints GPNodeConstraints.constraintsFor(java.lang.String constraintsName, EvolutionState state)
          You must guarantee that after calling constraintsFor(...) one or several times, you call state.output.exitIfErrors() once.
static GPTreeConstraints GPTreeConstraints.constraintsFor(java.lang.String constraintsName, EvolutionState state)
          You must guarantee that after calling constraintsFor(...) one or several times, you call state.output.exitIfErrors() once.
 void GPProblem.describe(Individual ind, EvolutionState state, int subpopulation, int threadnum, int log, int verbosity)
           
protected  void GPNodeBuilder.errorAboutNoNodeWithType(GPType type, EvolutionState state)
          Issues a fatal error that no node (nonterminal or terminal) was found with a return type of the given type, and that an algorithm had requested one.
abstract  void GPNode.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
          Evaluates the node with the given thread, state, individual, problem, and stack.
 void ADM.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void ADF.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void ADFArgument.eval(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem)
           
 void ADFContext.evaluate(EvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, Problem problem, int argument)
          Evaluates the argument number in the current context
static GPFunctionSet GPFunctionSet.functionSetFor(java.lang.String functionSetName, EvolutionState state)
          Returns the function set for a given name.
 void ERC.mutateERC(EvolutionState state, int thread)
          Mutates the node's "value".
 Individual GPSpecies.newIndividual(EvolutionState state, java.io.DataInput dataInput)
           
 Individual GPSpecies.newIndividual(EvolutionState state, int thread)
           
 Individual GPSpecies.newIndividual(EvolutionState state, java.io.LineNumberReader reader)
           
abstract  GPNode GPNodeBuilder.newRootedTree(EvolutionState state, GPType type, int thread, GPNodeParent parent, GPFunctionSet set, int argposition, int requestedSize)
           
 void GPIndividual.parseGenotype(EvolutionState state, java.io.LineNumberReader reader)
           
 GPNode GPNodeSelector.pickNode(EvolutionState s, int subpopulation, int thread, GPIndividual ind, GPTree tree)
          Picks a node at random from tree and returns it.
 int GPNodeBuilder.pickSize(EvolutionState state, int thread)
          Assuming that either minSize and maxSize, or sizeDistribution, is defined, picks a random size from minSize...maxSize inclusive, or randomly from sizeDistribution.
 void GPIndividual.printIndividual(EvolutionState state, int log, int verbosity)
          Overridden for the GPIndividual genotype, writing each tree in turn.
 void GPIndividual.printIndividual(EvolutionState state, java.io.PrintWriter writer)
          Overridden for the GPIndividual genotype, writing each tree in turn.
 void GPIndividual.printIndividualForHumans(EvolutionState state, int log, int verbosity)
          Overridden for the GPIndividual genotype, writing each tree in turn.
 int GPNode.printNode(EvolutionState state, int log, int verbosity)
          Prints out a COMPUTER-readable and Lisp-like atom for the node, which is also suitable for readNode to read, and returns the number of bytes in the string that you sent to the log (use print(), not println()).
 int GPNode.printNode(EvolutionState state, java.io.PrintWriter writer)
          Prints out a COMPUTER-readable and Lisp-like atom for the node, which is also suitable for readNode to read, and returns the number of bytes in the string that you sent to the log (use print(), not println()).
 int GPNode.printNodeForHumans(EvolutionState state, int log, int verbosity)
          Prints out a human-readable and Lisp-like atom for the node, and returns the number of bytes in the string that you sent to the log (use print(), not println()).
 int GPNode.printRootedTree(EvolutionState state, int log, int verbosity, int printbytes)
          Prints out the tree on a single line, with no ending \n, in a fashion that can be read in later by computer.
 int GPNode.printRootedTree(EvolutionState state, java.io.PrintWriter writer, int printbytes)
          Prints out the tree on a single line, with no ending \n, in a fashion that can be read in later by computer.
 int GPNode.printRootedTreeForHumans(EvolutionState state, int log, int verbosity, int tablevel, int printbytes)
          Prints out the tree in a readable Lisp-like multi-line fashion.
 void GPTree.printTree(EvolutionState state, int log, int verbosity)
          Prints out the tree in single-line fashion suitable for reading in later by computer.
 void GPTree.printTree(EvolutionState state, java.io.PrintWriter writer)
          Prints out the tree in single-line fashion suitable for reading in later by computer.
 void GPTree.printTreeForHumans(EvolutionState state, int log, int verbosity)
          Prints out the tree in a readable Lisp-like fashion.
 boolean GPBreedingPipeline.produces(EvolutionState state, Population newpop, int subpopulation, int thread)
          Returns true if s is a GPSpecies.
 void GPIndividual.readGenotype(EvolutionState state, java.io.DataInput dataInput)
          Overridden for the GPIndividual genotype.
 void ERC.readNode(EvolutionState state, java.io.DataInput dataInput)
          To successfully read from a DataOutput, you must override this to read your specific ERC data in.
 void GPNode.readNode(EvolutionState state, java.io.DataInput dataInput)
          Override this to read any additional node-specific information from dataInput besides: the number of arguments, the specific node class, the children, and the parent.
 void ADF.readNode(EvolutionState state, java.io.DataInput dataInput)
           
 void ADFArgument.readNode(EvolutionState state, java.io.DataInput dataInput)
           
static GPNode GPNode.readRootedTree(EvolutionState state, java.io.DataInput dataInput, GPType expectedType, GPFunctionSet set, GPNodeParent parent, int argposition)
           
static GPNode GPNode.readRootedTree(int linenumber, DecodeReturn dret, GPType expectedType, GPFunctionSet set, GPNodeParent parent, int argposition, EvolutionState state)
          Reads the node and its children from the form printed out by printRootedTree.
 void GPTree.readTree(EvolutionState state, java.io.DataInput dataInput)
           
 void GPTree.readTree(EvolutionState state, java.io.LineNumberReader reader)
          Reads in the tree from a form printed by printTree.
abstract  void ERC.resetNode(EvolutionState state, int thread)
          Remember to override this to randomize your ERC after it has been cloned.
 void GPNode.resetNode(EvolutionState state, int thread)
          Starts a node in a new life immediately after it has been cloned.
 void GPFunctionSet.setup(EvolutionState state, Parameter base)
          Must be done after GPType and GPNodeConstraints have been set up
 void GPData.setup(EvolutionState state, Parameter base)
           
 void GPType.setup(EvolutionState state, Parameter base)
           
 void GPInitializer.setup(EvolutionState state, Parameter base)
           
 void ADFContext.setup(EvolutionState state, Parameter base)
           
 void GPNodeConstraints.setup(EvolutionState state, Parameter base)
          This must be called after the GPTypes have been set up.
 void GPNodeBuilder.setup(EvolutionState state, Parameter base)
           
 void GPProblem.setup(EvolutionState state, Parameter base)
           
 void ADFStack.setup(EvolutionState state, Parameter base)
           
 void GPTreeConstraints.setup(EvolutionState state, Parameter base)
          This must be called after the GPTypes and GPFunctionSets have been set up.
 void GPSetType.setup(EvolutionState state, Parameter base)
           
 void GPNode.setup(EvolutionState state, Parameter base)
          Sets up a prototypical GPNode with those features all nodes of that prototype share, and nothing more.
 void GPIndividual.setup(EvolutionState state, Parameter base)
          Sets up a prototypical GPIndividual with those features which it shares with other GPIndividuals in its species, and nothing more.
 void ADF.setup(EvolutionState state, Parameter base)
           
 void GPTree.setup(EvolutionState state, Parameter base)
          Sets up a prototypical GPTree with those features it shares with other GPTrees in its position in its GPIndividual, and nothhing more.
 void ADFArgument.setup(EvolutionState state, Parameter base)
           
 void GPSpecies.setup(EvolutionState state, Parameter base)
           
 void GPInitializer.setupFunctionSets(EvolutionState state, Parameter base)
           
 void GPInitializer.setupNodeConstraints(EvolutionState state, Parameter base)
          Sets up all the GPNodeConstraints, loading them from the parameter file.
 void GPInitializer.setupTreeConstraints(EvolutionState state, Parameter base)
          Sets up all the GPTreeConstraints, loading them from the parameter file.
 void GPInitializer.setupTypes(EvolutionState state, Parameter base)
          Sets up all the types, loading them from the parameter file.
static GPType GPType.typeFor(java.lang.String typeName, EvolutionState state)
          Returns a type for a given name.
protected  boolean GPNodeBuilder.warnAboutNonterminal(boolean test, GPType type, boolean fail, EvolutionState state)
          If the given test is true, issues a warning that no terminal was found with a return type of the given type, and that an algorithm had requested one.
protected  void GPNodeBuilder.warnAboutNonTerminalWithType(GPType type, boolean fail, EvolutionState state)
          Issues a warning that no nonterminal was found with a return type of the given type, and that an algorithm had requested one.
protected  void GPNodeBuilder.warnAboutNoTerminalWithType(GPType type, boolean fail, EvolutionState state)
          Issues a warning that no terminal was found with a return type of the given type, and that an algorithm had requested one.
 void GPIndividual.writeGenotype(EvolutionState state, java.io.DataOutput dataOutput)
          Overridden for the GPIndividual genotype.
 void ERC.writeNode(EvolutionState state, java.io.DataOutput dataOutput)
          To successfully write to a DataOutput, you must override this to write your specific ERC data out.
 void GPNode.writeNode(EvolutionState state, java.io.DataOutput dataOutput)
          Override this to write any additional node-specific information to dataOutput besides: the number of arguments, the specific node class, the children, and the parent.
 void ADF.writeNode(EvolutionState state, java.io.DataOutput dataOutput)
           
 void ADFArgument.writeNode(EvolutionState state, java.io.DataOutput dataOutput)
           
 void GPNode.writeRootedTree(EvolutionState state, GPType expectedType, GPFunctionSet set, java.io.DataOutput dataOutput)
           
 void GPTree.writeTree(EvolutionState state, java.io.DataOutput dataOutput)
           
 

Uses of EvolutionState in ec.gp.breed
 

Methods in ec.gp.breed with parameters of type EvolutionState
 void MutateERCPipeline.mutateERCs(GPNode node, EvolutionState state, int thread)
           
 int RehangPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int MutatePromotePipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int MutateERCPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int InternalCrossoverPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int MutateDemotePipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int MutateSwapPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int MutateOneNodePipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int MutateAllNodesPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 void RehangPipeline.setup(EvolutionState state, Parameter base)
           
 void MutatePromotePipeline.setup(EvolutionState state, Parameter base)
           
 void MutateERCPipeline.setup(EvolutionState state, Parameter base)
           
 void InternalCrossoverPipeline.setup(EvolutionState state, Parameter base)
           
 void MutateDemotePipeline.setup(EvolutionState state, Parameter base)
           
 void MutateSwapPipeline.setup(EvolutionState state, Parameter base)
           
 void MutateOneNodePipeline.setup(EvolutionState state, Parameter base)
           
 void MutateAllNodesPipeline.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.gp.build
 

Methods in ec.gp.build with parameters of type EvolutionState
 java.lang.String RandTree.buildDyckWord(int requestedSize, int[] arities, int[] s, EvolutionState state, int thread)
           
 GPNode PTC2.newRootedTree(EvolutionState state, GPType type, int thread, GPNodeParent parent, GPFunctionSet set, int argposition, int requestedSize)
           
 GPNode PTC1.newRootedTree(EvolutionState state, GPType type, int thread, GPNodeParent parent, GPFunctionSet set, int argposition, int requestedSize)
           
 GPNode RandomBranch.newRootedTree(EvolutionState state, GPType type, int thread, GPNodeParent parent, GPFunctionSet set, int argposition, int requestedSize)
           
 GPNode RandTree.newRootedTree(EvolutionState state, GPType type, int thread, GPNodeParent parent, GPFunctionSet set, int argposition, int requestedSize)
           
 GPNode Uniform.newRootedTree(EvolutionState state, GPType type, int thread, GPNodeParent parent, GPFunctionSet set, int argposition, int requestedSize)
           
 int Uniform.pickSize(EvolutionState state, int thread, int functionset, int type)
           
 void Uniform.preprocess(EvolutionState state, int _maxtreesize)
           
 void PTC2.setup(EvolutionState state, Parameter base)
           
 void PTC1.setup(EvolutionState state, Parameter base)
           
 void RandomBranch.setup(EvolutionState state, Parameter base)
           
 void PTCFunctionSet.setup(EvolutionState state, Parameter base)
           
 void RandTree.setup(EvolutionState state, Parameter base)
           
 void Uniform.setup(EvolutionState state, Parameter base)
           
 void RandTree.setupArities(EvolutionState state, GPFunctionSet set)
           
 

Uses of EvolutionState in ec.gp.koza
 

Methods in ec.gp.koza with parameters of type EvolutionState
protected  void KozaShortStatistics._postEvaluationStatistics(EvolutionState state)
          Prints out the statistics, but does not end with a println -- this lets overriding methods print additional statistics on the same line
 void KozaStatistics.finalStatistics(EvolutionState state, int result)
          Logs the best individual of the run.
protected  GPNode KozaBuilder.fullNode(EvolutionState state, int current, int max, GPType type, int thread, GPNodeParent parent, int argposition, GPFunctionSet set)
          A private recursive method which builds a FULL-style tree for newRootedTree(...)
protected  GPNode KozaBuilder.growNode(EvolutionState state, int current, int max, GPType type, int thread, GPNodeParent parent, int argposition, GPFunctionSet set)
          A private function which recursively returns a GROW tree to newRootedTree(...)
 GPNode HalfBuilder.newRootedTree(EvolutionState state, GPType type, int thread, GPNodeParent parent, GPFunctionSet set, int argposition, int requestedSize)
           
 GPNode GrowBuilder.newRootedTree(EvolutionState state, GPType type, int thread, GPNodeParent parent, GPFunctionSet set, int argposition, int requestedSize)
           
 GPNode FullBuilder.newRootedTree(EvolutionState state, GPType type, int thread, GPNodeParent parent, GPFunctionSet set, int argposition, int requestedSize)
           
 GPNode KozaNodeSelector.pickNode(EvolutionState s, int subpopulation, int thread, GPIndividual ind, GPTree tree)
           
 void KozaShortStatistics.postBreedingStatistics(EvolutionState state)
           
 void KozaStatistics.postBreedingStatistics(EvolutionState state)
           
 void KozaShortStatistics.postEvaluationStatistics(EvolutionState state)
           
 void KozaStatistics.postEvaluationStatistics(EvolutionState state)
           
 void KozaShortStatistics.postInitializationStatistics(EvolutionState state)
           
 void KozaStatistics.postInitializationStatistics(EvolutionState state)
           
 void KozaShortStatistics.preBreedingStatistics(EvolutionState state)
           
 void KozaStatistics.preBreedingStatistics(EvolutionState state)
           
 void KozaShortStatistics.preEvaluationStatistics(EvolutionState state)
           
 void KozaStatistics.preEvaluationStatistics(EvolutionState state)
           
 void KozaShortStatistics.preInitializationStatistics(EvolutionState state)
           
 void KozaStatistics.preInitializationStatistics(EvolutionState state)
           
 int CrossoverPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int MutationPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 void KozaFitness.readFitness(EvolutionState state, java.io.DataInput dataInput)
           
 void KozaFitness.readFitness(EvolutionState state, java.io.LineNumberReader reader)
           
 void KozaFitness.setFitness(EvolutionState state, float _f)
          Deprecated.  
 void KozaFitness.setStandardizedFitness(EvolutionState state, float _f)
          Set the standardized fitness in the half-open interval [0.0,infinity) which is defined (NOTE: DIFFERENT FROM fitness()!!!) as 0.0 being the IDEAL and infinity being worse than the worst possible.
 void CrossoverPipeline.setup(EvolutionState state, Parameter base)
           
 void KozaShortStatistics.setup(EvolutionState state, Parameter base)
           
 void HalfBuilder.setup(EvolutionState state, Parameter base)
           
 void KozaBuilder.setup(EvolutionState state, Parameter base)
           
 void MutationPipeline.setup(EvolutionState state, Parameter base)
           
 void KozaFitness.setup(EvolutionState state, Parameter base)
           
 void KozaStatistics.setup(EvolutionState state, Parameter base)
           
 void KozaNodeSelector.setup(EvolutionState state, Parameter base)
           
 void KozaFitness.writeFitness(EvolutionState state, java.io.DataOutput dataOutput)
           
 

Uses of EvolutionState in ec.multiobjective
 

Methods in ec.multiobjective with parameters of type EvolutionState
 void MultiObjectiveFitness.readFitness(EvolutionState state, java.io.DataInput dataInput)
           
 void MultiObjectiveFitness.readFitness(EvolutionState state, java.io.LineNumberReader reader)
           
 void MultiObjectiveFitness.setup(EvolutionState state, Parameter base)
          Sets up.
 void MultiObjectiveFitness.writeFitness(EvolutionState state, java.io.DataOutput dataOutput)
           
 

Uses of EvolutionState in ec.multiobjective.spea2
 

Methods in ec.multiobjective.spea2 with parameters of type EvolutionState
 void SPEA2Breeder.breedPopChunk(Population newpop, EvolutionState state, int[] numinds, int[] from, int threadnum)
          A private helper function for breedPopulation which breeds a chunk of individuals in a subpopulation for a given thread.
 Population SPEA2Breeder.breedPopulation(EvolutionState state)
          A simple breeder that doesn't attempt to do any cross- population breeding.
 void SPEA2Evaluator.evalPopChunk(EvolutionState state, int[] numinds, int[] from, int threadnum, SimpleProblemForm p)
          A private helper function for evaluatePopulation which evaluates a chunk of individuals in a subpopulation for a given thread.
 void SPEA2Evaluator.evaluatePopulation(EvolutionState state)
          A simple evaluator that doesn't do any coevolutionary evaluation.
 void SPEA2Breeder.loadArchive(EvolutionState state, Population newpop)
          A private helper function for breedPopulation which loads the archive (top end of indivudal array) with the SPEA2 elites.
 void SPEA2Subpopulation.printSubpopulation(EvolutionState state, int log, int verbosity)
          Overridden to include the archive size in the stream.
 void SPEA2Subpopulation.printSubpopulation(EvolutionState state, java.io.PrintWriter writer)
          Overridden to include the archive size in the stream.
 void SPEA2Subpopulation.printSubpopulationForHumans(EvolutionState state, int log, int verbosity)
          Overridden to include the archive size in the stream.
 int SPEA2TournamentSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int SPEA2TournamentSelection.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 void SPEA2MultiObjectiveFitness.readFitness(EvolutionState state, java.io.DataInput dataInput)
           
 void SPEA2MultiObjectiveFitness.readFitness(EvolutionState state, java.io.LineNumberReader reader)
           
 void SPEA2Subpopulation.readSubpopulation(EvolutionState state, java.io.DataInput dataInput)
          Overridden to include the archive size in the stream.
 void SPEA2Subpopulation.readSubpopulation(EvolutionState state, java.io.LineNumberReader reader)
          Overridden to include the archive size in the stream.
 boolean SPEA2Evaluator.runComplete(EvolutionState state)
          The SPEA2Evaluator determines that a run is complete by asking each individual in each population if he or she is optimal; if it finds an individual somewhere that's optimal, it signals that the run is complete.
 void SPEA2Evaluator.setup(EvolutionState state, Parameter base)
           
 void SPEA2Breeder.setup(EvolutionState state, Parameter base)
           
 void SPEA2Subpopulation.setup(EvolutionState state, Parameter base)
          Returns an instance of Subpopulation just like it had been before it was populated with individuals.
 void SPEA2MultiObjectiveFitness.writeFitness(EvolutionState state, java.io.DataOutput dataOutput)
           
 void SPEA2Subpopulation.writeSubpopulation(EvolutionState state, java.io.DataOutput dataOutput)
          Overridden to include the archive size in the stream.
 

Uses of EvolutionState in ec.parsimony
 

Methods in ec.parsimony with parameters of type EvolutionState
 int DoubleTournamentSelection.make(int subpopulation, EvolutionState state, int thread)
          Produces the index of a person selected from among several by a tournament.
 void TarpeianStatistics.preEvaluationStatistics(EvolutionState state)
          Marks a proportion (killProportion) of individuals with above-average size (within their own subpopulation) to a minimum value.
 void BucketTournamentSelection.prepareToProduce(EvolutionState state, int subpopulation, int thread)
          Prepare to produce: create the buckets!!!!
 void RatioBucketTournamentSelection.prepareToProduce(EvolutionState state, int subpopulation, int thread)
          Prepare to produce: create the buckets!!!!
 int LexicographicTournamentSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int DoubleTournamentSelection.produce(int subpopulation, EvolutionState state, int thread)
          Produces the index of a person selected from among several by a tournament.
 int ProportionalTournamentSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int BucketTournamentSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int RatioBucketTournamentSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int ProportionalTournamentSelection.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 void TarpeianStatistics.setMinimumFitness(EvolutionState state, int subpopulation, Individual ind)
          Sets the fitness of an individual to the minimum fitness possible.
 void LexicographicTournamentSelection.setup(EvolutionState state, Parameter base)
           
 void DoubleTournamentSelection.setup(EvolutionState state, Parameter base)
           
 void ProportionalTournamentSelection.setup(EvolutionState state, Parameter base)
           
 void TarpeianStatistics.setup(EvolutionState state, Parameter base)
           
 void BucketTournamentSelection.setup(EvolutionState state, Parameter base)
           
 void RatioBucketTournamentSelection.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.pso
 

Methods in ec.pso with parameters of type EvolutionState
 Population PSOBreeder.breedPopulation(EvolutionState state)
           
 void PSOSubpopulation.populate(EvolutionState state, int thread)
           
 void PSOSubpopulation.printSubpopulation(EvolutionState state, int log, int verbosity)
          Overridden to include the global best, neighborhood bests, personal bests, and previous individuals in the stream.
 void PSOSubpopulation.printSubpopulation(EvolutionState state, java.io.PrintWriter writer)
          Overridden to include the global best, neighborhood bests, personal bests, and previous individuals in the stream.
 void PSOSubpopulation.printSubpopulationForHumans(EvolutionState state, int log, int verbosity)
          Overridden to include the global best, neighborhood bests, personal bests, and previous individuals in the stream.
 void PSOSubpopulation.readSubpopulation(EvolutionState state, java.io.DataInput dataInput)
          Overridden to include the global best, neighborhood bests, personal bests, and previous individuals in the stream.
 void PSOSubpopulation.readSubpopulation(EvolutionState state, java.io.LineNumberReader reader)
          Overridden to include the global best, neighborhood bests, personal bests, and previous individuals in the stream.
 void PSOSubpopulation.setup(EvolutionState state, Parameter base)
           
 void PSOBreeder.setup(EvolutionState state, Parameter base)
           
 void PSOSubpopulation.writeSubpopulation(EvolutionState state, java.io.DataOutput dataOutput)
          Overridden to include the global best, neighborhood bests, personal bests, and previous individuals in the stream.
 

Uses of EvolutionState in ec.rule
 

Methods in ec.rule with parameters of type EvolutionState
 void RuleSet.addRandomRule(EvolutionState state, int thread)
          Add a random rule to the rule set
static RuleSetConstraints RuleSetConstraints.constraintsFor(java.lang.String constraintsName, EvolutionState state)
          You must guarantee that after calling constraintsFor(...) one or several times, you call state.output.exitIfErrors() once.
static RuleConstraints RuleConstraints.constraintsFor(java.lang.String constraintsName, EvolutionState state)
          You must guarantee that after calling constraintsFor(...) one or several times, you call state.output.exitIfErrors() once.
 void Rule.mutate(EvolutionState state, int thread)
          Mutate the rule.
 void RuleSet.mutateRules(EvolutionState state, int thread)
          Mutates rules in the RuleSet independently with the given probability.
 Individual RuleSpecies.newIndividual(EvolutionState state, int thread)
           
 int RuleSetConstraints.numRulesForReset(RuleSet ruleset, EvolutionState state, int thread)
          Returns a stochastic value picked to specify the number of rules to generate when calling reset() on this kind of Rule.
 void RuleIndividual.parseGenotype(EvolutionState state, java.io.LineNumberReader reader)
          Overridden for the RuleIndividual genotype.
 int RuleSetConstraints.pickSize(EvolutionState state, int thread)
          Assuming that either resetMinSize and resetMaxSize, or sizeDistribution, is defined, picks a random size from resetMinSize...resetMaxSize inclusive, or randomly from sizeDistribution.
 void RuleIndividual.postprocessIndividual(EvolutionState state, int thread)
          Called by pipelines after they've modified the individual and it might need to be "fixed" -- basically a hook for you to override.
 void RuleSet.postprocessRules(EvolutionState state, int thread)
          Should be called by pipelines to "fix up" the rulesets after they have been mutated or crossed over.
 void RuleIndividual.preprocessIndividual(EvolutionState state, int thread)
          Called by pipelines before they've modified the individual and it might need to be "fixed" -- basically a hook for you to override.
 void RuleSet.preprocessRules(EvolutionState state, int thread)
          Should be called by pipelines to "fix up" the rulesets before they have been mutated or crossed over.
 void RuleIndividual.printIndividual(EvolutionState state, int log, int verbosity)
          Overridden for the RuleIndividual genotype, writing each ruleset in turn.
 void RuleIndividual.printIndividual(EvolutionState state, java.io.PrintWriter writer)
          Overridden for the RuleIndividual genotype, writing each ruleset in turn.
 void RuleIndividual.printIndividualForHumans(EvolutionState state, int log, int verbosity)
          Overridden for the RuleIndividual genotype, writing each ruleset in turn.
 void Rule.printRule(EvolutionState state, int log, int verbosity)
          Prints the rule in a way that can be read by readRule().
 void Rule.printRule(EvolutionState state, java.io.PrintWriter writer)
          Prints the rule in a way that can be read by readRule().
 void Rule.printRuleForHumans(EvolutionState state, int log, int verbosity)
          Nice printing.
 void RuleSet.printRuleSet(EvolutionState state, int log, int verbosity)
          Prints the rule set such that the computer can read it later
 void RuleSet.printRuleSet(EvolutionState state, java.io.PrintWriter writer)
          Prints the rule set such that the computer can read it later
 void RuleSet.printRuleSetForHumans(EvolutionState state, int log, int verbosity)
          Prints out the rule set in a readable fashion.
 java.lang.String Rule.printRuleToString(EvolutionState state)
          Deprecated.  
 void RuleSet.randomizeRulesOrder(EvolutionState state, int thread)
          Randomizes the order of the rules in the rule set.
 void RuleIndividual.readGenotype(EvolutionState state, java.io.DataInput dataInput)
          Overridden for the RuleIndividual genotype.
 void Rule.readRule(EvolutionState state, java.io.DataInput dataInput)
          Override this if you need to read rules in from a binary stream
 void Rule.readRule(EvolutionState state, java.io.LineNumberReader reader)
          Reads a rule printed by printRule(...).
 void Rule.readRuleFromString(java.lang.String string, EvolutionState state)
          Reads a rule from a string, which may contain a final '\n'.
 void RuleSet.readRuleSet(EvolutionState state, java.io.DataInput dataInput)
          Reads RuleSets in from a binary stream
 void RuleSet.readRuleSet(EvolutionState state, java.io.LineNumberReader reader)
          Reads the rule set
 Rule RuleSet.removeRandomRule(EvolutionState state, int thread)
          Removes a randomly-chosen rule from the rule set and returns it.
 void RuleSet.reset(EvolutionState state, int thread)
          A reset method for randomly reinitializing the RuleSet
 void RuleIndividual.reset(EvolutionState state, int thread)
           
abstract  void Rule.reset(EvolutionState state, int thread)
          The reset method randomly reinitializes the rule.
 void RuleSpecies.setup(EvolutionState state, Parameter base)
           
 void RuleSet.setup(EvolutionState state, Parameter base)
           
 void RuleIndividual.setup(EvolutionState state, Parameter base)
           
 void RuleSetConstraints.setup(EvolutionState state, Parameter base)
           
 void Rule.setup(EvolutionState state, Parameter base)
           
 void RuleConstraints.setup(EvolutionState state, Parameter base)
           
 void RuleInitializer.setup(EvolutionState state, Parameter base)
          Sets up the RuleConstraints and RuleSetConstraints cliques.
 void RuleInitializer.setupConstraints(EvolutionState state, Parameter base)
          Sets up all the RuleConstraints, loading them from the parameter file.
 void RuleInitializer.setupRuleSetConstraints(EvolutionState state, Parameter base)
           
 RuleSet[] RuleSet.split(EvolutionState state, int thread, RuleSet[] sets)
          Splits the rule set into a number of disjoint rule sets, copying the rules and adding them to the sets as appropriate.
 RuleSet[] RuleSet.splitIntoTwo(EvolutionState state, int thread, RuleSet[] sets, float prob)
          Splits the rule set into a two disjoint rule sets, copying the rules and adding them to the sets as appropriate.
 void RuleIndividual.writeGenotype(EvolutionState state, java.io.DataOutput dataOutput)
          Overridden for the RuleIndividual genotype, writing each ruleset in turn.
 void Rule.writeRule(EvolutionState state, java.io.DataOutput dataOutput)
          Override this if you need to write rules out to a binary stream
 void RuleSet.writeRuleSet(EvolutionState state, java.io.DataOutput dataOutput)
          Writes RuleSets out to a binary stream
 

Uses of EvolutionState in ec.rule.breed
 

Methods in ec.rule.breed with parameters of type EvolutionState
 int RuleCrossoverPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int RuleMutationPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 void RuleCrossoverPipeline.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.select
 

Methods in ec.select with parameters of type EvolutionState
 void GreedyOverselection.finishProducing(EvolutionState s, int subpopulation, int thread)
           
 void BestSelection.finishProducing(EvolutionState s, int subpopulation, int thread)
           
 void FitProportionateSelection.finishProducing(EvolutionState s, int subpopulation, int thread)
           
 void GreedyOverselection.prepareToProduce(EvolutionState s, int subpopulation, int thread)
           
 void MultiSelection.prepareToProduce(EvolutionState s, int subpopulation, int thread)
           
 void BestSelection.prepareToProduce(EvolutionState s, int subpopulation, int thread)
           
 void FitProportionateSelection.prepareToProduce(EvolutionState s, int subpopulation, int thread)
           
 int GreedyOverselection.produce(int subpopulation, EvolutionState state, int thread)
           
 int MultiSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int FirstSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int TournamentSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int BestSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int FitProportionateSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int RandomSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int MultiSelection.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int FirstSelection.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int TournamentSelection.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int RandomSelection.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 boolean MultiSelection.produces(EvolutionState state, Population newpop, int subpopulation, int thread)
           
 void GreedyOverselection.setup(EvolutionState state, Parameter base)
           
 void MultiSelection.setup(EvolutionState state, Parameter base)
           
 void TournamentSelection.setup(EvolutionState state, Parameter base)
           
 void BestSelection.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.simple
 

Subclasses of EvolutionState in ec.simple
 class SimpleEvolutionState
          A SimpleEvolutionState is an EvolutionState which implements a simple form of generational evolution.
 

Fields in ec.simple declared as EvolutionState
 EvolutionState SimpleEvaluator.SimpleEvaluatorThread.state
           
 

Methods in ec.simple with parameters of type EvolutionState
protected  void SimpleShortStatistics._postEvaluationStatistics(EvolutionState state)
          Prints out the statistics, but does not end with a println -- this lets overriding methods print additional statistics on the same line
 void SimpleBreeder.breedPopChunk(Population newpop, EvolutionState state, int[] numinds, int[] from, int threadnum)
          A private helper function for breedPopulation which breeds a chunk of individuals in a subpopulation for a given thread.
 Population SimpleBreeder.breedPopulation(EvolutionState state)
          A simple breeder that doesn't attempt to do any cross- population breeding.
 void SimpleExchanger.closeContacts(EvolutionState state, int result)
          Doesn't do anything.
 void SimpleProblemForm.describe(Individual ind, EvolutionState state, int threadnum, int log, int verbosity)
          Deprecated. 
 void SimpleProblemForm.describe(Individual ind, EvolutionState state, int subpopulation, int threadnum, int log, int verbosity)
          "Reevaluates" an individual, for the purpose of printing out interesting facts about the individual in the context of the Problem, and logs the results.
 void SimpleProblemForm.evaluate(EvolutionState state, Individual ind, int threadnum)
          Deprecated. 
 void SimpleProblemForm.evaluate(EvolutionState state, Individual ind, int subpopulation, int threadnum)
          Evaluates the individual in ind, if necessary (perhaps not evaluating them if their evaluated flags are true), and sets their fitness appropriately.
 void SimpleEvaluator.evaluatePopulation(EvolutionState state)
          A simple evaluator that doesn't do any coevolutionary evaluation.
 void SimpleStatistics.finalStatistics(EvolutionState state, int result)
          Logs the best individual of the run.
 void SimpleFinisher.finishPopulation(EvolutionState state, int result)
          Doesn't do anything.
 void SimpleStatistics.generationBoundaryStatistics(EvolutionState state)
          Steady-state only: computes statistics at each generation count
 void SimpleExchanger.initializeContacts(EvolutionState state)
          Doesn't do anything.
 Population SimpleInitializer.initialPopulation(EvolutionState state, int thread)
          Creates, populates, and returns a new population by making a new population, calling setup(...) on it, and calling populate(...) on it, assuming an unthreaded environment (thread 0).
 void SimpleBreeder.loadElites(EvolutionState state, Population newpop)
          A private helper function for breedPopulation which loads elites into a subpopulation.
 Population SimpleExchanger.postBreedingExchangePopulation(EvolutionState state)
          Simply returns state.population.
 void SimpleShortStatistics.postBreedingStatistics(EvolutionState state)
           
 void SimpleShortStatistics.postEvaluationStatistics(EvolutionState state)
           
 void SimpleStatistics.postEvaluationStatistics(EvolutionState state)
          Logs the best individual of the generation.
 void SimpleShortStatistics.postInitializationStatistics(EvolutionState state)
           
 void SimpleStatistics.postInitializationStatistics(EvolutionState state)
           
 Population SimpleExchanger.preBreedingExchangePopulation(EvolutionState state)
          Simply returns state.population.
 void SimpleShortStatistics.preBreedingStatistics(EvolutionState state)
           
 void SimpleShortStatistics.preEvaluationStatistics(EvolutionState state)
           
 void SimpleShortStatistics.preInitializationStatistics(EvolutionState state)
           
 void SimpleFitness.readFitness(EvolutionState state, java.io.DataInput dataInput)
           
 void SimpleFitness.readFitness(EvolutionState state, java.io.LineNumberReader reader)
          Presently does not decode the fact that the fitness is ideal or not
 void SimpleExchanger.reinitializeContacts(EvolutionState state)
          Doesn't do anything.
 java.lang.String SimpleExchanger.runComplete(EvolutionState state)
          Always returns null
 boolean SimpleEvaluator.runComplete(EvolutionState state)
          The SimpleEvaluator determines that a run is complete by asking each individual in each population if he's optimal; if he finds an individual somewhere that's optimal, he signals that the run is complete.
 void SimpleFitness.setFitness(EvolutionState state, float _f)
          Deprecated.  
 void SimpleFitness.setFitness(EvolutionState state, float _f, boolean _isIdeal)
           
 void SimpleInitializer.setup(EvolutionState state, Parameter base)
           
 void SimpleExchanger.setup(EvolutionState state, Parameter base)
           
 void SimpleShortStatistics.setup(EvolutionState state, Parameter base)
           
 void SimpleStatistics.setup(EvolutionState state, Parameter base)
           
 void SimpleBreeder.setup(EvolutionState state, Parameter base)
           
 void SimpleFinisher.setup(EvolutionState state, Parameter base)
           
 void SimpleFitness.setup(EvolutionState state, Parameter base)
           
 void SimpleEvaluator.setup(EvolutionState state, Parameter base)
           
 void SimpleEvolutionState.setup(EvolutionState state, Parameter base)
           
 Population SimpleInitializer.setupPopulation(EvolutionState state, int thread)
           
 void SimpleFitness.writeFitness(EvolutionState state, java.io.DataOutput dataOutput)
           
 

Uses of EvolutionState in ec.spatial
 

Methods in ec.spatial with parameters of type EvolutionState
 Population SpatialBreeder.breedPopulation(EvolutionState state)
           
 void SpatialMultiPopCoevolutionaryEvaluator.evaluatePopulation(EvolutionState state)
           
 int Spatial1DSubpopulation.getIndexRandomNeighbor(EvolutionState state, int threadnum, int distance)
          Returns a the index of a random neighbor.
 int Space.getIndexRandomNeighbor(EvolutionState state, int threadnum, int distance)
          Input: the maximum distance for neighbors.
 void SpatialMultiPopCoevolutionaryEvaluator.performCoevolutionaryEvaluation(EvolutionState state, Population population, GroupedProblemForm prob)
           
 int SpatialTournamentSelection.produce(int subpopulation, EvolutionState state, int thread)
           
 int SpatialTournamentSelection.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 boolean SpatialMultiPopCoevolutionaryEvaluator.runComplete(EvolutionState state)
           
 void Spatial1DSubpopulation.setup(EvolutionState state, Parameter base)
          Read additional parameters for the spatially-embedded subpopulation.
 void SpatialBreeder.setup(EvolutionState state, Parameter base)
           
 void SpatialTournamentSelection.setup(EvolutionState state, Parameter base)
           
 void SpatialMultiPopCoevolutionaryEvaluator.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.steadystate
 

Subclasses of EvolutionState in ec.steadystate
 class SteadyStateEvolutionState
           
 

Methods in ec.steadystate with parameters of type EvolutionState
 Individual SteadyStateBreeder.breedIndividual(EvolutionState state, int subpop, int thread)
           
 void SteadyStateEvaluator.evaluateIndividual(EvolutionState state, Individual ind, int subpop)
          Submits an individual to be evaluated by the Problem, and adds it and its subpopulation to the queue.
 void SteadyStateStatisticsForm.finalStatistics(EvolutionState state, int result)
          Called immediately after the run has completed.
 void SteadyStateBreeder.finishPipelines(EvolutionState state)
           
 void SteadyStateStatisticsForm.generationBoundaryStatistics(EvolutionState state)
          Called when the generation count increments
 QueueIndividual SteadyStateEvaluator.getNextEvaluatedIndividual(EvolutionState state)
          Returns the QueueIndividual from the front of the queue.
 QueueIndividual SteadyStateEvaluator.pollNextEvaluatedIndividual(EvolutionState state, long timeoutInMilliseconds)
          Polls for the next individual.
 void SteadyStateStatisticsForm.preInitializationStatistics(EvolutionState state)
          Called immediately before population initialization occurs.
 void SteadyStateBreeder.prepareToBreed(EvolutionState state, int thread)
           
 void SteadyStateEvaluator.prepareToEvaluate(EvolutionState state, int thread)
           
 void SteadyStateEvolutionState.setup(EvolutionState state, Parameter base)
           
 void SteadyStateEvaluator.setup(EvolutionState state, Parameter base)
           
 void SteadyStateBreeder.setup(EvolutionState state, Parameter base)
           
 

Uses of EvolutionState in ec.util
 

Methods in ec.util that return EvolutionState
static EvolutionState Checkpoint.restoreFromCheckpoint(java.lang.String checkpoint)
          Returns an EvolutionState object read from a checkpoint file whose filename is checkpoint
 

Methods in ec.util with parameters of type EvolutionState
static DecodeReturn Code.checkPreamble(java.lang.String preamble, EvolutionState state, java.io.LineNumberReader reader)
          Finds the next nonblank line, then trims the line and checks the preamble.
static boolean Code.readBooleanWithPreamble(java.lang.String preamble, EvolutionState state, java.io.LineNumberReader reader)
          Finds the next nonblank line, skips past an expected preamble, and reads in a boolean value ("true" or "false") if there is one, and returns it.
static double Code.readDoubleWithPreamble(java.lang.String preamble, EvolutionState state, java.io.LineNumberReader reader)
          Finds the next nonblank line, skips past an expected preamble, and reads in a float if there is one, and returns it.
static float Code.readFloatWithPreamble(java.lang.String preamble, EvolutionState state, java.io.LineNumberReader reader)
          Finds the next nonblank line, skips past an expected preamble, and reads in a float if there is one, and returns it.
static int Code.readIntegerWithPreamble(java.lang.String preamble, EvolutionState state, java.io.LineNumberReader reader)
          Finds the next nonblank line, skips past an expected preamble, and reads in an integer if there is one, and returns it.
static void Checkpoint.setCheckpoint(EvolutionState state)
          Writes the evolution state out to a file.
 

Uses of EvolutionState in ec.vector
 

Methods in ec.vector with parameters of type EvolutionState
 void BitVectorIndividual.defaultCrossover(EvolutionState state, int thread, VectorIndividual ind)
           
 void VectorIndividual.defaultCrossover(EvolutionState state, int thread, VectorIndividual ind)
          Destructively crosses over the individual with another in some default manner.
 void IntegerVectorIndividual.defaultCrossover(EvolutionState state, int thread, VectorIndividual ind)
           
 void ShortVectorIndividual.defaultCrossover(EvolutionState state, int thread, VectorIndividual ind)
           
 void GeneVectorIndividual.defaultCrossover(EvolutionState state, int thread, VectorIndividual ind)
           
 void FloatVectorIndividual.defaultCrossover(EvolutionState state, int thread, VectorIndividual ind)
           
 void LongVectorIndividual.defaultCrossover(EvolutionState state, int thread, VectorIndividual ind)
           
 void DoubleVectorIndividual.defaultCrossover(EvolutionState state, int thread, VectorIndividual ind)
           
 void ByteVectorIndividual.defaultCrossover(EvolutionState state, int thread, VectorIndividual ind)
           
 void BitVectorIndividual.defaultMutate(EvolutionState state, int thread)
          Destructively mutates the individual in some default manner.
 void VectorIndividual.defaultMutate(EvolutionState state, int thread)
          Destructively mutates the individual in some default manner.
 void IntegerVectorIndividual.defaultMutate(EvolutionState state, int thread)
          Destructively mutates the individual in some default manner.
 void ShortVectorIndividual.defaultMutate(EvolutionState state, int thread)
          Destructively mutates the individual in some default manner.
 void GeneVectorIndividual.defaultMutate(EvolutionState state, int thread)
          Destructively mutates the individual in some default manner.
 void FloatVectorIndividual.defaultMutate(EvolutionState state, int thread)
          Destructively mutates the individual in some default manner.
 void LongVectorIndividual.defaultMutate(EvolutionState state, int thread)
          Destructively mutates the individual in some default manner.
 void DoubleVectorIndividual.defaultMutate(EvolutionState state, int thread)
          Destructively mutates the individual in some default manner.
 void ByteVectorIndividual.defaultMutate(EvolutionState state, int thread)
          Destructively mutates the individual in some default manner.
protected  void IntegerVectorSpecies.initializeGenomeSegment(EvolutionState state, Parameter base, Parameter def, int numSegments)
           
 void VectorGene.mutate(EvolutionState state, int thread)
          Mutate the gene.
 Individual VectorSpecies.newIndividual(EvolutionState state, int thread)
           
 void FloatVectorSpecies.outOfRangeRetryLimitReached(EvolutionState state)
           
protected  void BitVectorIndividual.parseGenotype(EvolutionState state, java.io.LineNumberReader reader)
           
protected  void IntegerVectorIndividual.parseGenotype(EvolutionState state, java.io.LineNumberReader reader)
           
protected  void ShortVectorIndividual.parseGenotype(EvolutionState state, java.io.LineNumberReader reader)
           
protected  void GeneVectorIndividual.parseGenotype(EvolutionState state, java.io.LineNumberReader reader)
           
protected  void FloatVectorIndividual.parseGenotype(EvolutionState state, java.io.LineNumberReader reader)
           
protected  void LongVectorIndividual.parseGenotype(EvolutionState state, java.io.LineNumberReader reader)
           
protected  void DoubleVectorIndividual.parseGenotype(EvolutionState state, java.io.LineNumberReader reader)
           
protected  void ByteVectorIndividual.parseGenotype(EvolutionState state, java.io.LineNumberReader reader)
           
 void VectorGene.printGene(EvolutionState state, int verbosity, int log)
          Prints the gene in a way that can be read by readGene().
 void VectorGene.printGene(EvolutionState state, java.io.PrintWriter writer)
          Deprecated. use printGeneToString instead
 void VectorGene.printGeneForHumans(EvolutionState state, int verbosity, int log)
          Nice printing.
 java.lang.String VectorGene.printGeneToString(EvolutionState state)
          Deprecated. use printGeneToString() instead.
 void VectorGene.readGene(EvolutionState state, java.io.DataInput dataInput)
          Override this if you need to read rules in from a binary stream
 void VectorGene.readGene(EvolutionState state, java.io.LineNumberReader reader)
          Reads a gene printed by printGene(...).
 void VectorGene.readGeneFromString(java.lang.String string, EvolutionState state)
          Reads a gene from a string, which may contain a final '\n'.
 void BitVectorIndividual.readGenotype(EvolutionState state, java.io.DataInput dataInput)
           
 void IntegerVectorIndividual.readGenotype(EvolutionState state, java.io.DataInput dataInput)
           
 void ShortVectorIndividual.readGenotype(EvolutionState state, java.io.DataInput dataInput)
           
 void GeneVectorIndividual.readGenotype(EvolutionState state, java.io.DataInput dataInput)
           
 void FloatVectorIndividual.readGenotype(EvolutionState state, java.io.DataInput dataInput)
           
 void LongVectorIndividual.readGenotype(EvolutionState state, java.io.DataInput dataInput)
           
 void DoubleVectorIndividual.readGenotype(EvolutionState state, java.io.DataInput dataInput)
           
 void ByteVectorIndividual.readGenotype(EvolutionState state, java.io.DataInput dataInput)
           
 void BitVectorIndividual.reset(EvolutionState state, int thread)
          Initializes the individual by randomly flipping the bits
abstract  void VectorGene.reset(EvolutionState state, int thread)
          The reset method randomly reinitializes the gene.
abstract  void VectorIndividual.reset(EvolutionState state, int thread)
          Initializes the individual.
 void IntegerVectorIndividual.reset(EvolutionState state, int thread)
          Initializes the individual by randomly choosing Integers uniformly from mingene to maxgene.
 void ShortVectorIndividual.reset(EvolutionState state, int thread)
          Initializes the individual by randomly choosing Shorts uniformly from mingene to maxgene.
 void GeneVectorIndividual.reset(EvolutionState state, int thread)
          Initializes the individual by calling reset(...) on each gene.
 void FloatVectorIndividual.reset(EvolutionState state, int thread)
          Initializes the individual by randomly choosing floats uniformly from mingene to maxgene.
 void LongVectorIndividual.reset(EvolutionState state, int thread)
          Initializes the individual by randomly choosing Longs uniformly from mingene to maxgene.
 void DoubleVectorIndividual.reset(EvolutionState state, int thread)
          Initializes the individual by randomly choosing doubles uniformly from mingene to maxgene.
 void ByteVectorIndividual.reset(EvolutionState state, int thread)
          Initializes the individual by randomly choosing Bytes uniformly from mingene to maxgene.
 void VectorIndividual.reset(EvolutionState state, int thread, int newSize)
          Initializes the individual to a new size.
 void BitVectorIndividual.setup(EvolutionState state, Parameter base)
           
 void VectorGene.setup(EvolutionState state, Parameter base)
           
 void IntegerVectorIndividual.setup(EvolutionState state, Parameter base)
           
 void GeneVectorSpecies.setup(EvolutionState state, Parameter base)
           
 void ShortVectorIndividual.setup(EvolutionState state, Parameter base)
           
 void GeneVectorIndividual.setup(EvolutionState state, Parameter base)
           
 void FloatVectorSpecies.setup(EvolutionState state, Parameter base)
           
 void IntegerVectorSpecies.setup(EvolutionState state, Parameter base)
           
 void VectorSpecies.setup(EvolutionState state, Parameter base)
           
 void FloatVectorIndividual.setup(EvolutionState state, Parameter base)
           
 void LongVectorIndividual.setup(EvolutionState state, Parameter base)
           
 void DoubleVectorIndividual.setup(EvolutionState state, Parameter base)
           
 void ByteVectorIndividual.setup(EvolutionState state, Parameter base)
           
 void VectorGene.writeGene(EvolutionState state, java.io.DataOutput dataOutput)
          Override this if you need to write rules out to a binary stream
 void BitVectorIndividual.writeGenotype(EvolutionState state, java.io.DataOutput dataOutput)
           
 void IntegerVectorIndividual.writeGenotype(EvolutionState state, java.io.DataOutput dataOutput)
           
 void ShortVectorIndividual.writeGenotype(EvolutionState state, java.io.DataOutput dataOutput)
           
 void GeneVectorIndividual.writeGenotype(EvolutionState state, java.io.DataOutput dataOutput)
           
 void FloatVectorIndividual.writeGenotype(EvolutionState state, java.io.DataOutput dataOutput)
           
 void LongVectorIndividual.writeGenotype(EvolutionState state, java.io.DataOutput dataOutput)
           
 void DoubleVectorIndividual.writeGenotype(EvolutionState state, java.io.DataOutput dataOutput)
           
 void ByteVectorIndividual.writeGenotype(EvolutionState state, java.io.DataOutput dataOutput)
           
 

Uses of EvolutionState in ec.vector.breed
 

Methods in ec.vector.breed with parameters of type EvolutionState
 int VectorCrossoverPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 int VectorMutationPipeline.produce(int min, int max, int start, int subpopulation, Individual[] inds, EvolutionState state, int thread)
           
 void VectorCrossoverPipeline.setup(EvolutionState state, Parameter base)