Ejemplo n.º 1
0
        public void Parse_AllFunctions()
        {
            string[] functions =
            {
                "abs",   "sqrt",  "exp",  "ln", "log",
                "sin",   "cos",   "tan",
                "asin",  "acos",  "atan",
                "sinh",  "cosh",  "tanh",
                "round", "floor", "ceil"
            };

            string input = "";

            for (int i = 0; i < functions.Length; i++)
            {
                if (i > 0)
                {
                    input += " + ";
                }

                input += functions[i] + "(x)";
            }

            ArithmeticExpression ae = ArithmeticExpression.Parse(input);

            Assert.IsNotNull(ae);

            for (int i = 0; i < functions.Length; i++)
            {
                Assert.IsTrue(ae.IsCallbackUsed("operator_" + functions[i]));
            }

            Assert.IsFalse(ae.IsCallbackUsed("unknown"));
        }
Ejemplo n.º 2
0
        public void Parse_AllOperators()
        {
            ArithmeticExpression ae = ArithmeticExpression.Parse("0 + 1 - (2 * (3 / 4)) ^ (5 % 6)");

            Assert.IsNotNull(ae);

            Assert.IsTrue(ae.IsCallbackUsed("operator_add"));
            Assert.IsTrue(ae.IsCallbackUsed("operator_subtract"));
            Assert.IsTrue(ae.IsCallbackUsed("operator_multiply"));
            Assert.IsTrue(ae.IsCallbackUsed("operator_divide"));
            Assert.IsTrue(ae.IsCallbackUsed("operator_pow"));
            Assert.IsTrue(ae.IsCallbackUsed("operator_remainder"));

            Assert.IsFalse(ae.IsCallbackUsed("unknown"));
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Checks missing callbacks for given arithmetic expression
        /// </summary>
        /// <param name="item">Item to check</param>
        /// <param name="text">String builder to append warings to</param>
        private void CheckCallbacks(ListView.Item item, StringBuilder text)
        {
            if (item?.OperatorCallbacks == null)
            {
                return;
            }
            ArithmeticExpression ae = item.NumericValueSource as ArithmeticExpression;

            if (ae == null)
            {
                return;
            }

            bool isFirst      = true;
            bool iconAppended = false;

            string[] missingCallbacks = null;

            NativeOperatorCallbacks callbacks = item.OperatorCallbacks as NativeOperatorCallbacks;

            if (callbacks != null)
            {
                missingCallbacks = callbacks.MissingCallbacks;
                if (missingCallbacks.Length == 0)
                {
                    return;
                }
            }
            else
            {
                NativeOperatorRemotingCallbacks proxyCallbacks = item.OperatorCallbacks as NativeOperatorRemotingCallbacks;
                if (proxyCallbacks != null)
                {
                    iconAppended = true;
                    text.Append("      \f[-]\f[image:warning]  \f[0xaa6400]\f[I]" + Tx.T("mathlib.remoting"));

                    missingCallbacks = proxyCallbacks.MissingCallbacks;
                    if (missingCallbacks.Length == 0)
                    {
                        text.Append("\f[I]\f[Rc]");
                        return;
                    }
                }
            }

            if (missingCallbacks == null)
            {
                return;
            }

            for (int i = 0; i < missingCallbacks.Length; i++)
            {
                string current = missingCallbacks[i];
                if (!ae.IsCallbackUsed(current))
                {
                    continue;
                }

                if (isFirst)
                {
                    isFirst = false;
                    if (iconAppended)
                    {
                        text.Append(" \f[0x999999]|\f[0xaa6400] " + Tx.T("mathlib.missing callbacks"));
                    }
                    else
                    {
                        text.Append("      \f[-]\f[image:warning]  \f[0xaa6400]\f[I]" + Tx.T("mathlib.missing callbacks"));
                    }
                }
                else
                {
                    text.Append(", ");
                }

                if (current.StartsWith("constant_", StringComparison.Ordinal))
                {
                    text.Append("\f[I]");
                    text.Append(current, 9, current.Length - 9);
                    text.Append("\f[I]");
                }
                else if (current.StartsWith("operator_", StringComparison.Ordinal))
                {
                    text.Append(current, 9, current.Length - 9);
                }
                else
                {
                    text.Append(current);
                }
            }

            if (!isFirst)
            {
                text.Append("\f[I]\f[Rc]");
            }
        }