source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs @ 15032

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Configuration {
  using System.Collections.Generic;
  using Base.Erc;
  using Common;
  using Persistence.Default.CompositeSerializers.Storable;

  [StorableClass]
  public class PushConfiguration : PushConfigurationBase, IReadOnlyPushConfiguration {
    public PushConfiguration() {
      Name = "Push Configuration";

      ErcOptions = new ErcOptions();
      EvalPushLimit = 1024;
      MinPointsInProgram = 25;
      MaxPointsInProgram = 200;
      TopLevelPushCode = true;
      TopLevelPopCode = false;
      MaxPointsInRandomExpression = 64;
      MaxStringLength = 1000;
      MaxVectorLength = 500;
      MaxDepth = 100;
      FloatStringFormat = "R";
      MaxParenthesesClose = 4;
      ParenthesesCloseBiasLevel = 1;
    }


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

    public PushConfiguration(PushConfiguration origin, Cloner cloner) : base(origin, cloner) {

      ErcOptions = cloner.Clone(origin.ErcOptions);
      EvalPushLimit = origin.EvalPushLimit;
      MinPointsInProgram = origin.MinPointsInProgram;
      MaxPointsInProgram = origin.MaxPointsInProgram;
      MaxPointsInRandomExpression = origin.MaxPointsInRandomExpression;
      TopLevelPushCode = origin.TopLevelPushCode;
      TopLevelPopCode = origin.TopLevelPopCode;
      MaxStringLength = origin.MaxStringLength;
      MaxVectorLength = origin.MaxVectorLength;
      MaxDepth = origin.MaxDepth;
      FloatStringFormat = origin.FloatStringFormat;
      MaxParenthesesClose = origin.MaxParenthesesClose;
      ParenthesesCloseBiasLevel = origin.ParenthesesCloseBiasLevel;
    }

    [Storable]
    public string FloatStringFormat { get; set; }


    IReadOnlyList<string> IReadOnlyPushConfiguration.EnabledExpressions { get { return enabledExpressions; } }

    [Storable]
    public int MaxParenthesesClose { get; set; }
    [Storable]
    public double ParenthesesCloseBiasLevel { get; set; }


    [Storable]
    public ErcOptions ErcOptions { get; set; }

    IReadOnlyErcOptions IReadOnlyPushConfiguration.ErcOptions { get { return ErcOptions; } }

    /// <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 minimum 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 MinPointsInProgram { 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; }

    [Storable]
    public int MaxStringLength { get; set; }

    [Storable]
    public int MaxVectorLength { get; set; }

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