Ejemplo n.º 1
0
        /// <summary>
        /// Multiplies two operands.
        /// </summary>
        /// <param name="Left">Left operand.</param>
        /// <param name="Right">Right operand.</param>
        /// <param name="Node">Node performing the operation.</param>
        /// <returns>Result</returns>
        public static IElement EvaluateMultiplication(IElement Left, IElement Right, ScriptNode Node)
        {
            IElement Result;

            if (Left is IRingElement LE && !(!(Right is IRingElement RE)))
            {
                Result = LE.MultiplyRight(RE);
                if (!(Result is null))
                {
                    return(Result);
                }

                Result = RE.MultiplyLeft(LE);
                if (!(Result is null))
                {
                    return(Result);
                }
            }

            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, Node))
                        {
                            throw new ScriptRuntimeException("Incompatible operands.", Node);
                        }

                        LE = Left as IRingElement;
                        RE = Right as IRingElement;
                        if (!(LE is null) && !(RE is null))
                        {
                            Result = LE.MultiplyRight(RE);
                            if (!(Result is null))
                            {
                                return(Result);
                            }

                            Result = RE.MultiplyLeft(LE);
                            if (!(Result is null))
                            {
                                return(Result);
                            }
                        }
                    }

                    throw new ScriptRuntimeException("Operands cannot be multiplied.", Node);
                }
                else
                {
                    LinkedList <IElement> Elements = new LinkedList <IElement>();

                    foreach (IElement RightChild in Right.ChildElements)
                    {
                        Elements.AddLast(EvaluateMultiplication(Left, RightChild, Node));
                    }

                    return(Right.Encapsulate(Elements, Node));
                }
            }
            else
            {
                if (Right.IsScalar)
                {
                    LinkedList <IElement> Elements = new LinkedList <IElement>();

                    foreach (IElement LeftChild in Left.ChildElements)
                    {
                        Elements.AddLast(EvaluateMultiplication(LeftChild, Right, Node));
                    }

                    return(Left.Encapsulate(Elements, Node));
                }
                else
                {
                    ICollection <IElement> LeftChildren  = Left.ChildElements;
                    ICollection <IElement> RightChildren = Right.ChildElements;

                    if (LeftChildren.Count == RightChildren.Count)
                    {
                        LinkedList <IElement>  Elements = new LinkedList <IElement>();
                        IEnumerator <IElement> eLeft    = LeftChildren.GetEnumerator();
                        IEnumerator <IElement> eRight   = RightChildren.GetEnumerator();

                        try
                        {
                            while (eLeft.MoveNext() && eRight.MoveNext())
                            {
                                Elements.AddLast(EvaluateMultiplication(eLeft.Current, eRight.Current, Node));
                            }
                        }
                        finally
                        {
                            eLeft.Dispose();
                            eRight.Dispose();
                        }

                        return(Left.Encapsulate(Elements, Node));
                    }
                    else
                    {
                        LinkedList <IElement> LeftResult = new LinkedList <IElement>();

                        foreach (IElement LeftChild in LeftChildren)
                        {
                            LinkedList <IElement> RightResult = new LinkedList <IElement>();

                            foreach (IElement RightChild in RightChildren)
                            {
                                RightResult.AddLast(EvaluateMultiplication(LeftChild, RightChild, Node));
                            }

                            LeftResult.AddLast(Right.Encapsulate(RightResult, Node));
                        }

                        return(Left.Encapsulate(LeftResult, Node));
                    }
                }
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Divides the left operand from the right one.
        /// </summary>
        /// <param name="Left">Left operand.</param>
        /// <param name="Right">Right operand.</param>
        /// <param name="Node">Node performing the operation.</param>
        /// <returns>Result</returns>
        public static IElement EvaluateDivision(IElement Left, IElement Right, ScriptNode Node)
        {
            IElement     Result;
            IRingElement Temp;

            if (Left is IRingElement LE && !(!(Right is IRingElement RE)))
            {
                // TODO: Optimize in case of matrices. It's more efficient to employ a solve algorithm than to compute the inverse and the multiply.

                Temp = LE.Invert();
                if (!(Temp is null))
                {
                    Result = RE.MultiplyLeft(Temp);
                    if (!(Result is null))
                    {
                        return(Result);
                    }

                    Result = Temp.MultiplyRight(RE);
                    if (!(Result is null))
                    {
                        return(Result);
                    }
                }
            }

            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, Node))
                        {
                            throw new ScriptRuntimeException("Incompatible operands.", Node);
                        }

                        LE = Left as IRingElement;
                        RE = Right as IRingElement;
                        if (!(LE is null) && !(RE is null))
                        {
                            Temp = LE.Invert();
                            if (!(Temp is null))
                            {
                                Result = RE.MultiplyLeft(Temp);
                                if (!(Result is null))
                                {
                                    return(Result);
                                }

                                Result = Temp.MultiplyRight(RE);
                                if (!(Result is null))
                                {
                                    return(Result);
                                }
                            }
                        }
                    }

                    throw new ScriptRuntimeException("Operands cannot be divided.", Node);
                }
                else
                {
                    LinkedList <IElement> Elements = new LinkedList <IElement>();

                    foreach (IElement RightChild in Right.ChildElements)
                    {
                        Elements.AddLast(EvaluateDivision(Left, RightChild, Node));
                    }

                    return(Right.Encapsulate(Elements, Node));
                }
            }
            else
            {
                if (Right.IsScalar)
                {
                    LinkedList <IElement> Elements = new LinkedList <IElement>();

                    foreach (IElement LeftChild in Left.ChildElements)
                    {
                        Elements.AddLast(EvaluateDivision(LeftChild, Right, Node));
                    }

                    return(Left.Encapsulate(Elements, Node));
                }
                else
                {
                    if (Left is ISet Set1 && !(!(Right is ISet Set2)))
                    {
                        return(new SetDifference(Set1, Set2));
                    }