source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Expressions/ExecExpressions.cs @ 14392

using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Algorithms.PushGP.Interpreter;
using HeuristicLab.Common;

namespace HeuristicLab.Algorithms.PushGP.Expressions
{
    public class ExecExpandExpression : Expression
    {
        private const string prefix = "( ";
        private const string postfix = ")";
        private const string delimiter = " ";

        public readonly Expression[] Expressions;
        private List<Expression> treeIndex;

        public static readonly Expression Empty = new ExecExpandExpression(new Expression[0]);

        public ExecExpandExpression(Expression[] expressions) : base()
        {
            this.Expressions = expressions;
        }

        // copy constructor
        public ExecExpandExpression(ExecExpandExpression expression, Cloner cloner) : base(expression, cloner)
        {
            this.Expressions = expression.Expressions;
            this.treeIndex = expression.treeIndex;
        }

        /// <summary>
        /// Use this method to ensure the amount of expressions is not higher than the limit configured (Configuration.MaxPointsInProgram)
        /// </summary>
        /// <param name="expressions"></param>
        /// <param name="config"></param>
        /// <returns>Returns an ExpandExpression if maxPoints smaller or equal to Configuration.MaxProgramPoints and Noop otherwise</returns>
        public static Expression TryCreate(Expression[] expressions, Configuration config)
        {
            if (config.MaxPointsInProgram > expressions.Length)
            {
                return new ExecExpandExpression(expressions);
            }
            else
            {
                return new CodeNoopExpression();
            }
        }

        private string GetStringRepresentation()
        {
            if (this.StringRepresentation == null)
            {
                var sb = new StringBuilder();

                sb.Append(prefix);

                for (var i = this.Expressions.Length - 1; i >= 0; i--)
                {
                    sb.Append(this.Expressions[i].ToString() + delimiter);
                }

                sb.Append(postfix);

                this.StringRepresentation = sb.ToString();
            }

            return this.StringRepresentation;
        }

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

        public override bool Equals(object obj)
        {
            if (obj == null || obj.GetType() != typeof(ExecExpandExpression))
            {
                return false;
            }

            if (ReferenceEquals(this, obj))
            {
                return true;
            }

            var other = obj as ExecExpandExpression;

            return this.Expressions.SequenceEqual(other.Expressions);
        }

        public override string ToString()
        {
            return this.GetStringRepresentation();
        }

        public override void Eval(IInterpreter interpreter)
        {
            interpreter.ExecStack.Push(this.Expressions);
        }

        /// <summary>
        /// Returns the amount of elements in the whole tree
        /// </summary>
        /// <returns></returns>
        public int TotalCount
        {
            get
            {
                this.BuildIndexIfNecessary();

                return this.treeIndex.Count;
            }
        }

        /// <summary>
        /// Returns the element with the given index whereby the tree is indexed in depth first manner
        /// </summary>
        /// <param name="index">The index of the required element</param>
        /// <returns>The required element</returns>
        public Expression GetFromTree(int index)
        {
            this.BuildIndexIfNecessary();

            return this.treeIndex[index];
        }

        private void BuildIndexIfNecessary()
        {
            if (this.treeIndex != null)
                return;

            this.treeIndex = new List<Expression>(this.Expressions.Length) { this };

            for (var i = this.Expressions.Length - 1; i >= 0; i--)
            {
                var subExpression = this.Expressions[i];

                if (subExpression.GetType() == typeof(ExecExpandExpression))
                {
                    var list = subExpression as ExecExpandExpression;

                    list.BuildIndexIfNecessary();
                    this.treeIndex.AddRange(list.treeIndex);
                }
                else
                {
                    this.treeIndex.Add(subExpression);
                }

            }
        }
    }

    /// <summary>
    /// If the top item of the BOOLEAN stack is TRUE then this removes the second item on the EXEC stack, leaving the first item to be
    /// executed. If it is false then it removes the first item, leaving the second to be executed. This is similar to CODE.IF except
    /// that it operates on the EXEC stack. This acts as a NOOP unless there are at least two items on the EXEC stack and one item on
    /// the BOOLEAN stack.
    /// </summary>
    public class ExecIfExpression : Expression
    {
        public ExecIfExpression() : base("EXEC.IF") { }

        public override void Eval(IInterpreter interpreter)
        {
            // not enough arguments on stack
            if (interpreter.BooleanStack.Count == 0 ||
                interpreter.ExecStack.Count < 2)
                return;

            var condition = interpreter.BooleanStack.Pop();

            if (condition)
                interpreter.ExecStack.RemoveAt(interpreter.ExecStack.Count - 2);
            else
                interpreter.ExecStack.RemoveTop();
        }
    }

    /// <summary>
    /// The Push implementation of the "Y combinator". Inserts beneath the top item of the EXEC stack a new item of the form
    /// "( EXEC.Y <TopItem> )".
    /// </summary>
    public class ExecYExpression : Expression
    {
        public ExecYExpression() : base("EXEC.Y")
        {
        }

        public override void Eval(IInterpreter interpreter)
        {
            // not enough arguments on stack
            if (interpreter.ExecStack.Count == 0)
                return;

            var expandExpression = ExecExpandExpression.TryCreate(new[]
            {
                interpreter.ExecStack.Top,
                new ExecYExpression()
            }, interpreter.Configuration);

            interpreter.ExecStack.Insert(interpreter.ExecStack.Count - 1, expandExpression);
        }
    }

    /// <summary>
    /// The Push implementation of the "K combinator". Removes the second item on the EXEC stack.
    /// </summary>
    public class ExecKExpression : Expression
    {
        public ExecKExpression() : base("EXEC.K") { }

        public override void Eval(IInterpreter interpreter)
        {
            if (interpreter.ExecStack.Count < 2)
                return;

            var top = interpreter.ExecStack.Pop();
            interpreter.ExecStack.SetTop(top);
        }
    }

    /// <summary>
    /// The Push implementation of the "S combinator". Pops 3 items from the EXEC stack, which we will call A, B, and C
    /// (with A being the first one popped). Then pushes a list containing B and C back onto the EXEC stack, followed by
    /// another instance of C, followed by another instance of A.
    /// </summary>
    public class ExecSExpression : Expression
    {
        public ExecSExpression() : base("EXEC.S") { }

        public override void Eval(IInterpreter interpreter)
        {
            if (interpreter.ExecStack.Count < 3)
                return;

            var expressions = interpreter.ExecStack.Pop(2);
            var a = expressions[1];
            var b = expressions[0];
            var c = interpreter.ExecStack.Top;

            interpreter.ExecStack.SetTop(ExecExpandExpression.TryCreate(new[] { c, b }, interpreter.Configuration));
            interpreter.ExecStack.Push(c, a);
        }
    }
}