I'm not exactly positive what you mean here, but if you had ten floats
and ten booleans, and had type constraints in your GP node language,
you could represent them as twenty classes, or (using the trick below)
as two ERC classes, or even crazy things like two ERC classes for 5
floats each etc.
Sean
On Dec 9, 2010, at 8:54 AM, Calle wrote:
> Sean
>
> now I want to join the exchange of emails. I am also a newbie (you
> might remember me from struggling last week...)
>
> For the sake of general understanding I reckon the 'normal' way would
> be to have for each var a class representation, as you might want to
> control gpnodes having respective constraints? I assume it depends on
> the type of vars and the problem itself  if e.g. they are all of the
> same data type it doesn't matter whether to have each single class
> representations or tackle them by specialized ECRs. Otherwise you
> might have solutions like y = "integer greater than a boolean".
>
> Am I correct?
>
> Regards
>
> Calle
>
> On 9 December 2010 14:27, Sean Luke <[log in to unmask]> wrote:
>
>> You could certainly represent your variables as special kinds of
>> ERCs. Here
>> they'd hold the index into the array of current variable values
>> your Problem
>> is dishing out (I called that "vars" below). I slapped together
>> code below
>> but didn't compile it and I'm sure it'll require some
>> modification. But I
>> hope it gives you the general idea.
>>
>> Sean
>>
>>
>>
>> package ec.app.regression.func;
>> import ec.*;
>> import ec.app.regression.*;
>> import ec.gp.*;
>> import ec.util.*;
>> import java.io.*;
>>
>>
>> public class Var extends ERC
>> {
>> public String name() { return "Var"; } // distinguish from other
>> ERCs you
>> might be using
>>
>> int index;
>>
>> public void resetNode(final EvolutionState state, final int
>> thread)
>> {
>> // we'll reset our index to reflect a variable in
>> the problem
>> prototype
>> MyProblem prob = (MyProblem)
>> (state.evaluator.p_problem);
>> nodeIndex =
>> state.random[thread].nextInt(prob.vars.length);
>> }
>>
>> public int nodeHashCode() { return this.getClass().hashCode() +
>> nodeIndex; }
>>
>> public boolean nodeEquals(final GPNode node)
>> {
>> // check first to see if we're the same kind of ERC 
>> // won't work for subclasses; in that case you'll need
>> // to change this to isAssignableTo(...)
>> if (this.getClass() != node.getClass()) return false;
>> // now check to see if the ERCs hold the same value
>> return (((Var)node).index == index);
>> }
>>
>> public void readNode(final EvolutionState state, final DataInput
>> dataInput) throws IOException
>> {
>> index = dataInput.readInt();
>> }
>>
>> public void writeNode(final EvolutionState state, final DataOutput
>> dataOutput) throws IOException
>> {
>> dataOutput.writeInt(index);
>> }
>>
>> public String encode() { return Code.encode(index); }
>>
>> public boolean decode(DecodeReturn dret)
>> {
>> // store the position and the string in case they
>> // get modified by Code.java
>> int pos = dret.pos;
>> String data = dret.data;
>>
>> // decode
>> Code.decode(dret);
>>
>> if (dret.type != DecodeReturn.T_INT) // uh oh!
>> {
>> // restore the position and the string; it was an error
>> dret.data = data;
>> dret.pos = pos;
>> return false;
>> }
>>
>> // store the data
>> infrc = dret.l;
>> return true;
>> }
>>
>> public String toStringForHumans() { return "Var[" + index + "]"; }
>>
>> public void eval(final EvolutionState state,
>> final int thread,
>> final GPData input,
>> final ADFStack stack,
>> final GPIndividual individual,
>> final Problem problem)
>> {
>> MyProblem prob = (MyProblem)(problem);
>> return prob.vars[index];
>> }
>> }
>>
