Uses of Interface
ec.Prototype

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

Uses of Prototype in com.parabon.ec.simple
 

Classes in com.parabon.ec.simple that implement Prototype
 class SimpleBoundedFitness
          A SimpleBoundedFitness is a SimpleFitness with an arbitrary upper bound.
 

Uses of Prototype in ec
 

Classes in ec that implement Prototype
 class BreedingPipeline
          A BreedingPipeline is a BreedingSource which provides "fresh" individuals which can be used to fill a new population.
 class BreedingSource
          A BreedingSource is a Prototype which provides Individuals to populate new populations based on old ones.
 class Fitness
          Fitness is a prototype which describes the fitness of an individual.
 class Individual
          An Individual is an item in the EC population stew which is evaluated and assigned a fitness which determines its likelihood of selection.
 class Problem
          Problem is a prototype which defines the problem against which we will evaluate individuals in a population.
 class SelectionMethod
          A SelectionMethod is a BreedingSource which provides direct IMMUTABLE pointers to original individuals in an old population, not fresh mutable copies.
 class Species
          Species is a prototype which defines the features for a set of individuals in the population.
 

Uses of Prototype in ec.app.ant
 

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

Uses of Prototype in ec.app.ant.func
 

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

Uses of Prototype in ec.app.coevolve1
 

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

Uses of Prototype in ec.app.coevolve2
 

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

Uses of Prototype in ec.app.ecsuite
 

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

Uses of Prototype in ec.app.edge
 

Classes in ec.app.edge that implement Prototype
 class Edge
          Edge implements the Symbolic Edge problem.
 class EdgeData
           
 

Uses of Prototype in ec.app.edge.func
 

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

Uses of Prototype in ec.app.lawnmower
 

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

Uses of Prototype in ec.app.lawnmower.func
 

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

Uses of Prototype in ec.app.multiplexer
 

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

Uses of Prototype in ec.app.multiplexer.func
 

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

Uses of Prototype in ec.app.parity
 

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

Uses of Prototype in ec.app.parity.func
 

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

Uses of Prototype in ec.app.regression
 

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

Uses of Prototype in ec.app.regression.func
 

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

Uses of Prototype in ec.app.sum
 

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

Uses of Prototype in ec.app.twobox
 

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

Uses of Prototype in ec.app.twobox.func
 

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

Uses of Prototype in ec.breed
 

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

Uses of Prototype in ec.es
 

Classes in ec.es that implement Prototype
 class ESSelection
          ESSelection is a special SelectionMethod designed to be used with evolutionary strategies-type breeders.
 

Uses of Prototype in ec.eval
 

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

Uses of Prototype in ec.gp
 

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

Classes in ec.gp that implement Prototype
 class ADF
          An ADF is a GPNode which implements an "Automatically Defined Function", as described in Koza II.
 class ADFArgument
          An ADFArgument is a GPNode which represents an ADF's argument terminal, its counterpart which returns argument values in its associated function tree.
 class ADFContext
          ADFContext is the object pushed onto an ADF stack which represents the current context of an ADM or ADF function call, that is, how to get the argument values that argument_terminals need to return.
 class ADFStack
          ADFStack is a special data object used to hold ADF data.
 class ADM
          An ADM is an ADF which doesn't evaluate its arguments beforehand, but instead only evaluates them (and possibly repeatedly) when necessary at runtime.
 class ERC
          ERC is an abstract GPNode which implements Ephemeral Random Constants, as described in Koza I.
 class GPBreedingPipeline
          A GPBreedingPipeline is a BreedingPipeline which produces only members of some subclass of GPSpecies.
 class GPData
          GPData is the parent class of data transferred between GPNodes.
 class GPIndividual
          GPIndividual is an Individual used for GP evolution runs.
 class GPNode
          GPNode is a GPNodeParent which is the abstract superclass of all GP function nodes in trees.
 class GPNodeBuilder
          GPNodeBuilder is a Prototype which defines the superclass for objects which create ("grow") GP trees, whether for population initialization, subtree mutation, or whatnot.
 class GPProblem
          A GPProblem is a Problem which is meant to efficiently handle GP evaluation.
 class GPSpecies
          GPSpecies is a simple individual which is suitable as a species for GP subpopulations.
 class GPTree
          GPTree is a GPNodeParent which holds the root GPNode of a tree of GPNodes.
 

