ec.gp

Class GPProblem

java.lang.Object

ec.Problem

ec.gp.GPProblem

All Implemented Interfaces:

Prototype, Setup, SimpleProblemForm, java.io.Serializable, java.lang.Cloneable

Direct Known Subclasses:

Ant, Benchmarks, Edge, KLandscapes, Lawnmower, Lid, MajorityGP, Multiplexer, Multiplexer, MultiValuedRegression, OrderTree, Parity, PushProblem, Regression, RoyalTree, Semantic, TwoBox

public abstract class GPProblem
extends Problem
implements SimpleProblemForm

A GPProblem is a Problem which is meant to efficiently handle GP evaluation. GPProblems hold one ADFStack, which is used to evaluate a large number of trees without having to be garbage-collected and reallocated. Be sure to call stack.reset() after each tree evaluation.

Parameters

base.stack classname, inherits or = ec.ADFStack	(the class for the GPProblem's ADF Stack)
base.data classname, inherits and != ec.GPData	(the class for the GPProblem's basic GPData type)

Default Base
gp.problem

Parameter bases

base.stack	(stack)
base.data	(data)

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
GPData	input The GPProblem's GPData
static java.lang.String	P_DATA
static java.lang.String	P_GPPROBLEM
static java.lang.String	P_STACK
ADFStack	stack The GPProblem's stack

Fields inherited from class ec.Problem

P_PROBLEM

Constructor Summary

Constructors

Constructor and Description
GPProblem()

Method Summary

Modifier and Type	Method and Description
java.lang.Object	clone() Creates a new individual cloned from a prototype, and suitable to begin use in its own evolutionary context.
Parameter	defaultBase() GPProblem defines a default base so your subclass doesn't absolutely have to.
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 ec.Problem

canEvaluate, closeContacts, describe, describe, finishEvaluating, initializeContacts, prepareToEvaluate, reinitializeContacts

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface ec.simple.SimpleProblemForm

describe, evaluate

Field Detail

P_GPPROBLEM

public static final java.lang.String P_GPPROBLEM

See Also:

Constant Field Values

P_STACK

public static final java.lang.String P_STACK

See Also:

Constant Field Values

P_DATA

public static final java.lang.String P_DATA

See Also:

Constant Field Values

stack

public ADFStack stack

The GPProblem's stack

input

public GPData input

The GPProblem's GPData

Constructor Detail

GPProblem

public GPProblem()

Method Detail

defaultBase

public Parameter defaultBase()

GPProblem defines a default base so your subclass doesn't absolutely have to.

Specified by:

defaultBase in interface Prototype

Overrides:

defaultBase in class Problem

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

Specified by:

setup in interface Setup

Overrides:

setup in class Problem

clone

public java.lang.Object clone()

Description copied from interface: Prototype

Creates a new individual cloned from a prototype, and suitable to begin use in its own evolutionary context.

Typically this should be a full "deep" clone. However, you may share certain elements with other objects rather than clone hem, depending on the situation:

• If you hold objects which are shared with other instances, don't clone them.
• If you hold objects which must be unique, clone them.
• If you hold objects which were given to you as a gesture of kindness, and aren't owned by you, you probably shouldn't clone them.
• DON'T attempt to clone: Singletons, Cliques, or Groups.
• Arrays are not cloned automatically; you may need to clone an array if you're not sharing it with other instances. Arrays have the nice feature of being copyable by calling clone() on them.

Implementations.

• If no ancestor of yours implements clone(), and you have no need to do clone deeply, and you are abstract, then you should not declare clone().
• If no ancestor of yours implements clone(), and you have no need to do clone deeply, and you are not abstract, then you should implement it as follows:

   public Object clone() 
       {
       try
           { 
           return super.clone();
           }
       catch ((CloneNotSupportedException e)
           { throw new InternalError(); } // never happens
       }
          

• If no ancestor of yours implements clone(), but you need to deep-clone some things, then you should implement it as follows:

   public Object clone() 
       {
       try
           { 
           MyObject myobj = (MyObject) (super.clone());
  
           // put your deep-cloning code here...
           }
       catch ((CloneNotSupportedException e)
           { throw new InternalError(); } // never happens
       return myobj;
       } 
          

• If an ancestor has implemented clone(), and you also need to deep clone some things, then you should implement it as follows:

   public Object clone() 
       { 
       MyObject myobj = (MyObject) (super.clone());
  
       // put your deep-cloning code here...
  
       return myobj;
       } 
          

Specified by:

clone in interface Prototype

Overrides:

clone in class Problem