示例#1
0
        public void AddDigit(int digit)
        {
            if (input.HasValue && Math.Log10(input.Value) > 9)
            {
                InputError?.Invoke(this, "Value is too long for this calculator");
                return;
            }
            if (count > 8)
            {
                InputError?.Invoke(this, "Value is too long for this calculator");
                return;
            }
            if (!op.HasValue)
            {
                result = null;
            }

            if (point)
            {
                count = (count ?? 0);
                input = ((input ?? 0) * Math.Pow(10, (double)count) + (double)digit / 10) / Math.Pow(10, (double)count);
                DidUpdateValue?.Invoke(this, input.Value, 0);
                count++;
            }
            else
            {
                input = (input ?? 0) * 10 + digit;
                DidUpdateValue?.Invoke(this, input.Value, 0);
            }
        }
示例#2
0
        public void Compute()
        {
            if (!(left.HasValue && currentOp.HasValue))
            {
                return;
            }

            switch (currentOp)
            {
            case Operation.Add:
                right = right + left;
                break;

            case Operation.Sub:
                right = right - left;
                break;

            case Operation.Mul:
                right = right * left;
                break;

            case Operation.Div:
                if (left == 0)
                {
                    CalculationError?.Invoke(this, "Division by 0!");
                    return;
                }
                right = right / left;
                break;
            }

            DidUpdateValue?.Invoke(this, right.Value, precision);
            left      = 0;
            currentOp = null;
        }
示例#3
0
 public void ClearAll()
 {
     input  = null;
     result = null;
     op     = null;
     DidUpdateValue?.Invoke(this, 0, 0);
 }
示例#4
0
        public void Compute()
        {
            switch (currentOp)
            {
            case Operation.Add:
                right = left + right;
                left  = null;
                break;

            case Operation.Sub:
                right = right - left;
                left  = null;
                break;

            case Operation.Mul:
                right = left * right;
                left  = null;
                break;

            case Operation.Div:
                if (left == 0)
                {
                    CalculationError?.Invoke(this, "Division by 0!");
                    return;
                }
                right = right / left;
                left  = null;
                break;
            }

            DidUpdateValue?.Invoke(this, right.Value, precision);
        }
示例#5
0
 public void AddDigit(int digit)
 {
     if (left.HasValue && Math.Log10(left.Value) > 10 || precision > 13)
     {
         InputError?.Invoke(this, "Input overflow");
         return;
     }
     if (precision > 10)
     {
         InputError?.Invoke(this, "Input overflow");
         return;
     }
     if (!decimalPoint)
     {
         if (left >= 0 || left == null)
         {
             left = (left ?? 0) * 10 + digit;
         }
         else
         {
             left = (left ?? 0) * 10 - digit;
         }
     }
     else
     {
         precision += 1;
         left       = left + (Math.Pow(0.1, precision) * digit);
     }
     DidUpdateValue?.Invoke(this, left.Value, precision);
 }
示例#6
0
        public void AddDigit(int digit)
        {
            Debug.WriteLine(digit);
            if (hasPoint == false)
            {
                if (input.HasValue && Math.Log10(input.Value) > 9)
                {
                    InputError?.Invoke(this, "Value is too long for this calculator!");
                    return;
                }

                input = (input ?? 0) * 10 + digit;
            }
            else
            {
                if (fractionDigits > 8)
                {
                    InputError?.Invoke(this, "Value is too long for this calculator!");
                    return;
                }
                fractionDigits += 1;
                input           = (input ?? 0) + digit * Math.Pow(10, -fractionDigits);
            }
            DidUpdateValue?.Invoke(this, input.Value, fractionDigits);
        }
示例#7
0
        public void AddDigit(double digit)
        {
            if (left.HasValue && Math.Log10(left.Value) > 10)
            {
                InputError?.Invoke(this, "Input overflow");
                return;
            }

            if (!decimalPoint)
            {
                left = (left ?? 0) * 10 + digit;
            }
            else
            {
                precision += 1;
                if (precision == 1)
                {
                    left = left + 0.1 * digit;
                }
                else
                {
                    string znach1 = left.ToString() + digit.ToString();
                    var    znach2 = double.Parse(znach1);
                    left = znach2;
                }
            }
            DidUpdateValue?.Invoke(this, left.Value, precision);
        }
