source: addons/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Generators/CodeGenerator/CodeGeneratorUtils.cs @ 16958

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 HeuristicLab.Problems.ProgramSynthesis.Base.Extensions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
  using HeuristicLab.Problems.ProgramSynthesis.Push.SolutionCreator;

  using Stack;

  internal static class CodeGeneratorUtils {
    private static readonly Expression Noop = ExpressionTable.GetStatelessExpression<ExecNoopExpression>();

    internal static Expression MapToExpression(
      IRandom random,
      IReadOnlyErcOptions ercOptions,
      IReadOnlyExpressionsConfiguration config,
      IDictionary<string, Expression> customExpressions = null) {
      var customCount = customExpressions == null ? 0 : customExpressions.Count;
      var enabledExpressionCount = config.EnabledExpressions.Count;
      var index = random.Next(enabledExpressionCount + customCount);

      return index >= config.EnabledExpressions.Count
        ? customExpressions.Values.ElementAt(index - enabledExpressionCount)
        : MapToExpression(index, random, ercOptions, config);
    }

    internal static Expression MapToExpression(
      int index,
      IReadOnlyExpressionsConfiguration config) {

      switch (index) {
        case PushSolutionEncoding.Noop:
          return Noop;
      }

      var name = config.EnabledExpressions[index];
      return ExpressionTable.GetExpression(name);
    }

    internal static Expression MapToExpression(
      int index,
      IRandom random,
      IReadOnlyErcOptions ercOptions,
      IReadOnlyExpressionsConfiguration config) {

      switch (index) {
        case PushSolutionEncoding.Noop:
          return Noop;

        case PushSolutionEncoding.Erc:
          var stackType = config.ExpressionsPerStackCount.RandomWeightedOrDefault(random, pair => pair.Value).Key;

          if (stackType == default(StackTypes))
            break;

          return CreateRandomErcExpression(stackType, random, ercOptions);

        case PushSolutionEncoding.In:
          if (config.InExpressionCount == 0) break;

          var nr = random.Next(0, config.InExpressionCount) + 1;
          return ExpressionTable.InExpressionTable[nr];
      }

      var name = config.EnabledExpressions[index];
      return ExpressionTable.GetExpression(name);
    }

    public static Expression GetRandomExpression(IRandom random, IReadOnlyErcOptions ercOptions, IReadOnlyExpressionsConfiguration instructions, double inInstructionProbability) {
      var x = random.NextDouble();
      var inInstructionRelativeProbability = ercOptions.ErcProbability + inInstructionProbability;

      Expression expression;

      if (ercOptions.ErcProbability > 0 && x <= ercOptions.ErcProbability) {
        var stackType = instructions.ExpressionsPerStackCount.RandomWeightedOrDefault(random, pair => pair.Value).Key;

        expression = stackType == default(StackTypes)
          ? GetRandomExpression(random, instructions)
          : CreateRandomErcExpression(stackType, random, ercOptions);
      } else if (
        inInstructionProbability > 0 &&
        x <= inInstructionRelativeProbability &&
        instructions.InExpressionCount > 0) {

        var index = random.Next(0, instructions.InExpressionCount);
        expression = ExpressionTable.InExpressionTable[index];
      } else {
        expression = GetRandomExpression(random, instructions);
      }

      return expression;
    }

    private static Expression GetRandomExpression(
      IRandom random,
      IReadOnlyExpressionsConfiguration instructionsConfig) {
      var index = random.Next(0, instructionsConfig.EnabledExpressions.Count);
      var expressionName = instructionsConfig.EnabledExpressions[index];
      var expression = ExpressionTable.GetExpression(expressionName);

      return expression;
    }

    //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;
    //}

    /// <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;
      }
    }
  }
}