Uses of Prototype in ec.gp.breed
 

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

Uses of Prototype in ec.gp.build
 

Classes in ec.gp.build that implement Prototype
 class PTC1
          PTC1 implements the "Strongly-typed Probabilistic Tree Creation 1 (PTC1)" algorithm described in
 class PTC2
          PTC2 implements the "Strongly-typed Probabilistic Tree Creation 2 (PTC2)" algorithm described in
 class RandomBranch
          RandomBranch implements the Random_Branch tree generation method described in
 class RandTree
           
 class Uniform
          Uniform implements the algorithm described in
 

Uses of Prototype in ec.gp.koza
 

Classes in ec.gp.koza that implement Prototype
 class CrossoverPipeline
          CrossoverPipeline is a GPBreedingPipeline which performs a strongly-typed version of Koza-style "Subtree Crossover".
 class FullBuilder
          FullBuilder is a GPNodeBuilder which implements the FULL tree building method described in Koza I/II.
 class GrowBuilder
          GrowBuilder is a GPNodeBuilder which implements the GROW tree building method described in Koza I/II.
 class HalfBuilder
          HalfBuilder is a GPNodeBuilder which implements the RAMPED HALF-AND-HALF tree building method described in Koza I/II.
 class KozaBuilder
           
 class KozaFitness
          KozaFitness is a Fitness which stores an individual's fitness as described in Koza I.
 class KozaNodeSelector
          KozaNodeSelector is a GPNodeSelector which picks nodes in trees a-la Koza I, with the addition of having a probability of always picking the root.
 class MutationPipeline
          MutationPipeline is a GPBreedingPipeline which implements a strongly-typed version of the "Point Mutation" operator as described in Koza I.
 

Uses of Prototype in ec.multiobjective
 

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

Uses of Prototype in ec.multiobjective.spea2
 

Classes in ec.multiobjective.spea2 that implement Prototype
 class SPEA2MultiObjectiveFitness
          SPEA2MultiObjectiveFitness is a subclass of Fitness which implements basic multiobjective fitness functions along with support for the ECJ SPEA2 (Strength Pareto Evolutionary Algorithm) extensions.
 class SPEA2TournamentSelection
          Does a simple tournament selection, limited to the subpopulation it's working in at the time and only within the boundry of the SPEA2 archive (between 0-archiveSize).
 

Uses of Prototype in ec.parsimony
 

Classes in ec.parsimony that implement Prototype
 class BucketTournamentSelection
          Does a tournament selection, limited to the subpopulation it's working in at the time.
 class DoubleTournamentSelection
           
 class LexicographicTournamentSelection
          Does a simple tournament selection, limited to the subpopulation it's working in at the time.
 class ProportionalTournamentSelection
          This selection method adds parsimony pressure to the regular tournament selection.
 class RatioBucketTournamentSelection
          Does a tournament selection, limited to the subpopulation it's working in at the time.
 

Uses of Prototype in ec.rule
 

Classes in ec.rule that implement Prototype
 class Rule
          Rule is an abstract class for describing rules.
 class RuleIndividual
          RuleIndividual is an Individual with an array of RuleSets, each of which is a set of Rules.
 class RuleSet
          RuleSet is a set of Rules, implemented straightforwardly as an arbitrary-length array of Rules.
 class RuleSpecies
          RuleSpecies is a simple individual which is suitable as a species for rule sets subpopulations.
 

Uses of Prototype in ec.rule.breed
 

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

Uses of Prototype in ec.select
 

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

Uses of Prototype in ec.simple
 

Classes in ec.simple that implement Prototype
 class SimpleFitness
          A simple default fitness, consisting of a single floating-point value where fitness A is superior to fitness B if and only if A > B.
 

Uses of Prototype in ec.spatial
 

Classes in ec.spatial that implement Prototype
 class SpatialTournamentSelection
          A slight modification of the tournament selection procedure for use with spatially-embedded EAs.
 

Uses of Prototype in ec.vector
 

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

Uses of Prototype in ec.vector.breed
 

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