示例#8
0
        public void ComputeUnar()
        {
            switch (currentOp)
            {
            case Operation.Sqrt:
                right = Math.Sqrt((double)left);

                break;

            case Operation.Log:
                right = Math.Log((double)left);

                break;

            case Operation.Sin:
                right = Math.Sin((double)left);

                break;

            case Operation.Cos:
                right = Math.Cos((double)left);

                break;

            case Operation.Tan:
                right = Math.Tan((double)left);

                break;
            }
            left = right;
            DidUpdateValue?.Invoke(this, right.Value, precision);
            right = null;
        }
示例#9
0
 public void Reset()
 {
     left      = 0;
     right     = null;
     currentOp = null;
     precision = 0;
     DidUpdateValue?.Invoke(this, left.Value, precision);
 }
示例#10
0
 public void SQRT()
 {
     if (input.HasValue && left != 0)
     {
         input = Math.Sqrt((double)input);
     }
     DidUpdateValue?.Invoke(this, input.Value, count);
 }
示例#11
0
 public void Reverce()
 {
     if (left.HasValue && left != 0)
     {
         left *= -1;
     }
     DidUpdateValue?.Invoke(this, left.Value, precision);
 }
示例#12
0
 public void SQRT()
 {
     if (left.HasValue && left != 0)
     {
         left = Math.Sqrt((double)left);
     }
     DidUpdateValue?.Invoke(this, left.Value, precision);
 }
 public void Reset()
 {
     currentOp    = null;
     left         = 0;
     right        = null;
     precision    = 0;
     decimalPoint = false;
     DidUpdateValue?.Invoke(this, left.Value, 0);
 }
示例#14
0
 public void RemoveDigit()
 {
     if (hasPoint == false)
     {
         long i = (long)input / 10;
         input = i;
     }
     DidUpdateValue?.Invoke(this, input.Value, fractionDigits);
 }
示例#15
0
        public void Compute()
        {
            switch (currentOp)
            {
            case Operation.Add:
                right = left + right;
                left  = null;
                break;

            case Operation.Sub:
                right -= left;
                left   = null;
                break;

            case Operation.Mul:
                right = left * right;
                left  = null;
                break;

            case Operation.Div:
                if (left == 0)
                {
                    CalculationError?.Invoke(this, "Division by 0!");
                    return;
                }
                right /= left;
                left   = null;
                break;

            case Operation.Pow:
                right *= right;
                left   = null;
                break;

            case Operation.Sqrt:
                right = Math.Sqrt((double)right);
                left  = null;
                break;

            case Operation.Drob:
                right = 1 / right;
                left  = null;
                break;

            case Operation.Sin:
                right = Math.Sin((double)right);
                left  = null;
                break;

            case Operation.Cos:
                right = Math.Cos((double)right);
                left  = null;
                break;
            }
            DidUpdateValue?.Invoke(this, right.Value, precision);
        }
示例#16
0
        public void Compute()
        {
            switch (currentOp)
            {
            case Operation.Add:
                right        = left + right;
                left         = null;
                precision    = 0;
                decimalPoint = false;
                break;

            case Operation.Sub:
                right        = right - left;
                left         = null;
                precision    = 0;
                decimalPoint = false;
                break;

            case Operation.Mul:
                right        = left * right;
                left         = null;
                precision    = 0;
                decimalPoint = false;
                break;

            case Operation.Div:
                if (left == 0)
                {
                    CalculationError?.Invoke(this, "Division by 0!");
                    return;
                }
                right        = right / left;
                left         = null;
                precision    = 0;
                decimalPoint = false;
                break;

            case Operation.Pow:
                right        = Math.Pow((double)right, (double)left);
                left         = null;
                precision    = 0;
                decimalPoint = false;
                break;

            default:
                currentOp    = null;
                precision    = 0;
                decimalPoint = false;
                return;
            }


            DidUpdateValue?.Invoke(this, right.Value, precision);
        }
