MatrixIndex.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Operators.Matrices
{
    public class MatrixIndex : NullCheckTernaryOperator
    {
        public MatrixIndex(ScriptNode Left, ScriptNode X, ScriptNode Y, bool NullCheck, int Start, int Length, Expression Expression)
            : base(Left, X, Y, NullCheck, Start, Length, Expression)
        {
        }
 
        public override IElement Evaluate(Variables Variables)
        {
            IElement Left = this.left.Evaluate(Variables);
            if (this.nullCheck && Left.AssociatedObjectValue is null)
                return Left;
 
            IElement Middle = this.middle.Evaluate(Variables);
            IElement Right = this.right.Evaluate(Variables);
 
            return EvaluateIndex(Left, Middle, Right, this.nullCheck, this);
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (!this.isAsync)
                return this.Evaluate(Variables);
 
            IElement Left = await this.left.EvaluateAsync(Variables);
            if (this.nullCheck && Left.AssociatedObjectValue is null)
                return Left;
 
            IElement Middle = await this.middle.EvaluateAsync(Variables);
            IElement Right = await this.right.EvaluateAsync(Variables);
 
            return EvaluateIndex(Left, Middle, Right, this.nullCheck, this);
        }
        public static IElement EvaluateIndex(IElement Matrix, IElement IndexX, IElement IndexY, bool NullCheck, ScriptNode Node)
        {
            if (Matrix is IMatrix M)
                return EvaluateIndex(M, IndexX, IndexY, Node);
            else if (Matrix.IsScalar)
            {
                if (NullCheck && Matrix.AssociatedObjectValue is null)
                    return Matrix;
 
                throw new ScriptRuntimeException("The index operator operates on matrices.", Node);
            }
            else
            {
                LinkedList<IElement> Elements = new LinkedList<IElement>();
 
                foreach (IElement E in Matrix.ChildElements)
                    Elements.AddLast(EvaluateIndex(E, IndexX, IndexY, NullCheck, Node));
 
                return Matrix.Encapsulate(Elements, Node);
            }
        }
 
        public static IElement EvaluateIndex(IMatrix Matrix, IElement IndexX, IElement IndexY, ScriptNode Node)
        {
            if (IndexX.AssociatedObjectValue is double x && 
                IndexY.AssociatedObjectValue is double y)
            {
                if (x < 0 || x > int.MaxValue || x != Math.Truncate(x) || y < 0 || y > int.MaxValue || y != Math.Truncate(y))
                    throw new ScriptRuntimeException("Indices must be non-negative integers.", Node);
 
                return Matrix.GetElement((int)x, (int)y);
            }
 
            if (IndexX.IsScalar)
            {
                if (IndexY.IsScalar)
                    throw new ScriptRuntimeException("Index must be a non-negative integer.", Node);
                else
                {
                    LinkedList<IElement> Elements = new LinkedList<IElement>();
 
                    foreach (IElement E in IndexY.ChildElements)
                        Elements.AddLast(EvaluateIndex(Matrix, IndexX, E, Node));
 
                    return IndexY.Encapsulate(Elements, Node);
                }
            }
            else
            {
                if (IndexY.IsScalar)
                {
                    LinkedList<IElement> Elements = new LinkedList<IElement>();
 
                    foreach (IElement E in IndexX.ChildElements)
                        Elements.AddLast(EvaluateIndex(Matrix, E, IndexY, Node));
 
                    return IndexX.Encapsulate(Elements, Node);
                }
                else
                {
                    ICollection<IElement> IndexXChildren = IndexX.ChildElements;
                    ICollection<IElement> IndexYChildren = IndexY.ChildElements;
 
                    if (IndexXChildren.Count == IndexYChildren.Count)
                    {
                        LinkedList<IElement> Elements = new LinkedList<IElement>();
                        IEnumerator<IElement> eX = IndexXChildren.GetEnumerator();
                        IEnumerator<IElement> eY = IndexYChildren.GetEnumerator();
 
                        try
                        {
                            while (eX.MoveNext() && eY.MoveNext())
                                Elements.AddLast(EvaluateIndex(Matrix, eX.Current, eY.Current, Node));
                        }
                        finally
                        {
                            eX.Dispose();
                            eY.Dispose();
                        }
 
                        return IndexX.Encapsulate(Elements, Node);
                    }
                    else
                    {
                        LinkedList<IElement> XResult = new LinkedList<IElement>();
 
                        foreach (IElement XChild in IndexXChildren)
                        {
                            LinkedList<IElement> YResult = new LinkedList<IElement>();
 
                            foreach (IElement YChild in IndexYChildren)
                                YResult.AddLast(EvaluateIndex(Matrix, XChild, YChild, Node));
 
                            XResult.AddLast(IndexY.Encapsulate(YResult, Node));
                        }
 
                        return IndexX.Encapsulate(XResult, Node);
                    }
                }
            }
        }
 
    }
}