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

using System;
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 : StatefullExpression
    {
        private const string prefix = "( ";
        private const string postfix = ")";
        private const string delimiter = " ";

        public readonly Expression[] Expressions;
        public readonly bool IsEmpty;

        private List<Expression> treeIndex;

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

        public ExecExpandExpression(Expression[] expressions)
        {
            Expressions = expressions;
            IsEmpty = expressions.Length == 0;
        }

        // copy constructor
        public ExecExpandExpression(ExecExpandExpression original, Cloner cloner) : base(original, cloner)
        {
            Expressions = new Expression[original.Expressions.Length];
            Array.Copy(original.Expressions, Expressions, original.Expressions.Length);

            if (original.treeIndex != null)
            {
                treeIndex = original.treeIndex.Select(e => cloner.Clone(e)).ToList();
            }

            IsEmpty = original.IsEmpty;
        }

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

        protected override string InitStringRepresentation()
        {
            var sb = new StringBuilder();

            sb.Append(prefix);

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

            sb.Append(postfix);

            return sb.ToString();
        }

        protected override int InitId()
        {
            unchecked
            {
                var hash = 19;
                foreach (var e in Expressions)
                {
                    hash *= 31 + e.GetHashCode();
                }

                return hash;
            }
        }

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

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        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 Expressions.SequenceEqual(other.Expressions);
        }

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

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

                return 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)
        {
            BuildIndexIfNecessary();

            return treeIndex[index];
        }

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

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

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

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

                    expand.BuildIndexIfNecessary();
                    treeIndex.AddRange(expand.treeIndex);
                }
                else
                {
                    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 : StatelessExpression
    {
        protected override string InitStringRepresentation() { return "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 : StatelessExpression
    {
        protected override string InitStringRepresentation() { return "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 : StatelessExpression
    {
        protected override string InitStringRepresentation() { return "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 : StatelessExpression
    {
        protected override string InitStringRepresentation() { return "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);
        }
    }
}