ec
Class Species

java.lang.Object
  |
  +--ec.Species
Direct Known Subclasses:
GPSpecies

public abstract class Species
extends java.lang.Object
implements Prototype

Species is a prototype which defines the features for a set of individuals in the population. Typically, individuals may breed if they belong to the same species (but it's not a hard-and-fast rule). Each Subpopulation has one Species object which defines the species for individuals in that Subpopulation.

Species are generally responsible for creating individuals, through their newIndividual(...) method. This method usually clones its prototypical individual and makes some additional modifications to the clone, then returns it.

Species also holds a prototypical breeding pipeline meant to breed this individual. To breed individuals of this species, clone the pipeline and use the clone.

Parameters
base.ind
classname, inherits and != ec.Individual
(the class for the prototypical individual for the species)
base.numpipes
int >= 1
(total number of breeding pipelines for the species)
base.pipe
classname, inherits and != ec.BreedingPipeline
(the class for the prototypical Breeding Pipeline)

Parameter bases
base.ind i_prototype (the prototypical individual)
base.pipe pipe_prototype (breeding pipeline prototype)

See Also:
Serialized Form

Field Summary
 Individual i_prototype
          The prototypical individual for this species.
static java.lang.String P_INDIVIDUAL
           
static java.lang.String P_PIPE
           
 BreedingPipeline pipe_prototype
           
 
Constructor Summary
Species()
           
 
Method Summary
abstract  Individual newIndividual(EvolutionState state, Subpopulation _population, Fitness _fitness)
          override this to provide a brand-new individual to fill in a population.
abstract  Individual newIndividual(EvolutionState state, Subpopulation _population, Fitness _fitness, int thread, java.io.LineNumberReader reader)
          override this to provide an individual read from a file; the individual will appear as it was written by printIndividual(...).
 java.lang.Object protoClone()
          Creates a new individual cloned from a prototype, and suitable to begin use in its own evolutionary context.
 java.lang.Object protoCloneSimple()
          This should be implemented in a the top-level Prototype ONLY; in fact, it should probably be declared final.
 void 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.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

P_INDIVIDUAL

public static final java.lang.String P_INDIVIDUAL

P_PIPE

public static final java.lang.String P_PIPE

i_prototype

public Individual i_prototype
The prototypical individual for this species.

pipe_prototype

public BreedingPipeline pipe_prototype
Constructor Detail

Species

public Species()
Method Detail

protoClone

public java.lang.Object protoClone()
                            throws java.lang.CloneNotSupportedException
Description copied from interface: Prototype
Creates a new individual cloned from a prototype, and suitable to begin use in its own evolutionary context.

The question here is whether or not this means to perform a "deep" or "light" ("shallow") clone, or something in-between. You may need to deep-clone parts of your object rather than simply copying their references, depending on the situation:

Implementations.

If you know that your superclasses will never change their protoClone() implementations, you might try inlining them in your overridden protoClone() method. But this is dangerous (though it yields a small net increase).

In general, you want to keep your deep cloning to an absolute minimum, so that you don't have to call protoClone() but one time.

The approach taken here is the fastest that I am aware of while still permitting objects to be specified at runtime from a parameter file. It would be faster to use the "new" operator; but that would require hard-coding that we can't do. Although using java.lang.Object.clone() entails an extra layer that deals with stripping away the "protected" keyword and also wrapping the exception handling (which is a BIG hit, about three times as slow as using "new"), it's still MUCH faster than using java.lang.Class.newInstance(), and also much faster than rolling our own Clone() method.

Specified by:
protoClone in interface Prototype

protoCloneSimple

public final java.lang.Object protoCloneSimple()
Description copied from interface: Prototype
This should be implemented in a the top-level Prototype ONLY; in fact, it should probably be declared final. It should be implemented as follows:

public final Object protoCloneSimple()
{
try { return protoClone(); }
catch (CloneNotSupportedException e) 
{ throw new InternalError(); } // never happens
} 
Specified by:
protoCloneSimple in interface Prototype

newIndividual

public abstract Individual newIndividual(EvolutionState state,
                                         Subpopulation _population,
                                         Fitness _fitness)
                                  throws java.lang.CloneNotSupportedException
override this to provide a brand-new individual to fill in a population. The CloneNotSupportedException permits you to use protoClone() rather than protoCloneSimple(), for efficiency gains.

newIndividual

public abstract Individual newIndividual(EvolutionState state,
                                         Subpopulation _population,
                                         Fitness _fitness,
                                         int thread,
                                         java.io.LineNumberReader reader)
                                  throws java.io.IOException,
                                         java.lang.CloneNotSupportedException
override this to provide an individual read from a file; the individual will appear as it was written by printIndividual(...). You should read and set up the fitness as well. Don't close the file.

setup

public void setup(EvolutionState state,
                  Parameter base)
Description copied from interface: Prototype
Sets up the object by reading it from the parameters stored in state, built off of the parameter base base. If an ancestor implements this method, be sure to call super.setup(state,base); before you do anything else.

For prototypes, setup(...) is typically called once for the prototype instance; cloned instances do not receive the setup(...) call. setup(...) may be called more than once; the only guarantee is that it will get called at least once on an instance or some "parent" object from which it was ultimately cloned.

Specified by:
setup in interface Prototype