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];
>        }
>    }
>