RowVector.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 RowVector : NullCheckBinaryOperator
    {
        public RowVector(ScriptNode Left, ScriptNode Y, bool NullCheck, int Start, int Length, Expression Expression)
            : base(Left, 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 Right = this.right.Evaluate(Variables);
 
            return EvaluateIndex(Left, 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 Right = await this.right.EvaluateAsync(Variables);
 
            return EvaluateIndex(Left, Right, this.nullCheck, this);
        }
        public static IElement EvaluateIndex(IElement Matrix, IElement Index, bool NullCheck, ScriptNode Node)
        {
            if (Matrix is IMatrix M)
                return EvaluateIndex(M, Index, Node);
            else if (Matrix.IsScalar)
            {
                if (NullCheck && Matrix.AssociatedObjectValue is null)
                    return Matrix;
 
                throw new ScriptRuntimeException("The row index operator operates on matrices.", Node);
            }
            else
            {
                LinkedList<IElement> Elements = new LinkedList<IElement>();
 
                foreach (IElement E in Matrix.ChildElements)
                    Elements.AddLast(EvaluateIndex(E, Index, NullCheck, Node));
 
                return Matrix.Encapsulate(Elements, Node);
            }
        }
 
        public static IElement EvaluateIndex(IMatrix Matrix, IElement Index, ScriptNode Node)
        {
            if (Index.AssociatedObjectValue is double d)
            {
                if (d < 0 || d > int.MaxValue || d != Math.Truncate(d))
                    throw new ScriptRuntimeException("Row index must be a non-negative integer.", Node);
 
                return Matrix.GetRow((int)d);
            }
 
            if (Index.IsScalar)
                throw new ScriptRuntimeException("Row index must be a non-negative integer.", Node);
            else
            {
                LinkedList<IElement> Elements = new LinkedList<IElement>();
 
                foreach (IElement E in Index.ChildElements)
                    Elements.AddLast(EvaluateIndex(Matrix, E, Node));
 
                return Index.Encapsulate(Elements, Node);
            }
        }
 
    }
}