Пример #1
0
        public static void Rechnen(double operand1, Operator @operator, double operand2, Action <double> onSuccess, Action onFailure)
        {
            switch (@operator)
            {
            case Operator.Plus:
                operand1 += operand2;
                break;

            case Operator.Minus:
                operand1 -= operand2;
                break;

            case Operator.Mal:
                operand1 *= operand2;
                break;

            case Operator.Durch:
                if (operand2 == 0)
                {
                    onFailure();
                    return;
                }
                operand1 /= operand2;
                break;

            default:
                throw new ArgumentOutOfRangeException(@operator.ToString());
            }
            onSuccess(operand1);
        }
Пример #2
0
        // Check correctness
        override public string ToString()
        {
            string expression;

            if (Object.ReferenceEquals(op, null))
            {
                return(solution.ToString());
            }

            expression = OperatorNames.OpenParenthesis + Left.ToString() + op.ToString();

            if (!op.IsUnary())
            {
                expression += Right.ToString();
            }
            return(expression + OperatorNames.ClosedParenthesis);
        }
Пример #3
0
 public override string ToString()
 {
     return Operator.ToString() + " " + PreviousTotal.ToString();
 }
Пример #4
0
        void PerformOperation(int leftIndex, int rightIndex, Operator operation)
        {
            // Perform operation against given operands.
            // Result is stored back to left operand value.
            // Right operand value is flagged as eliminated (used).

            Operand left  = GetLeftOperand(leftIndex);
            Operand right = GetRightOperand(rightIndex);

            try
            {
                switch (operation)
                {
                case Operator.Exponention:
                    throw new CalculatorEvaluateException("Exponentiation not implemented as integer operation");

                case Operator.Multiplication:
                    left.Value = checked (left.Value * right.Value);
                    break;

                case Operator.Division:
                    if (right.Value == 0)
                    {
                        throw new CalculatorEvaluateException("Division by zero.");
                    }
                    left.Value = left.Value / right.Value;
                    break;

                case Operator.Addition:
                    left.Value = checked (left.Value + right.Value);
                    break;

                case Operator.Subtraction:
                    left.Value = checked (left.Value - right.Value);
                    break;

                default:
                    throw new CalculatorEvaluateException(string.Format("Unsupported operation {0}", operation.ToString()));
                }
            }
            catch (OverflowException ex)
            {
                throw new CalculatorEvaluateException("Overflow error");
            }
            right.Eliminated = true;
        }
Пример #5
0
 public override string ToString()
 {
     return(Operator.ToString() + " " + Operand.ToString());
 }
Пример #6
0
 public override string ToString() => $"{number1?.ToString() ?? ""} {@operator?.ToString() ?? ""} {number2?.ToString() ?? ""}";