source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushGpConfiguration.cs @ 14727

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Configuration {
  using System;
  using System.Collections.Generic;
  using System.Linq;

  using HeuristicLab.Common;
  using HeuristicLab.Core;
  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;

  [StorableClass]
  public class PushGpConfiguration : NamedItem, IReadonlyPushGpConfiguration, IEnabledExpressionsConfiguration {
    private static readonly string itemName = "PushGP Configuration";

    public PushGpConfiguration() {
      this.EvalPushLimit = 4096;
      this.MaxPointsInProgram = 128;
      this.MaxPointsInRandomExpression = 64;

      this.TopLevelPushCode = true;
      this.TopLevelPopCode = false;

      this.MinRandomInteger = -128;
      this.MaxRandomInteger = 128;
      this.MinRandomFloat = -128D;
      this.MaxRandomFloat = 128D;
      this.NewErcNameProbability = 0.5;
      this.ErcProbability = 0.2;

      this.EnabledExpressions = ExpressionTable.ExpressionNames.ToList();
    }

    [StorableConstructor]
    public PushGpConfiguration(bool deserializing) : base(deserializing) { }

    public PushGpConfiguration(PushGpConfiguration origin, Cloner cloner) : base(origin, cloner) {
      this.EnabledExpressions = origin.EnabledExpressions.ToList();

      this.EvalPushLimit = origin.EvalPushLimit;
      this.MaxPointsInProgram = origin.MaxPointsInProgram;
      this.MaxPointsInRandomExpression = origin.MaxPointsInRandomExpression;

      this.TopLevelPushCode = origin.TopLevelPushCode;
      this.TopLevelPopCode = origin.TopLevelPopCode;

      this.MinRandomInteger = origin.MinRandomInteger;
      this.MaxRandomInteger = origin.MaxRandomInteger;
      this.MinRandomFloat = origin.MinRandomFloat;
      this.MaxRandomFloat = origin.MaxRandomFloat;
      this.NewErcNameProbability = origin.NewErcNameProbability;
      this.ErcProbability = origin.ErcProbability;

      this.isBooleanStackEnabled = origin.IsBooleanStackEnabled;
      this.isIntegerStackEnabled = origin.IsIntegerStackEnabled;
      this.isFloatStackEnabled = origin.IsFloatStackEnabled;
      this.isNameStackEnabled = origin.IsNameStackEnabled;
      this.isCodeStackEnabled = origin.IsCodeStackEnabled;
      this.isExecStackEnabled = origin.IsExecStackEnable;
    }

    public event EventHandler<EnabledExpressionsChangedEventArgs> EnabledExpressionsChanged;

    [Storable]
    public IList<string> EnabledExpressions { get; private set; }

    IReadOnlyList<string> IReadonlyPushGpConfiguration.EnabledExpressions { get { return this.EnabledExpressions as IReadOnlyList<string>; } }

    [Storable]
    private bool isBooleanStackEnabled = true;

    public bool IsBooleanStackEnabled
    {
      get
      {
        return this.isBooleanStackEnabled;
      }

      set
      {
        if (this.isBooleanStackEnabled == value) return;

        this.isBooleanStackEnabled = value;

        if (this.isBooleanStackEnabled) EnableExpressionOfStack(StackType.Boolean);
        else DisableExpressionOfStack(StackType.Boolean);
      }
    }

    [Storable]
    private bool isIntegerStackEnabled = true;

    public bool IsIntegerStackEnabled
    {
      get
      {
        return this.isIntegerStackEnabled;
      }

      set
      {
        if (this.isIntegerStackEnabled == value) return;

        this.isIntegerStackEnabled = value;

        if (this.isIntegerStackEnabled) EnableExpressionOfStack(StackType.Integer);
        else DisableExpressionOfStack(StackType.Integer);
      }
    }

    [Storable]
    private bool isFloatStackEnabled = true;

    public bool IsFloatStackEnabled
    {
      get
      {
        return this.isFloatStackEnabled;
      }

      set
      {
        if (this.isFloatStackEnabled == value) return;

        this.isFloatStackEnabled = value;

        if (this.isFloatStackEnabled) EnableExpressionOfStack(StackType.Float);
        else DisableExpressionOfStack(StackType.Float);
      }
    }

    [Storable]
    private bool isCodeStackEnabled = true;

    public bool IsCodeStackEnabled
    {
      get
      {
        return this.isCodeStackEnabled;
      }

      set
      {
        if (this.isCodeStackEnabled == value) return;

        this.isCodeStackEnabled = value;

        if (this.isCodeStackEnabled) EnableExpressionOfStack(StackType.Code);
        else DisableExpressionOfStack(StackType.Code);
      }
    }

    [Storable]
    private bool isExecStackEnabled = true;

    public bool IsExecStackEnable
    {
      get
      {
        return this.isExecStackEnabled;
      }

      set
      {
        if (this.isExecStackEnabled == value) return;

        this.isExecStackEnabled = value;

        if (this.isExecStackEnabled) EnableExpressionOfStack(StackType.Exec);
        else DisableExpressionOfStack(StackType.Exec);
      }
    }

    [Storable]
    private bool isNameStackEnabled = true;

    public bool IsNameStackEnabled
    {
      get
      {
        return this.isNameStackEnabled;
      }

      set
      {
        if (this.isNameStackEnabled == value) return;

        this.isNameStackEnabled = value;

        if (this.isNameStackEnabled) EnableExpressionOfStack(StackType.Name);
        else DisableExpressionOfStack(StackType.Name);
      }
    }

    [Storable]
    public double ErcProbability { get; set; }

    /// <summary>
    ///     This is the maximum allowed number of "executions" in a single top-level call to the interpreter.
    ///     The execution of a single Push instruction counts as one execution, as does the processing of a single literal,
    ///     as does the descent into one layer of parentheses (that is, the processing of the "(" counts as one execution).
    ///     When this limit is exceeded the interpreter aborts immediately, leaving its stacks in the states they were in prior
    ///     to the abort (so they may still be examined by a calling program). Whether or not this counts as an "abnormal"
    ///     termination
    ///     is up to the calling program.
    /// </summary>
    [Storable]
    public int EvalPushLimit { get; set; }

    /// <summary>
    /// This is the maximum of depth a push program can have. Expressions, which lead to exceed this limit are interpreted as NOOP.
    /// </summary>
    [Storable]
    public int MaxDepth { get; set; }

    /// <summary>
    ///     This is the maximum size of an item on the CODE stack, expressed as a number of points.
    ///     A point is an instruction, a literal, or a pair of parentheses. Any instruction that would cause this limit to be
    ///     exceeded
    ///     should instead act as a NOOP, leaving all stacks in the states that they were in before the execution of the
    ///     instruction.
    /// </summary>
    [Storable]
    public int MaxPointsInProgram { get; set; }

    /// <summary>
    ///     The maximum number of points in an expression produced by the CODE.RAND instruction.
    /// </summary>
    [Storable]
    public int MaxPointsInRandomExpression { get; set; }

    /// <summary>
    ///     When TRUE (which is the default), code passed to the top level of the interpreter
    ///     will be pushed onto the CODE stack prior to execution.
    /// </summary>
    [Storable]
    public bool TopLevelPushCode { get; set; }

    /// <summary>
    ///     When TRUE, the CODE stack will be popped at the end of top level calls to the interpreter. The default is FALSE.
    /// </summary>
    [Storable]
    public bool TopLevelPopCode { get; set; }

    /// <summary>
    ///     The minimum INTEGER that will be produced as an ephemeral random INTEGER constant or from a call to INTEGER.RAND.
    /// </summary>
    [Storable]
    public int MinRandomInteger { get; set; }

    /// <summary>
    ///     The maximum INTEGER that will be produced as an ephemeral random INTEGER constant or from a call to INTEGER.RAND.
    /// </summary>
    [Storable]
    public int MaxRandomInteger { get; set; }

    /// <summary>
    ///     The minimum FLOAT that will be produced as an ephemeral random FLOAT constant or from a call to FLOAT.RAND.
    /// </summary>
    [Storable]
    public double MinRandomFloat { get; set; }

    /// <summary>
    ///     The maximum FLOAT that will be produced as an ephemeral random FLOAT constant or from a call to FLOAT.RAND.
    /// </summary>
    [Storable]
    public double MaxRandomFloat { get; set; }

    /// <summary>
    ///     The probability that the selection of the ephemeral
    ///     random NAME constant for inclusion in randomly generated code will produce a new name
    ///     (rather than a name that was previously generated).
    /// </summary>
    [Storable]
    public double NewErcNameProbability { get; set; }

    public void EnableExpressionOfStack(StackType type) {
      foreach (var name in ExpressionTable.StackTypeToNamesTable[type]) {
        EnableExpression(name);
      }
    }

    public void DisableExpressionOfStack(StackType type) {
      foreach (var name in ExpressionTable.StackTypeToNamesTable[type]) {
        DisableExpression(name);
      }
    }

    public void EnableExpression(string name) {
      if (EnabledExpressions.Contains(name)) return;

      EnabledExpressions.Add(name);

      if (EnabledExpressionsChanged != null) {
        EnabledExpressionsChanged.Invoke(this, new EnabledExpressionsChangedEventArgs(
          new[] { name },
          new string[0]));
      }
    }

    public void DisableExpression(string name) {
      if (!EnabledExpressions.Contains(name)) return;

      EnabledExpressions.Remove(name);

      if (EnabledExpressionsChanged != null) {
        EnabledExpressionsChanged.Invoke(this, new EnabledExpressionsChangedEventArgs(
          new string[0],
          new[] { name }));
      }
    }

    public void EnableExpression<T>() where T : Expression {
      var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(typeof(T), typeof(PushExpressionAttribute));
      EnableExpression(attribute.ExpressionName);
    }

    public void DisableExpression<T>() where T : Expression {
      var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(typeof(T), typeof(PushExpressionAttribute));
      DisableExpression(attribute.ExpressionName);
    }

    public void EnableStack(StackType type) {
      SetStack(type, true);
    }

    public void DisableStack(StackType type) {
      SetStack(type, false);
    }

    private void SetStack(StackType type, bool value) {
      switch (type) {
        case StackType.Boolean:
          IsBooleanStackEnabled = value;
          break;
        case StackType.Integer:
          IsIntegerStackEnabled = value;
          break;
        case StackType.Float:
          IsFloatStackEnabled = value;
          break;
        case StackType.Name:
          IsNameStackEnabled = value;
          break;
        case StackType.Code:
          IsCodeStackEnabled = value;
          break;
        default: throw new InvalidOperationException("Stacktype unkown");
      }
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new PushGpConfiguration(this, cloner);
    }
  }
}