示例#17
0
        public void TransformInput(CalculatorTransformation t)
        {
            input = input ?? 0;

            switch (t)
            {
            case CalculatorTransformation.Negate:
                input = -input;
                break;
            }
            DidUpdateValue?.Invoke(this, input.Value, fractionDigits);
        }
示例#18
0
 public void Sign()
 {
     if (left != null)
     {
         left = left * (-1);
         DidUpdateValue?.Invoke(this, left.Value, precision);
     }
     else
     {
         right = right * (-1);
         DidUpdateValue?.Invoke(this, right.Value, precision);
     }
 }
示例#19
0
 public void AddOperation(Operation op)
 {
     if (left.HasValue && currentOp.HasValue)
     {
         Compute();
     }
     if (!right.HasValue)
     {
         right     = left;
         left      = 0;
         precision = 0;
         DidUpdateValue.Invoke(this, left.Value, precision);
     }
     currentOp = op;
 }
示例#20
0
 public void Delete()
 {
     if (!hasPoint)
     {
         input = (int)(input ?? 0) / 10;
     }
     else
     {
         input = ((int)((input ?? 0) / Math.Pow(10, -fractionDigits)) / 10) * Math.Pow(10, -(--fractionDigits));
         if (fractionDigits == 0)
         {
             hasPoint = false;
         }
     }
     DidUpdateValue?.Invoke(this, input.Value, fractionDigits);
 }
 public void clearSymbol()
 {
     if (decimalPoint)
     {
         left = left - (left * Math.Pow(10, precision - 1) % 1) * Math.Pow(0.1, precision - 1);
         precision--;
         if (precision == 0)
         {
             decimalPoint = false;
         }
     }
     else
     {
         left = (int)(left * 0.1);
     }
     DidUpdateValue?.Invoke(this, left.Value, precision);
 }
示例#22
0
        public void TransformInput(CalculatorTransformation t)
        {
            input = input ?? 0;

            switch (t)
            {
            case CalculatorTransformation.Negate:
                input = -input;
                break;

            case CalculatorTransformation.Percent:
                input /= 100;
                break;

            case CalculatorTransformation.Sqr:
                input *= input;
                break;

            case CalculatorTransformation.Sqrt:
                if (input.HasValue && input.Value >= 0)
                {
                    input = Math.Sqrt(input ?? 0);
                }
                else
                {
                    ComputationError.Invoke(this, "Negative Square");
                }
                break;

            case CalculatorTransformation.Inverse:
                if (input.HasValue && input.Value != 0)
                {
                    input = 1 / input;
                }
                else
                {
                    ComputationError.Invoke(this, "Division by Zero");
                }
                break;
            }

            DidUpdateValue?.Invoke(this, input.Value, fractionDigits);
        }
示例#23
0
        public void AddDigit(int digit)
        {
            if (left.HasValue && Math.Log10(left.Value) > 10)
            {
                InputError?.Invoke(this, "Input overflow");
                return;
            }

            if (!decimalPoint)
            {
                left = (left ?? 0) * 10 + digit;
            }
            else
            {
                precision += 1;
            }

            DidUpdateValue?.Invoke(this, left.Value, precision);
        }
        public void AddDigit(int digit)
        {
            if (left.HasValue && Math.Log10(left.Value) > 10 || left.HasValue && Math.Log10(left.Value * Math.Pow(10, precision)) > 10)
            {
                InputError?.Invoke(this, "Too many digits");
                return;
            }

            if (!decimalPoint)
            {
                left = (left ?? 0) * 10 + digit;
            }
            else
            {
                precision += 1;
                left       = (left ?? 0) + digit / Math.Pow(10, precision);
            }

            DidUpdateValue?.Invoke(this, left.Value, precision);
        }
