Residue.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Runtime.Collections;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Operators.Arithmetics
{
    public class Residue : BinaryOperator
    {
        public Residue(ScriptNode Left, ScriptNode Right, int Start, int Length, Expression Expression)
            : base(Left, Right, Start, Length, Expression)
        {
        }
 
        public override IElement Evaluate(Variables Variables)
        {
            IElement Left = this.left.Evaluate(Variables);
            IElement Right = this.right.Evaluate(Variables);
 
            return EvaluateResidue(Left, Right, this);
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (!this.isAsync)
                return this.Evaluate(Variables);
 
            IElement Left = await this.left.EvaluateAsync(Variables);
            IElement Right = await this.right.EvaluateAsync(Variables);
 
            return EvaluateResidue(Left, Right, this);
        }
 
        public static IElement EvaluateResidue(IElement Left, IElement Right, ScriptNode Node)
        {
            if (Left.AssociatedObjectValue is double dl && Right.AssociatedObjectValue is double dr)
            {
                if (dl < long.MinValue || dl > long.MaxValue || dl != Math.Truncate(dl))
                    throw new ScriptRuntimeException("Modulus operator does not work on decimal numbers.", Node);
 
                if (dr < long.MinValue || dr > long.MaxValue || dr != Math.Truncate(dr))
                    throw new ScriptRuntimeException("Modulus operator does not work on decimal numbers.", Node);
 
                long l = (long)dl;
                long r = (long)dr;
 
                return new DoubleNumber(l % r);
            }
 
            if (Left.IsScalar)
            {
                if (Right.IsScalar)
                {
                    ISet LeftSet = Left.AssociatedSet;
                    ISet RightSet = Right.AssociatedSet;
 
                    if (!LeftSet.Equals(RightSet))
                    {
                        if (Expression.UpgradeField(ref Left, ref LeftSet, ref Right, ref RightSet))
                        {
                            if (Left is IEuclidianDomainElement LE && Right is IEuclidianDomainElement RE)
                            {
                                ((IEuclidianDomain)LeftSet).Divide(LE, RE, out IEuclidianDomainElement Result);
                                return Result;
                            }
                        }
                    }
 
                    IElement Result2 = EvaluateNamedOperator("op_Modulus", Left, Right, Node);
                    if (!(Result2 is null))
                        return Result2;
 
                    throw new ScriptRuntimeException("Residue could not be computed.", Node);
                }
                else
                {
                    ChunkedList<IElement> Elements = new ChunkedList<IElement>();
 
                    foreach (IElement RightChild in Right.ChildElements)
                        Elements.Add(EvaluateResidue(Left, RightChild, Node));
 
                    return Right.Encapsulate(Elements, Node);
                }
            }
            else
            {
                if (Right.IsScalar)
                {
                    ChunkedList<IElement> Elements = new ChunkedList<IElement>();
 
                    foreach (IElement LeftChild in Left.ChildElements)
                        Elements.Add(EvaluateResidue(LeftChild, Right, Node));
 
                    return Left.Encapsulate(Elements, Node);
                }
                else
                {
                    ICollection<IElement> LeftChildren = Left.ChildElements;
                    ICollection<IElement> RightChildren = Right.ChildElements;
 
                    if (LeftChildren.Count == RightChildren.Count)
                    {
                        ChunkedList<IElement> Elements = new ChunkedList<IElement>();
                        IEnumerator<IElement> eLeft = LeftChildren.GetEnumerator();
                        IEnumerator<IElement> eRight = RightChildren.GetEnumerator();
 
                        try
                        {
                            while (eLeft.MoveNext() && eRight.MoveNext())
                                Elements.Add(EvaluateResidue(eLeft.Current, eRight.Current, Node));
                        }
                        finally
                        {
                            eLeft.Dispose();
                            eRight.Dispose();
                        }
 
                        return Left.Encapsulate(Elements, Node);
                    }
                    else
                    {
                        ChunkedList<IElement> LeftResult = new ChunkedList<IElement>();
 
                        foreach (IElement LeftChild in LeftChildren)
                        {
                            ChunkedList<IElement> RightResult = new ChunkedList<IElement>();
 
                            foreach (IElement RightChild in RightChildren)
                                RightResult.Add(EvaluateResidue(LeftChild, RightChild, Node));
 
                            LeftResult.Add(Right.Encapsulate(RightResult, Node));
                        }
 
                        return Left.Encapsulate(LeftResult, Node);
                    }
                }
            }
        }
 
    }
}