source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/CodeGeneratorUtils.cs @ 15189

using System.Collections.Generic;
using System.Linq;

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator {
  using Core;
  using Expressions;

  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc;

  using Stack;

  internal static class CodeGeneratorUtils {
    internal static Expression CreateExpressionOrErc(
      IRandom random,
      IReadOnlyList<string> enabledExpressions,
      IReadOnlyErcOptions ercOptions,
      IDictionary<string, Expression> customExpressions = null) {
      var customCount = customExpressions == null ? 0 : customExpressions.Count;
      var index = random.Next(enabledExpressions.Count + customCount);

      return index >= enabledExpressions.Count
        ? customExpressions.Values.ElementAt(index - enabledExpressions.Count)
        : CreateExpressionOrErc(index, random, enabledExpressions, ercOptions);
    }

    internal static Expression CreateExpressionOrErc(
      int index,
      IRandom random,
      IReadOnlyList<string> enabledExpressions,
      IReadOnlyErcOptions ercOptions) {
      var name = enabledExpressions[index];

      return CreateExpressionOrErc(name, random, ercOptions);
    }

    private static Expression CreateExpressionOrErc(
      string expressionName,
      IRandom random,
      IReadOnlyErcOptions ercOptions) {
      //var x = random.NextDouble();
      //Expression expression = null;

      //if (x < ercOptions.ErcProbability) {
      //  var expressionType = ExpressionTable.NameToTypeTable[expressionName];
      //  expression = CreateRandomErcExpression(
      //      ExpressionTable.TypeToAttributeTable[expressionType].StackType,
      //      random,
      //      ercOptions);
      //}

      //if (expression == null || expression is ExecNoopExpression) {
      //  expression = ExpressionTable.GetExpression(expressionName);
      //}

      //return expression;

      var expression = ExpressionTable.GetExpression(expressionName);

      return expression;
    }

    private static readonly Expression Noop = ExpressionTable.GetStatelessExpression<ExecNoopExpression>();
    /// <summary>
    /// Create a ErcExpression whereby the type of the expression conforms to the passed stack type.
    /// </summary>
    /// <param name="type"></param>
    /// <param name="random"></param>
    /// <param name="pushConfiguration"></param>
    /// <returns>ErcExpression or Noop if the required ErcOptionConstants is not configured or enabled in the passed config.</returns>
    internal static Expression CreateRandomErcExpression(StackTypes type, IRandom random, IReadOnlyErcOptions ercOptions) {
      switch (type) {
        case StackTypes.Integer:
          return ercOptions.IntegerErcOptions == null || !ercOptions.IntegerErcOptions.IsEnabled
             ? Noop
             : new IntegerPushExpression(ercOptions.IntegerErcOptions.GetErcValue(random));

        case StackTypes.Float:
          return ercOptions.FloatErcOptions == null || !ercOptions.FloatErcOptions.IsEnabled
            ? Noop
            : new FloatPushExpression(ercOptions.FloatErcOptions.GetErcValue(random));

        case StackTypes.Boolean:
          return ercOptions.BooleanErcOptions == null || !ercOptions.BooleanErcOptions.IsEnabled
            ? Noop
            : new BooleanPushExpression(ercOptions.BooleanErcOptions.GetErcValue(random));

        case StackTypes.Name:
          return ercOptions.NameErcOptions == null || !ercOptions.NameErcOptions.IsEnabled
            ? Noop
            : new NamePushExpression(ercOptions.NameErcOptions.GetErcValue(random));

        case StackTypes.String:
          return ercOptions.StringErcOptions == null || !ercOptions.StringErcOptions.IsEnabled
            ? Noop
            : new StringPushExpression(ercOptions.StringErcOptions.GetErcValue(random));

        case StackTypes.Char:
          return ercOptions.CharErcOptions == null || !ercOptions.CharErcOptions.IsEnabled
            ? Noop
            : new CharPushExpression(ercOptions.CharErcOptions.GetErcValue(random));

        case StackTypes.IntegerVector:
          return ercOptions.IntegerVectorErcOptions == null || !ercOptions.IntegerVectorErcOptions.IsEnabled
            ? Noop
            : new IntegerVectorPushExpression(ercOptions.IntegerVectorErcOptions.GetErcValue(random).Select(i => (long)i).ToList());

        case StackTypes.FloatVector:
          return ercOptions.FloatVectorErcOptions == null || !ercOptions.FloatVectorErcOptions.IsEnabled
            ? Noop
            : new FloatVectorPushExpression(ercOptions.FloatVectorErcOptions.GetErcValue(random));

        case StackTypes.StringVector:
          return ercOptions.StringVectorErcOptions == null || !ercOptions.StringVectorErcOptions.IsEnabled
            ? Noop
            : new StringVectorPushExpression(ercOptions.StringVectorErcOptions.GetErcValue(random));

        default:
          return Noop;
      }
    }
  }
}