FunctionOneVectorVariable.cs

using System.Threading.Tasks;
using Waher.Runtime.Collections;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Objects.Matrices;
using Waher.Script.Objects.VectorSpaces;
using Waher.Script.Operators.Vectors;
 
namespace Waher.Script.Model
{
    public abstract class FunctionOneVectorVariable : FunctionOneVariable, IIterativeEvaluation
    {
        public FunctionOneVectorVariable(ScriptNode Argument, int Start, int Length, Expression Expression)
            : base(Argument, Start, Length, Expression)
        {
        }
 
        public override string[] DefaultArgumentNames => new string[] { "v" };
 
        public override IElement Evaluate(IElement Argument, Variables Variables)
        {
            if (!(Argument is IVector Vector))
            {
                if (Argument is IMatrix Matrix)
                {
                    ChunkedList<IElement> Elements = new ChunkedList<IElement>();
                    int i, c = Matrix.Rows;
 
                    if (Matrix is DoubleMatrix)
                    {
                        for (i = 0; i < c; i++)
                            Elements.Add(this.Evaluate((DoubleVector)Matrix.GetRow(i), Variables));
                    }
                    else if (Matrix is ComplexMatrix)
                    {
                        for (i = 0; i < c; i++)
                            Elements.Add(this.Evaluate((ComplexVector)Matrix.GetRow(i), Variables));
                    }
                    else if (Matrix is BooleanMatrix)
                    {
                        for (i = 0; i < c; i++)
                            Elements.Add(this.Evaluate((BooleanVector)Matrix.GetRow(i), Variables));
                    }
                    else
                    {
                        for (i = 0; i < c; i++)
                            Elements.Add(this.Evaluate(Matrix.GetRow(i), Variables));
                    }
 
                    return Argument.Encapsulate(Elements, this);
                }
                else
                {
                    if (Argument is ISet Set)
                    {
                        ChunkedList<IElement> Elements = new ChunkedList<IElement>();
 
                        foreach (IElement E in Set.ChildElements)
                            Elements.Add(this.Evaluate(E, Variables));
 
                        return Argument.Encapsulate(Elements, this);
                    }
                    else
                        return this.EvaluateNonVector(Argument, Variables);
                }
            }
 
            if (Vector is DoubleVector DoubleVector)
                return this.EvaluateVector(DoubleVector, Variables);
 
            if (Vector is ComplexVector ComplexVector)
                return this.EvaluateVector(ComplexVector, Variables);
 
            if (Vector is BooleanVector BooleanVector)
                return this.EvaluateVector(BooleanVector, Variables);
 
            return this.EvaluateVector(Vector, Variables);
        }
 
