public void ShouldAbsoluteNumbers()
        {
            Calculator calc = new Calculator();

            Assert.AreEqual(2, calc.Absolute(2));
            Assert.AreEqual(1.5, calc.Absolute(-1.5));
            Assert.AreEqual(0, calc.Absolute(0));
        }
예제 #2
0
        //Method of parsing inputExpression on each time where text on inputExpression is Changed
        private void Parse()
        {
            //Declaration of variable
            int startPosition, endPosition, index;

            string parsedNumber = "";

            double number, result;

            //ScreenNumber is 1 if current screen is first screen otherwise 2
            int screenNumber = isSecondPage ? 2 : 1;

            //getting status
            int status = int.Parse(String.Concat(screenNumber.ToString(), currentBtnIndex));

            switch (status)
            {
            /*
             * Explanation Here Case 102 Means:
             * 1->First Screen
             * 0->index of row i.e 0 means first row
             * 2->index of column i.e 2 means third row
             */
            case 102:    //Square Root
            {
                startPosition = evaluationString.IndexOf("sqrt(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where sqrt( length is 5 so
                for (index = (startPosition + 5); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.SquareRoot(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 110:    //sin
            {
                startPosition = evaluationString.IndexOf("sin(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where sin( length is 4 so
                for (index = (startPosition + 4); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Check calculator is in degree mode or not
                if (isDegree)
                {
                    number = Calc.DegreeToRadian(number);
                }
                //Round result
                result = Math.Round(Calc.Sin(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 111:    //cos
            {
                startPosition = evaluationString.IndexOf("cos(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where cos( length is 4 so
                for (index = (startPosition + 4); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Check calculator is in degree mode or not
                if (isDegree)
                {
                    number = Calc.DegreeToRadian(number);
                }

                //Round result
                result = Math.Round(Calc.Cos(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 112:    //tan
            {
                startPosition = evaluationString.IndexOf("tan(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where tan( length is 4 so
                for (index = (startPosition + 4); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Check calculator is in degree mode or not
                if (isDegree)
                {
                    number = Calc.DegreeToRadian(number);
                }

                //Round result
                result = Math.Round(Calc.Tan(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 120:    //ln
            {
                startPosition = evaluationString.IndexOf("ln(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where ln( length is 3 so
                for (index = (startPosition + 3); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.Ln(number), 4);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 121:    //log
            {
                startPosition = evaluationString.IndexOf("log(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where log( length is 4 so
                for (index = (startPosition + 4); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.Log(number), 4);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 130:    //e^
            {
                startPosition = evaluationString.IndexOf("e^(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where e^( length is 3 so
                for (index = (startPosition + 3); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.Exponential(number), 5);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 140:    //absolute
            {
                startPosition = evaluationString.IndexOf("abs(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where abs( length is 4 so
                for (index = (startPosition + 4); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Calc.Absolute(number);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 202:    //Cube root
            {
                startPosition = evaluationString.IndexOf("cbrt(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where cbrt( length is 5 so
                for (index = (startPosition + 5); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.CubeRoot(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 210:    //SineInverse
            {
                startPosition = evaluationString.IndexOf("Asin(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where Asin( length is 5 so
                for (index = (startPosition + 5); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.SineInverse(number), 2);
                //Check calculator is in degree mode or not
                if (isDegree)
                {
                    result = Math.Round(Calc.RadianToDegree(result), 3);
                }

                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 211:    //CosInverse
            {
                startPosition = evaluationString.IndexOf("Acos(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where Acos( length is 5 so
                for (index = (startPosition + 5); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.CosInverse(number), 2);
                //Check calculator is in degree mode or not
                if (isDegree)
                {
                    result = Math.Round(Calc.RadianToDegree(result), 3);
                }
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 212:    //TanInverse
            {
                startPosition = evaluationString.IndexOf("Atan(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where Atan( length is 5 so
                for (index = (startPosition + 5); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.TanInverse(number), 2);
                //Check calculator is in degree mode or not
                if (isDegree)
                {
                    result = Math.Round(Calc.RadianToDegree(result), 3);
                }
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 220:    //Sine Hyperbolic
            {
                startPosition = evaluationString.IndexOf("sinh(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where sinh( length is 5 so
                for (index = (startPosition + 5); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.SineHyperbolic(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 221:    //Cos Hyperbolic
            {
                startPosition = evaluationString.IndexOf("cosh(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where cosh( length is 5 so
                for (index = (startPosition + 5); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.CosHyperbolic(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 222:    //Tan Hyperbolic
            {
                startPosition = evaluationString.IndexOf("tanh(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where tanh( length is 5 so
                for (index = (startPosition + 5); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.TanHyperbolic(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 230:    //Inverse Sine Hyperbolic
            {
                startPosition = evaluationString.IndexOf("Asinh(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where Asinh( length is 6 so
                for (index = (startPosition + 6); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.InverseSineHyperbolic(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 231:    //Inverse Cos Hyperbolic
            {
                startPosition = evaluationString.IndexOf("Acosh(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where Acosh( length is 6 so
                for (index = (startPosition + 6); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.InverseCosHyperbolic(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 232:    //Inverse Tan Hyperbolic
            {
                startPosition = evaluationString.IndexOf("Atanh(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where Atanh( length is 6 so
                for (index = (startPosition + 6); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.InverseTanHyperbolic(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            case 240:    //2^
            {
                startPosition = evaluationString.IndexOf("2^(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where 2^( length is 3 so
                for (index = (startPosition + 3); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = double.Parse(parsedNumber);
                //Round result
                result = Math.Round(Calc.PowerOf2(number), 2);
                //Than replaces in evaluationString
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }

            //Same process on three cases so
            case 131:
            case 132:
            case 241:
            {
                string givenNumber = "";
                startPosition = evaluationString.IndexOf("^(");
                endPosition   = evaluationString.IndexOf(")", startPosition);
                //Where ^( length is 2 so
                for (index = (startPosition + 2); index < endPosition; index++)
                {
                    //Getting Number Lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                double power = double.Parse(parsedNumber);
                //To get the actual number
                index = startPosition - 1;

                //Replace this with regular expression for short hand
                while (index >= 0 && (evaluationString[index] != '+' && txtBoxExpression.Text[index] != '-' && txtBoxExpression.Text[index] != '*' && txtBoxExpression.Text[index] != '/' && txtBoxExpression.Text[index] != '%' && txtBoxExpression.Text[index] != '(' && txtBoxExpression.Text[index] != ')'))
                {
                    givenNumber += evaluationString[index];
                    index--;
                }
                //Result
                result = Math.Round(Calc.Power(double.Parse(givenNumber), power), 2);
                //Replace result on txtBoxExpression
                evaluationString = evaluationString.Remove(index + 1, endPosition - index).Insert(index + 1, result.ToString());

                break;
            }

            case 242:    //Factorial
            {
                startPosition = evaluationString.IndexOf("facto(");
                endPosition   = evaluationString.IndexOf(')', startPosition);
                //Where ( length is 6 so
                for (index = (startPosition + 6); index < endPosition; index++)
                {
                    //Getting Number lies inside Bracket
                    parsedNumber += evaluationString[index];
                }
                //Parsing into float
                number = Math.Abs(double.Parse(parsedNumber));
                //Round result
                result = Calc.Factorial(number);
                //Than replaces in txBoxExpression
                evaluationString = evaluationString.Remove(startPosition, (endPosition - startPosition + 1)).Insert(startPosition, result.ToString());
                break;
            }
            //On Default Case do nothing

            default: { break; }
            }
        }