Documentation of 'ec.app.lawnmower.Lawnmower' Java class
Lawnmower
Skip navigation links
ec.app.lawnmower

Class Lawnmower

  • All Implemented Interfaces:
    Prototype, Setup, SimpleProblemForm, java.io.Serializable, java.lang.Cloneable

    public class Lawnmower
extends GPProblem
implements SimpleProblemForm
    Lawnmower implements the Koza-II Lawnmower problem.

    Parameters

    base.data
    classname, inherits or == ec.app.lawnmower.LawnmowerData    		 (the class for the prototypical GPData object for the Lawnmower problem)
    base.file
    String    		 (filename of the .trl file for the Lawnmower problem)
    base.turns
    int >= 1    		 (maximal number of moves the lawnmower may make)

    Parameter bases

    base.data species (the GPData object)
    See Also:
    Serialized Form

    • Constructor Detail

      • Lawnmower

        public Lawnmower()

    • Method Detail

      • 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 GPProblem

      • 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 GPProblem

      • evaluate

        public void evaluate(EvolutionState state,
                     Individual ind,
                     int subpopulation,
                     int threadnum)
        Description copied from interface: SimpleProblemForm
        Evaluates the individual in ind, if necessary (perhaps not evaluating them if their evaluated flags are true), and sets their fitness appropriately.
        Specified by:
        evaluate in interface SimpleProblemForm

      • describe

        public void describe(EvolutionState state,
                     Individual ind,
                     int subpopulation,
                     int threadnum,
                     int log)
        Description copied from class: Problem
        Part of SimpleProblemForm. Included here so you don't have to write the default version, which usually does nothing.
        Specified by:
        describe in interface SimpleProblemForm
        Overrides:
        describe in class Problem
Skip navigation links

DMelt 3.0 © DataMelt by jWork.ORG

You see the box below because you did not login.