Esempio n. 1
0
        public override void Calculate()
        {
            if (null == node1)
            {
                isint      = false;
                fresult    = Double.NaN;
                calculated = true;
                return;
            }
            node1.Calculate();
            isint = false;
            double src = node1.isint ? node1.result : node1.fresult;

            switch (func)
            {
            case FuncID.Sin:
                fresult = Math.Sin(src); break;

            case FuncID.Cos:
                fresult = Math.Cos(src); break;

            case FuncID.Tan:
                fresult = Math.Tan(src); break;

            default: break;
            }
            calculated = true;
        }
Esempio n. 2
0
        private void Calculate_Button_Click(object sender, RoutedEventArgs e)
        {
            if ("" == raw_input.Text)
            {
                return;
            }
            Calc_node node = null;

            try
            {
                node = G.Generate(raw_input.Text);
                node.Calculate();
            }
            catch (Exception)
            {
                result_box.Text = "算式中存在错误";
                return;
            }
            if (node.isint)
            {
                result_box.Text = node.result.ToString();
            }
            else if (Double.IsNaN(node.fresult))
            {
                result_box.Text = "算式中存在错误";
                return;
            }
            else
            {
                result_box.Text = node.fresult.ToString();
            }
        }
Esempio n. 3
0
 public override void Calculate()
 {
     if (internal_node != null)
     {
         internal_node.Calculate();
         if (internal_node.isint)
         {
             isint  = true;
             result = internal_node.result;
         }
         else
         {
             isint   = false;
             fresult = internal_node.fresult;
         }
     }
     else
     {
         isint   = false;
         fresult = Double.NaN;
     }
     calculated = true;
 }
Esempio n. 4
0
        public override void Calculate()
        {
            if (null == node1 || null == node2)
            {
                isint      = false;
                fresult    = Double.NaN;
                calculated = true;
                return;
            }
            node1.Calculate();
            node2.Calculate();
            isint = node1.isint && node2.isint && (op != Operator.EXPO) && (op != Operator.LOG) &&
                    ((op != Operator.DIVIDE) || (node2.result != 0 && node1.result % node2.result == 0));
            if (isint)
            {
                checked
                {
                    try
                    {
                        switch (op)
                        {
                        case Operator.ADD:
                            result = node1.result + node2.result; break;

                        case Operator.MINUS:
                            result = node1.result - node2.result; break;

                        case Operator.MULTI:
                            result = node1.result * node2.result; break;

                        case Operator.DIVIDE:
                            result = node1.result / node2.result; break;

                        default: break;
                        }
                    }
                    catch (OverflowException)
                    {
                        isint = false;
                    }
                }
            }
            if (!isint)
            {
                if (node1.isint)
                {
                    node1.fresult = node1.result;
                }
                if (node2.isint)
                {
                    node2.fresult = node2.result;
                }
                switch (op)
                {
                case Operator.ADD:
                    fresult = node1.fresult + node2.fresult; break;

                case Operator.MINUS:
                    fresult = node1.fresult - node2.fresult; break;

                case Operator.MULTI:
                    fresult = node1.fresult * node2.fresult; break;

                case Operator.DIVIDE:
                    fresult = node1.fresult / node2.fresult; break;

                case Operator.EXPO:
                    fresult = Math.Pow(node1.fresult, node2.fresult); break;

                case Operator.LOG:
                    fresult = Math.Log(node2.fresult, node1.fresult); break;

                default: break;
                }
            }
            calculated = true;
        }