コード例 #1
0
ファイル: Power.cs プロジェクト: orf53975/IoTGateway
        /// <summary>
        /// Calculates Left ^ Right.
        /// </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 EvaluatePower(IElement Left, IElement Right, ScriptNode Node)
        {
            DoubleNumber DR = Right as DoubleNumber;

            if (Left is DoubleNumber DL && DR != null)
            {
                return(new DoubleNumber(Math.Pow(DL.Value, DR.Value)));
            }

            if (Left is IRingElement LE && DR != null)
            {
                double d = DR.Value;
                if (d >= long.MinValue && d <= long.MaxValue && Math.Truncate(d) == d)
                {
                    long n = (long)d;

                    if (n < 0)
                    {
                        LE = LE.Invert();
                        if (LE == null)
                        {
                            throw new ScriptRuntimeException("Base element not invertible.", Node);
                        }

                        n = -n;
                    }
                    else if (n == 0)
                    {
                        if (!(LE is ICommutativeRingWithIdentityElement LE2))
                        {
                            throw new ScriptRuntimeException("Base element ring does not have unity.", Node);
                        }

                        return(LE2.One);
                    }

                    IRingElement Result = null;

                    while (n > 0)
                    {
                        if ((n & 1) == 1)
                        {
                            if (Result == null)
                            {
                                Result = LE;
                            }
                            else
                            {
                                Result = (IRingElement)Multiply.EvaluateMultiplication(Result, LE, Node);
                            }
                        }

                        n >>= 1;
                        if (n > 0)
                        {
                            LE = (IRingElement)Multiply.EvaluateMultiplication(LE, LE, Node);
                        }
                    }

                    return(Result);
                }
                else
                {
                    throw new ScriptRuntimeException("Exponent too large.", Node);
                }
            }

            if (Left.IsScalar)
            {
                if (Right.IsScalar)
                {
                    throw new ScriptRuntimeException("Power operation could not be computed.", Node);
                }
                else
                {
                    LinkedList <IElement> Elements = new LinkedList <IElement>();

                    foreach (IElement RightChild in Right.ChildElements)
                    {
                        Elements.AddLast(EvaluatePower(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(EvaluatePower(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(EvaluatePower(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(EvaluatePower(LeftChild, RightChild, Node));
                            }

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

                        return(Left.Encapsulate(LeftResult, Node));
                    }
                }
            }
        }
コード例 #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));
                    }