Seems that I can't go without help, these days. I'm trying to make a GP
symbolic regression problem, this is the equation:
y(n) = 2x(n)  0.5y(n1) + 0.4y(n2) + 3x(n1)2
The data comes from a communication channel, being a double for each
time step, that is represented by the x array, so x(n) is the current
value in the channel, and x(n1) is the value in the channel 1ms ago.
Similarly, y represents the output of the function, so y(n1) is the
value the gp tree gave 1 timestep ago and y(n2) the output 2 timesteps ago.
Seems not very difficult, I implemented two arrays in the Problem class,
one which hold the input, and another one that hold the output, so when
evaluating the nodes would access to them. I attach at the end the code.
The problem is that I keep having problems, the tree gets evaluated to
Infinite, or to NaN, without apparent reason. In fact I check the values
that every node keeps, and they are always right, but at the end I
receive some strange value.
Has anybody made this before? there is anything that I'm missing? How
should I code it?
Alberto
P.D: Code explanation: Only 3 node types, Add, X and Y, all of them
extend GPNode, they only implement toString(), checkConstraints(...) and
eval(...). If I take out Y and run the experiment with X and Add no
errors are produced, but I've been unable to find the error in Y. I
suppose that is some pointer thing I don't see.

public class NodeData extends GPData{
public static final long serialVersionUID = 789456151;
public double value;
public GPData copyTo(final GPData gpData){
((NodeData)gpData).value = value;
return pGPData;
}
}

(In TestProblem.java)
public void evaluate(final EvolutionState state,
final Individual individual,
final int threadNum){
if (individual.evaluated) return;
y = 0d; // Defined as static Double
x = 0d; // Idem
float error = 0;
for(int i = 0; i < inputSamples.length; i++){
x = inputSamples[i];
((GPIndividual)individual).trees[0].child.eval(state,
threadNum, input, stack, (GPIndividual)individual, this);
if(Double.POSITIVE_INFINITY ==
error)state.output.fatal("Infinite at input.value\n"); // This is
the one which fails
if(Double.isNaN(Math.abs(error)))state.output.fatal("NaN!!!");
y = input.value;
error += Math.abs(goalSamples[i]  input.value);
}
((SimpleFitness)individual.fitness).setFitness(state,
1/(1+error), false);
individual.evaluated = true;
}

(In Add.java)
public void eval(final EvolutionState state,
final int thread,
final GPData input,
final ADFStack stack,
final GPIndividual individual,
final Problem problem){
double tmp;
children[0].eval(state, thread, input, stack, individual, problem);
tmp = ((NodeData)input).value;
children[1].eval(state, thread, input, stack, individual, problem);
((NodeData)input).value += tmp;
if(Double.isNaN(((NodeData)input).value))state.output.fatal("NaN
at input.value\n" + toStringForHumans());
if(Double.POSITIVE_INFINITY ==
((NodeData)input).value)state.output.fatal("Infinite at input.value\n" +
toStringForHumans()); // Never fails
}

(In X.java)
public void eval(final EvolutionState state,
final int thread,
final GPData input,
final ADFStack stack,
final GPIndividual individual,
final Problem problem){
((NodeData)input).value = ((GPTestProblem)problem).x;
if(Double.isNaN(((NodeData)input).value))state.output.fatal("NaN
at input.value\n" + toStringForHumans());
if(Double.POSITIVE_INFINITY ==
((NodeData)input).value)state.output.fatal("Infinite at input.value\n" +
toStringForHumans()); // Never fails
}

(In Y.java)
public void eval(final EvolutionState state,
final int thread,
final GPData input,
final ADFStack stack,
final GPIndividual individual,
final Problem problem){
((NodeData)input).value = ((GPTestProblem)problem).y;
if(Double.isNaN(((NodeData)input).value))state.output.fatal("NaN
at input.value\n" + toStringForHumans());
if(Double.POSITIVE_INFINITY ==
((NodeData)input).value)state.output.fatal("Infinite at input.value\n" +
toStringForHumans()); // Never fails
}