        protected virtual IElement EvaluateNonVector(IElement Argument, Variables Variables)
        {
            IVector Vector = VectorDefinition.Encapsulate(new IElement[] { Argument }, false, this);
 
            if (Vector is DoubleVector DoubleVector)
                return this.EvaluateVector(DoubleVector, Variables);
 
            if (Vector is ComplexVector ComplexVector)
                return this.EvaluateVector(ComplexVector, Variables);
 
            if (Vector is BooleanVector BooleanVector)
                return this.EvaluateVector(BooleanVector, Variables);
 
            return this.EvaluateVector(Vector, Variables);
        }
 
 
        public override async Task<IElement> EvaluateAsync(IElement Argument, Variables Variables)
        {
            if (!(Argument is IVector Vector))
            {
                if (Argument is IMatrix Matrix)
                {
                    ChunkedList<IElement> Elements = new ChunkedList<IElement>();
                    int i, c = Matrix.Rows;
 
                    if (Matrix is DoubleMatrix)
                    {
                        for (i = 0; i < c; i++)
                            Elements.Add(await this.EvaluateAsync((DoubleVector)Matrix.GetRow(i), Variables));
                    }
                    else if (Matrix is ComplexMatrix)
                    {
                        for (i = 0; i < c; i++)
                            Elements.Add(await this.EvaluateAsync((ComplexVector)Matrix.GetRow(i), Variables));
                    }
                    else if (Matrix is BooleanMatrix)
                    {
                        for (i = 0; i < c; i++)
                            Elements.Add(await this.EvaluateAsync((BooleanVector)Matrix.GetRow(i), Variables));
                    }
                    else
                    {
                        for (i = 0; i < c; i++)
                            Elements.Add(await this.EvaluateAsync(Matrix.GetRow(i), Variables));
                    }
 
                    return Argument.Encapsulate(Elements, this);
                }
                else
                {
                    if (Argument is ISet Set)
                    {
                        ChunkedList<IElement> Elements = new ChunkedList<IElement>();
 
                        foreach (IElement E in Set.ChildElements)
                            Elements.Add(await this.EvaluateAsync(E, Variables));
 
                        return Argument.Encapsulate(Elements, this);
                    }
                    else
                        return await this.EvaluateNonVectorAsync(Argument, Variables);
                }
            }
 
            if (Vector is DoubleVector DoubleVector)
                return await this.EvaluateVectorAsync(DoubleVector, Variables);
 
            if (Vector is ComplexVector ComplexVector)
                return await this.EvaluateVectorAsync(ComplexVector, Variables);
 
            if (Vector is BooleanVector BooleanVector)
                return await this.EvaluateVectorAsync(BooleanVector, Variables);
 
            return await this.EvaluateVectorAsync(Vector, Variables);
        }
 
        protected virtual async Task<IElement> EvaluateNonVectorAsync(IElement Argument, Variables Variables)
        {
            IVector Vector = VectorDefinition.Encapsulate(new IElement[] { Argument }, false, this);
 
            if (Vector is DoubleVector DoubleVector)
                return await this.EvaluateVectorAsync(DoubleVector, Variables);
 
            if (Vector is ComplexVector ComplexVector)
                return await this.EvaluateVectorAsync(ComplexVector, Variables);
 
            if (Vector is BooleanVector BooleanVector)
                return await this.EvaluateVectorAsync(BooleanVector, Variables);
 
            return await this.EvaluateVectorAsync(Vector, Variables);
        }
 
        public abstract IElement EvaluateVector(IVector Argument, Variables Variables);
 
        public virtual IElement EvaluateVector(DoubleVector Argument, Variables Variables)
        {
            return this.EvaluateVector((IVector)Argument, Variables);
        }
 
        public virtual IElement EvaluateVector(ComplexVector Argument, Variables Variables)
        {
            return this.EvaluateVector((IVector)Argument, Variables);
        }
 
        public virtual IElement EvaluateVector(BooleanVector Argument, Variables Variables)
        {
            return this.EvaluateVector((IVector)Argument, Variables);
        }
 
        public virtual Task<IElement> EvaluateVectorAsync(IVector Argument, Variables Variables)
        {
            return Task.FromResult(this.EvaluateVector(Argument, Variables));
        }
 
        public virtual Task<IElement> EvaluateVectorAsync(DoubleVector Argument, Variables Variables)
        {
            return Task.FromResult(this.EvaluateVector(Argument, Variables));
        }
 
        public virtual Task<IElement> EvaluateVectorAsync(ComplexVector Argument, Variables Variables)
        {
            return Task.FromResult(this.EvaluateVector(Argument, Variables));
        }
 
        public virtual Task<IElement> EvaluateVectorAsync(BooleanVector Argument, Variables Variables)
        {
            return Task.FromResult(this.EvaluateVector(Argument, Variables));
        }
 
        #region IIterativeEvaluation
 
        public virtual bool CanEvaluateIteratively => true;
 
        public virtual IIterativeEvaluator CreateEvaluator()
        {
            return new FunctionOneVectorVariableIterator(this);
        }
 
        #endregion
    }
}