source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/LoopExpression.cs @ 14744

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {

  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;

  public struct LoopState {
    //public LoopState() { }
    public LoopState(Expression body, long currentIndex, long destinationIndex, long incrementor) {
      this.Body = body;
      this.CurrentIndex = currentIndex;
      this.DestinationIndex = destinationIndex;
      this.Incrementor = incrementor;
    }

    public readonly Expression Body;
    public readonly long CurrentIndex;
    public readonly long DestinationIndex;
    public readonly long Incrementor;

    public override int GetHashCode() {
      var hash = 19;

      if (this.Body != null)
        hash = hash * 31 + this.Body.GetHashCode();

      hash = hash * 31 + this.CurrentIndex.GetHashCode();
      hash = hash * 31 + this.DestinationIndex.GetHashCode();
      hash = hash * 31 + this.Incrementor.GetHashCode();

      return hash;
    }
  }

  public abstract class LoopExpression : StatefulExpression<LoopState> {
    protected LoopExpression() : base(new LoopState()) { }
    protected LoopExpression(LoopState state) : base(state) { }

    protected bool Eval(IPushInterpreter interpreter, IStack<Expression> sourceStack, bool pushCurrentIndex = false) {
      // if not initialized
      if (this.State.Body == null) {
        if (this.HasInsufficientArguments(interpreter, sourceStack)) return false;

        var state = this.InitState(interpreter, sourceStack);
        var initLoopExpression = Clone(state);

        interpreter.ExecStack.Push(initLoopExpression, state.Body);
        return true;
      }

      // if loop end reached
      if (this.State.DestinationIndex == this.State.CurrentIndex) {
        this.PushLastIteration(interpreter);
        return true;
      }

      this.PushIteration(interpreter);

      return true;
    }

    protected virtual void PushIteration(IPushInterpreter interpreter) {
      interpreter.IntegerStack.Push(this.State.CurrentIndex);

      var newState = new LoopState(State.Body, State.CurrentIndex + this.State.Incrementor, State.DestinationIndex, State.Incrementor);
      var nextLoopExpression = Clone(newState);

      interpreter.ExecStack.Push(nextLoopExpression, this.State.Body);
    }

    protected virtual void PushLastIteration(IPushInterpreter interpreter) {
      interpreter.IntegerStack.Push(this.State.CurrentIndex);
      interpreter.ExecStack.Push(this.State.Body);
    }

    protected abstract LoopExpression Clone(LoopState state);
    protected abstract bool HasInsufficientArguments(IPushInterpreter interpreter, IStack<Expression> sourceStack);
    protected abstract LoopState InitState(IPushInterpreter interpreter, IStack<Expression> sourceStack);
  }
}