source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/Configuration.cs @ 14323

using System.Collections.Generic;
using HeuristicLab.Algorithms.PushGP.Expressions;

namespace HeuristicLab.Algorithms.PushGP.Interpreter
{
    public class Configuration
    {
        public bool IsBooleanStackEnabled { get; set; } = true;
        public bool IsIntegerStackEnabled { get; set; } = true;
        public bool IsFloatStackEnabled { get; set; } = true;
        public bool IsCodeStackEnabled { get; set; } = true;
        public bool IsNameStackEnabled { get; set; } = true;

        public IList<OpCode> AllowedInstructions { get; set; }

        public IList<Expression> PredefinedExpressions { get; set; }

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

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

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

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

        /// <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>
        public uint EvalPushLimit { get; set; } = uint.MaxValue;

        /// <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>
        public uint MaxPointsInProgram { get; set; } = uint.MaxValue;

        /// <summary>
        /// The maximum number of points in an expression produced by the CODE.RAND instruction.
        /// </summary>
        public uint MaxPointsInRandomExpression { get; set; } = uint.MaxValue;

        /// <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>
        public bool TopLevelPushCode { get; set; } = true;

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

        /// <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>
        public double NewErcNameProbability { get; set; } = 0.5;

        public ushort RandomSeedMax { get; set; } = 30081;
        public ushort RandomSeedMin { get; set; } = 0;

        public ushort? RandomSeed { get; set; } = null;
    }
}