示例#25
0
 public void Earse()
 {
     if (left.HasValue)
     {
         if (precision > 0)
         {
             left *= Math.Pow(10, precision);
             left  = (left ?? 0) / 10 - (left ?? 0) % 10 / 10;
             precision--;
             left /= Math.Pow(10, precision);
             DidUpdateValue?.Invoke(this, left.Value, precision);
         }
         else
         {
             left         = (left ?? 0) / 10 - (left ?? 0) % 10 / 10;
             decimalPoint = false;
             DidUpdateValue?.Invoke(this, left.Value, precision);
         }
     }
 }
示例#26
0
        public void Compute()
        {
            switch (currentOp)
            {
            case Operation.Add:
                right = left + right;
                left  = null;
                break;

            case Operation.Sub:
                right = right - left;
                left  = null;
                break;

            case Operation.Mul:
                right = left * right;
                left  = null;
                break;

            case Operation.Div:
                if (left == 0)
                {
                    CalculationError?.Invoke(this, "Деление на 0!");
                    return;
                }
                right = right / left;
                left  = null;
                break;

            case Operation.Pow:
                right = Math.Pow((double)right, (double)left);
                left  = null;
                break;
            }
            left = right;
            DidUpdateValue?.Invoke(this, right.Value, precision);
            right     = null;
            currentOp = null;
        }
示例#27
0
 public void AddOperation(Operation op)
 {
     if (left.HasValue && currentOp.HasValue)
     {
         Compute();
     }
     if (!right.HasValue && !(op == Operation.Sqrt || op == Operation.Cos || op == Operation.Log || op == Operation.Tan || op == Operation.Sin))
     {
         right        = left;
         left         = 0;
         precision    = 0;
         decimalPoint = false;
         DidUpdateValue.Invoke(this, left.Value, precision);
         currentOp = op;
     }
     if (left.HasValue && op == Operation.Sqrt || op == Operation.Cos || op == Operation.Log || op == Operation.Tan || op == Operation.Sin || op == Operation.Sign || op == Operation.Interest)
     {
         currentOp = op;
         ComputeUnar();
         currentOp = null;
     }
 }
示例#28
0
        public void Compute()
        {
            switch (op)
            {
            case CalculatorOperation.Add:
                result = result + (input ?? 0);
                DidUpdateValue?.Invoke(this, result.Value, 0);
                input = 0;
                break;

            case CalculatorOperation.Div:
                if (input != null && input.Value != 0)
                {
                    result = result / (input ?? 0);
                    DidUpdateValue?.Invoke(this, result.Value, 0);
                    input = 0;
                    break;
                }
                else
                {
                    InputError?.Invoke(this, "Division by zero");
                    break;
                }

            case CalculatorOperation.Mul:
                result = result - (input ?? 0);
                DidUpdateValue?.Invoke(this, result.Value, 0);
                input = 0;
                break;

            case CalculatorOperation.Sub:
                result = result * (input ?? 0);
                DidUpdateValue?.Invoke(this, result.Value, 0);
                input = 0;
                break;
            }
            op = null;
        }
示例#29
0
        public void Compute()
        {
            switch (this.op)
            {
            case CalculatorOperation.Add:
                result = result + input;
                DidUpdateValue?.Invoke(this, result.Value, 0);
                ResetInput();
                break;

            case CalculatorOperation.Div:
                if (input.HasValue && input.Value != 0)
                {
                    result = result / input;
                    DidUpdateValue?.Invoke(this, result.Value, 0);
                    ResetInput();
                }
                else
                {
                    ComputationError?.Invoke(this, "Division by Zero");
                }
                break;
            }
        }
示例#30
0
        public void AddDigit(int digit)
        {
            if (left.HasValue && Math.Log10(left.Value) > 10 || precision > 13)
            {
                InputError?.Invoke(this, "Переполнение входного сигнала");
                return;
            }
            if (precision > 10)
            {
                InputError?.Invoke(this, "Переполнение входного сигнала");
                return;
            }
            if (!decimalPoint)
            {
                left = (left ?? 0) * 10 + digit;
            }
            else
            {
                precision += 1;
                left       = left + (Math.Pow(0.1, precision) * digit);
            }

            DidUpdateValue?.Invoke(this, left.Value, precision);
        }