source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Simplifier/RandomSimplifier.cs @ 14513

namespace HeuristicLab.Algorithms.PushGP.Simplifier {
  using System;
  using System.Threading;
  using HeuristicLab.Algorithms.PushGP.Data.Random;
  using HeuristicLab.Algorithms.PushGP.Expressions;
  using HeuristicLab.Core;

  public class RandomSimplifier : ISimplifier {
    private static readonly ThreadLocal<IRandom> random = RandomFactory.GetRandom();

    public int Trys { get; set; }

    public ExecExpandExpression Simplify(ExecExpandExpression program, Predicate<ExecExpandExpression> isBetter) {

      if (program.TotalCount == 1) {
        return isBetter(ExecExpandExpression.Empty) ? ExecExpandExpression.Empty : program;
      }

      var copy = program.Copy();
      var maxTrys = Math.Min(Trys, program.TotalCount - 2);
      var sucessfullRemoves = 0;

      for (var i = 0; i < maxTrys; i++) {
        var rndIndex = random.Value.Next(1, program.TotalCount - 1 - sucessfullRemoves);
        var node = copy.GetFromTree(
          rndIndex,
          (super, parent, child, childIndex, parentIndex) => new {
            Super = super,
            Parent = parent,
            ChildIndex = childIndex,
            ParentIndex = parentIndex
          });

        var oldParentExpressions = node.Parent.Expressions as Expression[];
        var newParentExpressions = RemoveAt(oldParentExpressions, node.ChildIndex);
        var newParent = new ExecExpandExpression(newParentExpressions);

        var superExpressions = (node.Super == null ? copy.Expressions : node.Super.Expressions) as Expression[];
        superExpressions[node.ParentIndex] = newParent;

        if (isBetter(copy)) {
          sucessfullRemoves++;
        } else {
          superExpressions[node.ParentIndex] = node.Parent;
        }
      }

      return copy;
    }

    private static T[] RemoveAt<T>(T[] source, int index) {
      var dest = new T[source.Length - 1];
      if (index > 0)
        Array.Copy(source, 0, dest, 0, index);

      if (index < source.Length - 1)
        Array.Copy(source, index + 1, dest, index, source.Length - index - 1);

      return dest;
    }
  }
}