Sort.cs

using System;
using System.Collections.Generic;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Order;
 
namespace Waher.Script.Functions.Vectors
{
    public class Sort : FunctionMultiVariate
    {
        public Sort(ScriptNode Vector, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Vector },
                  new ArgumentType[] { ArgumentType.Vector },
                  Start, Length, Expression)
        {
        }
 
        public Sort(ScriptNode Vector, ScriptNode Order1, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Vector, Order1 },
                  new ArgumentType[] { ArgumentType.Vector, ArgumentType.Scalar },
                  Start, Length, Expression)
        {
        }
 
        public Sort(ScriptNode Vector, ScriptNode Order1, ScriptNode Order2, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Vector, Order1, Order2 },
                  new ArgumentType[] { ArgumentType.Vector, ArgumentType.Scalar, ArgumentType.Scalar },
                  Start, Length, Expression)
        {
        }
 
        public Sort(ScriptNode Vector, ScriptNode Order1, ScriptNode Order2, ScriptNode Order3, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Vector, Order1, Order2, Order3 },
                  new ArgumentType[] { ArgumentType.Vector, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar },
                  Start, Length, Expression)
        {
        }
 
        public Sort(ScriptNode Vector, ScriptNode Order1, ScriptNode Order2, ScriptNode Order3, ScriptNode Order4, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Vector, Order1, Order2, Order3, Order4 },
                  new ArgumentType[] { ArgumentType.Vector, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar },
                  Start, Length, Expression)
        {
        }
 
        public Sort(ScriptNode Vector, ScriptNode Order1, ScriptNode Order2, ScriptNode Order3, ScriptNode Order4, ScriptNode Order5,
            int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Vector, Order1, Order2, Order3, Order4, Order5 },
                  new ArgumentType[] { ArgumentType.Vector, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar,
                    ArgumentType.Scalar },
                  Start, Length, Expression)
        {
        }
 
        public Sort(ScriptNode Vector, ScriptNode Order1, ScriptNode Order2, ScriptNode Order3, ScriptNode Order4, ScriptNode Order5,
            ScriptNode Order6, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Vector, Order1, Order2, Order3, Order4, Order5, Order6 },
                  new ArgumentType[] { ArgumentType.Vector, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar,
                    ArgumentType.Scalar, ArgumentType.Scalar },
                  Start, Length, Expression)
        {
        }
 
        public Sort(ScriptNode Vector, ScriptNode Order1, ScriptNode Order2, ScriptNode Order3, ScriptNode Order4, ScriptNode Order5,
            ScriptNode Order6, ScriptNode Order7, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Vector, Order1, Order2, Order3, Order4, Order5, Order6, Order7 },
                  new ArgumentType[] { ArgumentType.Vector, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar,
                    ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar },
                  Start, Length, Expression)
        {
        }
 
        public Sort(ScriptNode Vector, ScriptNode Order1, ScriptNode Order2, ScriptNode Order3, ScriptNode Order4, ScriptNode Order5,
            ScriptNode Order6, ScriptNode Order7, ScriptNode Order8, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Vector, Order1, Order2, Order3, Order4, Order5, Order6, Order7, Order8 },
                  new ArgumentType[] { ArgumentType.Vector, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar,
                    ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar },
                  Start, Length, Expression)
        {
        }
 
        public Sort(ScriptNode Vector, ScriptNode Order1, ScriptNode Order2, ScriptNode Order3, ScriptNode Order4, ScriptNode Order5,
            ScriptNode Order6, ScriptNode Order7, ScriptNode Order8, ScriptNode Order9, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { Vector, Order1, Order2, Order3, Order4, Order5, Order6, Order7, Order8, Order9 },
                  new ArgumentType[] { ArgumentType.Vector, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar,
                    ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar, ArgumentType.Scalar },
                  Start, Length, Expression)
        {
        }
 
        public override string FunctionName => nameof(Sort);
 
        public override string[] DefaultArgumentNames
        {
            get { return new string[] { "x", "o1", "o2", "o3", "o4", "o5", "o6", "o7", "o8", "o9" }; }
        }
 
        public override IElement Evaluate(IElement[] Arguments, Variables Variables)
        {
            int c = Arguments.Length;
 
            if (!(Arguments[0] is IVector Vector))
                throw new ScriptRuntimeException("First argument muts be a vector.", this);
 
            ICollection<IElement> Temp = Vector.VectorElements;
            IElement[] Elements;
            int i;
 
            if (Temp is IElement[] V)
                Elements = (IElement[])V.Clone();
            else
            {
                Elements = new IElement[Temp.Count];
                i = 0;
 
                foreach (IElement E in Temp)
                    Elements[i++] = E;
            }
 
            if (c == 1)
                Array.Sort(Elements, new ElementOrder(this));
            else
            {
                IComparer<IElement>[] Comparers = new IComparer<IElement>[c];
                IElement Element;
                object Obj;
 
                for (i = 1; i < c; i++)
                {
                    Element = Arguments[i];
                    Obj = Element.AssociatedObjectValue;
 
                    if (Obj is double d)
                    {
                        int Sign = 1;
 
                        if (d < 0)
                        {
                            Sign = -1;
                            d = -d;
                        }
 
                        if (d == 0 || d > int.MaxValue || d != Math.Truncate(d))
                            throw new ScriptRuntimeException("Index values must be non-zero integers.", this);
 
                        Comparers[i - 1] = new IndexOrder(this, (int)(d - 1), Sign);
                    }
                    else if (Obj is string s)
                    {
                        int Sign = 1;
 
                        if (s.StartsWith("-"))
                        {
                            s = s.Substring(1);
                            Sign = -1;
                        }
 
                        Comparers[i - 1] = new PropertyOrder(this, s, Sign);
                    }
                    else if (Obj is ILambdaExpression Lambda)
                    {
                        if (Lambda.NrArguments != 2)
                            throw new ScriptRuntimeException("Lambda expressions must take exactly two parameters.", this);
 
                        Comparers[i - 1] = new LambdaOrder(Lambda, Variables);
                    }
                    else
                    {
                        throw new ScriptRuntimeException("Order parameters must be either lambda expressions, " +
                            "string values representing field names or numeric index values.", this);
                    }
                }
 
                Comparers[c - 1] = new ElementOrder(this);
 
                Array.Sort(Elements, new CompoundOrder(Comparers));
            }
 
            return Vector.Encapsulate(Elements, this);
        }
 
    }
}