Uses of Class ec.EvolutionState (ORIGIN 1.0.2)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

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&nbs`

Uses of Classec.EvolutionState

Uses of Class
ec.EvolutionState