source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/PushEvaluator.cs @ 14834

using System;
using System.Collections.Generic;

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem {
  using HeuristicLab.BenchmarkSuite;
  using HeuristicLab.BenchmarkSuite.Problems;
  using HeuristicLab.Core;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;

  public static class PushEvaluator {
    public static double Evaluate(IPushInterpreter interpreter, PushProgram program, Example example, double worstResult) {
      interpreter.BooleanStack.Push(example.InputBoolean);
      interpreter.IntegerStack.Push(example.InputInt);
      interpreter.FloatStack.Push(example.InputFloat);

      interpreter.Run(program);

      var result = GetDiff(example.OutputInt, interpreter.IntegerStack, worstResult, LongDiffer)
                 + GetDiff(example.OutputFloat, interpreter.FloatStack, worstResult, DoubleDiffer)
                 + GetDiff(example.OutputBoolean, interpreter.BooleanStack, worstResult, BooleanDiffer);

      return result;
    }

    public static EvaluationResult Evaluate(PushProgram program, PushInterpreterPool pool, IRandom random, Data data, int startIndex, int endIndex) {
      var length = endIndex - startIndex;
      if (length <= 0) return null;

      var evaluationResult = new EvaluationResult(length);

      using (var interpreter = pool.Create(random)) {
        for (var i = startIndex; i < endIndex; i++) {
          var result = Evaluate(interpreter, program, data.Examples[i], data.WorstResult);
          evaluationResult.ExampleQualities[i - startIndex] = result;
          evaluationResult.TotalQuality += result;
          interpreter.Reset();
        }
      }

      evaluationResult.TotalQuality /= length;

      return evaluationResult;
    }

    //public static EvaluationResult Evaluate(Individual individual, PushInterpreterPool pool, IRandom random, Data data, int startIndex, int endIndex) {
    //  var program = individual.ToPushProgram(pool.PushGpConfiguration);
    //  return Evaluate(program, pool, random, data, startIndex, endIndex);
    //}

    private static double DoubleDiffer(double a, double b) {
      var result = a - b;

      if (result == double.MinValue || double.IsPositiveInfinity(result) || double.IsNaN(result))
        return double.MaxValue;

      if (result == double.MaxValue || double.IsNegativeInfinity(result))
        return double.MinValue;

      return Math.Abs(result);
    }

    private static double LongDiffer(long a, long b) {
      var result = a - b;

      return result == long.MinValue ? long.MaxValue : Math.Abs(result);
    }

    private static double BooleanDiffer(bool a, bool b) {
      return a && b ? 0 : a || b ? 1 : 2;
    }

    private static double GetDiff<T>(IReadOnlyList<T> estimated, IPushStack<T> resultStack, double worstResult, Func<T, T, double> differ)
      where T : IComparable {
      if (estimated.Count == 0) return 0d;

      var diff = 0d;
      var comparableLength = 0;

      if (!resultStack.IsEmpty) {
        var count = Math.Min(estimated.Count, resultStack.Count);
        var result = resultStack.Peek(count);
        comparableLength = Math.Min(estimated.Count, result.Length);

        for (var i = 0; i < comparableLength; i++) {
          diff += Math.Min(differ(estimated[i], result[i]), worstResult);
        }
      }

      for (var i = comparableLength; i < estimated.Count - comparableLength; i++) {
        diff += differ(estimated[i], default(T));
      }

      return diff;
    }
  }
}