Пример #1
0
        }                          // The function deals with the Order/power operation.

        bool Unit_Intake_Command() // For the command like sin, cos, tan
        {
            bool done = true;

            if (Expressions.Contains("`"))
            {
                for (int c = Expressions.Count - 1; c >= 0; c--)
                {
                    string Element = Expressions [c];
                    if (Element == "`")
                    {
                        MathParserExpression RHS = theData [Expressions [c + 1].Trim("-".ToCharArray())];
                        if (Expressions [c + 1].Contains("-"))
                        {
                            if (RHS.Type.Contains("Number"))
                            {
                                RHS = new MathParserExpression((Number)RHS.Data * new Number(-1));
                                Expressions [c + 1].Replace("-", "");
                            }
                            if (RHS.Type.Contains("Matrix"))
                            {
                                RHS = new MathParserExpression((Matrix)RHS.Data * -1);
                                Expressions [c + 1].Replace("-", "");
                            }
                        }
                        UnitFunctionSolver ufs = new UnitFunctionSolver(Expressions [c - 1].Trim('-'), RHS);
                        if (ufs.isProcessed())
                        {
                            string name = autoNamer();
                            MathParserExpression ans = ufs.getSolution();
                            if (Expressions [c - 1].Contains("-"))
                            {
                                if (ans.Type.Contains("Number"))
                                {
                                    ans = new MathParserExpression((Number)ans.Data * new Number(-1));
                                    Expressions [c + 1].Replace("-", "");
                                }

                                if (ans.Type.Contains("Matrix"))
                                {
                                    ans = new MathParserExpression((Matrix)ans.Data * -1);
                                    Expressions [c + 1].Replace("-", "");
                                }
                            }
                            theData.Add(name, ans);
                            Expressions [c - 1] = name;
                        }
                        else
                        {
                            Processed = false;
                            done      = false;
                            break;
                        }
                        Expressions.RemoveRange(c, 2);
                        c = Expressions.Count;
                    }
                }
            }
            return(done);
        }
Пример #2
0
        public void Solve()
        {
            MathParser.StringObserver sol = new StringObserver(theExpression, Checker.History);
            if (sol.isProcessed())
            {
                solution = sol.getSolution();
            }
            else
            {
                Processed = false;
                throw new Exception("Expression Unsolvable.");
            }

            solution.Statement = theExpression;

            if (saveHistory)
            {
                if (string.IsNullOrEmpty(solution.Tag) || string.IsNullOrWhiteSpace(solution.Tag))
                {
                    if (solution.Type.Contains("Number"))
                    {
                        string name = autoNumberNamer();
                        solution.Tag = name;
                        solution.setEntireTag(name);
                        Checker.History.Add(name, solution);
                    }
                    else if (solution.Type.Contains("Matrix"))
                    {
                        string name = autoMatrixNamer();
                        solution.Tag = name;
                        solution.setEntireTag(name);
                        Checker.History.Add(name, solution);
                    }
                }
                else
                {
                    string name = solution.Tag;
                    if (Checker.History.ContainsKey(name))
                    {
                        //	solution.setEntireTag (name);
                        Checker.History[name] = solution;
                    }
                    else
                    {
                        //  solution.setEntireTag (name);
                        Checker.History.Add(name, solution);
                    }
                }
            }
        }             // end method for solve
Пример #3
0
        public void Solve()
        {
            if (Expressions.Count == 0)
            {
                Processed = false;
                throw new MathParserException("No Data to processes");
            }

            else if (Expressions.Count == 1)
            {
                if (Expressions[0].Contains("-"))
                {
                    MathParserExpression hold = theData[Expressions[0].Trim("-".ToCharArray())];
                    if (hold.Type.Contains("Number"))
                    {
                        Number ans = new Number((double)-1) * hold.Data;
                        solution = new MathParserExpression(ans);
                    }
                    else if (hold.Type.Contains("Matrix"))
                    {
                        Matrix ans = -1 * hold.Data;
                        solution = new MathParserExpression(ans);
                    }
                }
                else
                {
                    solution = theData[Expressions[0].Trim("-".ToCharArray())];
                }
            }

            else
            {
                if (Unit_Intake_Command())
                {
                    if (Order())
                    {
                        if (Division())
                        {
                            if (Multiplication())
                            {
                                if (Addition())
                                {
                                    solution = new MathParserExpression(theData [Expressions [0].Trim("-".ToCharArray())]);
                                }
                            }
                        }
                    }
                }
            }
        }
Пример #4
0
        }          // The function deals with the multiplication operations.

        bool Division()
        {
            bool done = true;

            if (Expressions.Contains("÷") || Expressions.Contains("/"))
            {
                for (int c = Expressions.Count - 1; c >= 0; c--)
                {
                    string Element = Expressions [c];
                    if (Element == "/" || Element == "÷")
                    {
                        MathParserExpression lhs = theData [Expressions [c - 1].Trim("-".ToCharArray())];
                        MathParserExpression rhs = theData [Expressions [c + 1].Trim("-".ToCharArray())];

                        if (lhs.Type.Contains("Number") && rhs.Type.Contains("Number"))
                        {
                            Number l   = lhs.Data;
                            Number r   = rhs.Data;
                            Number ans = new Number((double)l.Data /
                                                    (double)r.Data);
                            string name = autoNamer();
                            theData.Add(name, new MathParserExpression(ans));
                            Expressions [c - 1] = name;
                        }
                        else if (lhs.Type.Contains("Matrix") && rhs.Type.Contains("Number"))
                        {
                            Matrix l    = lhs.Data;
                            Number r    = rhs.Data;
                            Matrix ans  = l / ((double)r.Data);
                            string name = autoNamer();
                            theData.Add(name, new MathParserExpression(ans));
                            Expressions [c - 1] = name;
                        }
                        else
                        {
                            Processed = false;
                            done      = false;
                            throw new Exception("Invalid Division.");
                        }

                        Expressions.RemoveRange(c, 2);
                        c = Expressions.Count - 1;
                    }
                }
            }
            return(done);
        }
Пример #5
0
        private void Interpret()
        {
            if (isOverdrive(givenString))
            {
                MathParserOverdrive mpo = new MathParserOverdrive(givenString.TrimStart(new char[] { '@' }));
                mpo.Solve();
                if (isProcessed())
                {
                    Solution  = mpo.getSolution();
                    Processed = true;
                    return;
                }
            }

            else if (!givenString.Contains("="))
            {
                NonEquation solve = new NonEquation(givenString);
                solve.History = History;
                solve.Solve();
                if (solve.isProcessed())
                {
                    Solution = solve.getSolution();
                }
                else
                {
                    Processed = false;
                }
            }
            else
            {
                Equation sol = new Equation(givenString);
                sol.theHistory = History;
                sol.Solve();
                if (sol.isProcessed())
                {
                    Solution = sol.getSolution();
                }
                else
                {
                    Processed = false;
                }
            }
        }
Пример #6
0
        void Process(string command, string[] args, ref MathParserExpression theSolution)
        {
            MathParser.Solver sol = makeMathParserSolverObject();
            sol.SaveHistory();

            if (command == "eval")
            {
                foreach (var x in args)
                {
                    sol.setMathExpression(x);
                    sol.Solve();
                }
                theSolution = sol.getSolution();
                return;
            }


            throw new MathParserException("Keyword does not exist");
        }
Пример #7
0
        public void Solve()
        {
            if (Expressions.Count == 1)
            {
                if (Expressions[0].Contains("-"))
                {
                    MathParserExpression hold = theData[Expressions[0].Trim("-".ToCharArray())];
                    if (hold.Type.Contains("Number"))
                    {
                        Number ans = new Number((double)-1) * hold.Data;
                        solution = new MathParserExpression(ans);
                    }
                    else if (hold.Type.Contains("Matrix"))
                    {
                        Matrix ans = -1 * hold.Data;
                        solution = new MathParserExpression(ans);
                    }
                }
                else
                {
                    solution = theData[Expressions[0].Trim("-".ToCharArray())];
                }
            }

            else
            {
                if (Division())
                {
                    if (Multiplication())
                    {
                        if (Addition())
                        {
                            solution = new MathParserExpression(theData [Expressions [0].Trim("-".ToCharArray())]);
                        }
                    }
                }
            }
        }
Пример #8
0
        public void Solve()
        {
            string testString = givenExpression.Replace("=", "");
            int    testLenght = testString.Length;

            if (givenExpression.Length - testLenght <= 1)                 // Declaration statement. a = 2+2
            {
                string Name, Exp;
                {
                    string[] parts = givenExpression.Split('=');
                    Name = parts [0].Trim();
                    Exp  = parts [1].Trim();
                }
                NonEquation sol = new NonEquation(Exp);
                sol.History = theHistory;
                sol.Solve();
                BasicOperators = sol.theBasicOperatorsString;
                string numbers = "0123456789.";
                if (sol.ConstantName.Contains(Name) || sol.theKeyWordsList.Contains(Name) || Checker.ifContainOperation(Name, BasicOperators) || numbers.Contains(new string(Name[0], 1)) || string.IsNullOrEmpty(Name) || string.IsNullOrWhiteSpace(Name))
                {
                    Processed = false;
                    throw new MathParserException($"Invalid declaration. '{Name}'.");
                }
                if (sol.isProcessed())
                {
                    solution     = new MathParserExpression(sol.getSolution());
                    solution.Tag = Name.Trim();
                    //if (string.IsNullOrEmpty (solution.Data.Tag) || string.IsNullOrWhiteSpace (solution.Data.Tag)) {
                    solution.setEntireTag(Name.Trim());
                }
                else
                {
                    Processed = false;
                    throw new MathParserException("Unsolveable Input.");
                }
            }
        }           // end solve().
Пример #9
0
        }                   // end Operator syncor functions.

        public void Solve() // the method deals with the prelimanry making of the Expression Understading.
        {
            OperatorSync(); // Syncs the operators to be considered.
            SyncKeyWord();
            ConstantSync();
            if (givenExpression.Contains("(") || givenExpression.Contains(")"))
            {
                Only_Number_And_Operator_List_Maker();
                if (!(ExpressionElements[ExpressionElements.Count - 1] == ")") && theBasicOperatorsString.Contains(ExpressionElements[ExpressionElements.Count - 1]))
                {
                    Processed = false;
                    throw new MathParserException($"" +
                                                  "Invalid operator entry. No basic operator ({theBasicOperatorList.ToString()}) can be at the end of the expression.");
                }
                the_Data_List_Maker();
                OperatorHandler
                    oh = new OperatorHandler(ref ExpressionElements);
                oh.BasicOperatorsString = theBasicOperatorsString;
                oh.Process();
                if (!oh.isCorrectOperatorSequence())
                {
                    Processed = false;
                    throw new MathParserException("Bad operator sequence.");
                }

                // Balancing brakkets.
                if (ExpressionElements.Contains("(") || ExpressionElements.Contains("-(") || ExpressionElements.Contains(")"))
                {
                    int nsb = 0;
                    int neb = 0;
                    foreach (string s in ExpressionElements)
                    {
                        if (s.Contains("("))
                        {
                            nsb++;
                        }
                        if (s.Contains(")"))
                        {
                            neb++;
                        }
                    }
                    if (nsb > neb)
                    {
                        for (int c = 0; c < (nsb - neb); c++)
                        {
                            ExpressionElements.Add(")");
                        }
                    }
                    if (neb > nsb)
                    {
                        List <string> dumy = new List <string>();
                        for (int c = 0; c < (-nsb + neb); c++)
                        {
                            dumy.Add("(");
                        }
                        foreach (string x in ExpressionElements)
                        {
                            dumy.Add(x);
                        }
                        ExpressionElements = dumy;
                    }
                }
                // end balancing brakkets


                MathParser.BraketSolver sol = new BraketSolver(ExpressionElements, theData);
                if (sol.isProcessed())
                {
                    Solution = sol.getSolution();
                }
                else
                {
                    Processed = false;
                    throw new MathParserException("Error");
                }
            }
            else if ((givenExpression.Contains("[") && !givenExpression.Contains("]")) || (!givenExpression.Contains("[") && givenExpression.Contains(("]"))))               // if the expession string contans an invalid matrix formate.
            {
                throw (new MathParserException("Invalid Matrix Formate. Entered."));
            }
            else               // if the expression string contain only operators and numbers.
            {
                Only_Number_And_Operator_List_Maker();
                if (theBasicOperatorsString.Contains(ExpressionElements[ExpressionElements.Count - 1]))
                {
                    Processed = false;

                    throw new MathParserException($"Invalid operator entry. No basic operator ({theBasicOperatorList.ToString()}) can be at the end of the expression.");
                }
                else
                {
                    the_Data_List_Maker();
                    OperatorHandler oh = new OperatorHandler(ref ExpressionElements);
                    oh.BasicOperatorsString = theBasicOperatorsString;
                    oh.Process();

                    if (!oh.isCorrectOperatorSequence())
                    {
                        Processed = false;
                        throw new MathParserException("Bad operator sequence.");
                    }
                    else
                    {
                        DMASSolver DS = new DMASSolver(ExpressionElements, theData);
                        DS.Solve();
                        if (DS.isProcessed())
                        {
                            Solution = new MathParserExpression(DS.getSolution());
                        }
                        else
                        {
                            Processed = false;
                        }
                    }
                }    // end
            }        // end
        }            // end solve
Пример #10
0
        public MathParserExpression getSolution()
        {
            MathParserExpression result = new MathParserExpression(theMatrix);

            return(result);
        }
Пример #11
0
        // End matrix syntax checker.

        public void Parse()            // Parse method.
        {
            bool proceed = MatrixSyntaxChecker();

            if (!proceed)
            {
                Processed = false;
            }
            else
            {
                string matExpression = givenExpression.TrimStart(FlagStart.ToCharArray());
                matExpression = matExpression.TrimEnd(FlagEnd.ToCharArray());
                matExpression = matExpression.Trim();
                List <string> theStringRows = new List <string>(matExpression.Split(FlagRowSeperation.ToCharArray()));
                theStringRows.Remove("");
                int rows = theStringRows.Count;
                int cols = 0;
                List <List <string> > theMatrixElements = new List <List <string> >();
                foreach (string row in theStringRows)
                {
                    List <string> dumyList = new List <string>(row.Trim().Split(FlagElementSeperation.ToCharArray()));
                    dumyList.Remove("");
                    if (dumyList.Count > cols)
                    {
                        cols = dumyList.Count;
                    }
                    theMatrixElements.Add(dumyList);
                }
                theMatrix = new Matrix(rows, cols, "");
                int irow = 0, icol = 0;
                foreach (List <string> row in theMatrixElements)
                {
                    icol = 0;
                    foreach (string element in row)
                    {
                        if (OnParse != null)
                        {
                            dynamic mElement = OnParse(element.Trim(), ref Processed);
                            theMatrix[irow, icol] = mElement;
                        }
                        else if (staticOnParse != null)
                        {
                            dynamic mElement = staticOnParse(element.Trim(), ref Processed);
                            theMatrix[irow, icol] = mElement;
                        }

                        else
                        {
                            NonEquation sol = new NonEquation(element.Trim());
                            sol.History = Checker.History;
                            sol.Solve();
                            Number a;
                            if (sol.isProcessed())
                            {
                                MathParserExpression ans = sol.getSolution();
                                a = ans.Data;
                            }
                            else
                            {
                                Processed = false;
                                throw new MathParserException("Invalid Entry.");
                            }
                            theMatrix[irow, icol] = (double)a.Data;
                            Processed             = true;
                        }
                        if (!Processed)
                        {
                            Processed = false;
                            break;
                        }
                        icol++;
                    }
                    if (!Processed)
                    {
                        Processed = false;
                        break;
                    }
                    irow++;
                }
                if (!Processed)
                {
                    theMatrix = new Matrix(1, 1);
                }
            }
        }
Пример #12
0
        bool Addition()
        {
            bool done = true;

            if (Expressions.Contains("+"))
            {
                for (int c = Expressions.Count - 1; c >= 0; c--)
                {
                    if (Expressions[c] == "+")
                    {
                        MathParserExpression rhs = theData[Expressions[c - 1].Trim("-".ToCharArray())];
                        MathParserExpression lhs = theData[Expressions[c + 1].Trim("-".ToCharArray())];

                        if (rhs.Type == lhs.Type)
                        {
                            if (rhs.Type.Contains("Number"))
                            {
                                if (Expressions [c - 1].Contains("-"))
                                {
                                    rhs = new MathParserExpression(rhs.Data * new Number(-1));
                                    Expressions [c - 1].Replace("-", "");
                                }
                                if (Expressions [c + 1].Contains("-"))
                                {
                                    lhs = new MathParserExpression(lhs.Data * new Number(-1));
                                    Expressions [c + 1].Replace("-", "");
                                }

                                Number ans  = rhs.Data + lhs.Data;
                                string name = autoNamer();
                                Expressions [c - 1] = name;
                                theData.Add(name, new MathParserExpression(ans));
                            }
                            else if (rhs.Type.Contains("Matrix"))
                            {
                                if (Expressions [c - 1].Contains("-"))
                                {
                                    rhs = new MathParserExpression((Matrix)rhs.Data * -1);
                                    Expressions [c - 1].Replace("-", "");
                                }
                                if (Expressions [c + 1].Contains("-"))
                                {
                                    lhs = new MathParserExpression((Matrix)lhs.Data * -1);
                                    Expressions [c + 1].Replace("-", "");
                                }

                                Matrix mrhs = rhs.Data;
                                Matrix mlhs = lhs.Data;

                                if (mrhs.Rows == mlhs.Rows && mrhs.Columns == mlhs.Columns)
                                {
                                    Matrix ans  = rhs.Data + lhs.Data;
                                    string name = autoNamer();
                                    Expressions [c - 1] = name;
                                    theData.Add(name, new MathParserExpression(ans));
                                }
                                else
                                {
                                    Processed = false;
                                    done      = false;
                                    throw new Exception("Invalid row and column matrix addition.");
                                }
                            }
                        }
                        else
                        {
                            Processed = false;
                            done      = false;
                            throw new Exception("Invalid data types addition.");
                        }
                        Expressions.RemoveRange(c, 2);
                        c = Expressions.Count - 1;
                    }              // end if
                }                  // end for loop.
            }
            return(done);
        }            // The function deals with the addition operations.
Пример #13
0
        }            // The function deals with the addition operations.

        bool Multiplication()
        {
            bool   done           = true;
            string multiply_cross = new string (((char)215), 1);

            if (Expressions.Contains("*") || Expressions.Contains(multiply_cross))
            {
                for (int c = Expressions.Count - 1; c >= 0; c--)
                {
                    if (Expressions[c] == "*" || Expressions[c] == multiply_cross)
                    {
                        MathParserExpression rhs = theData[Expressions[c - 1]];
                        MathParserExpression lhs = theData[Expressions[c + 1]];

                        if (rhs.Type == lhs.Type)
                        {
                            if (rhs.Type.Contains("Number"))
                            {
                                if (Expressions [c - 1].Contains("-"))
                                {
                                    rhs = new MathParserExpression(rhs.Data * new Number(-1));
                                    Expressions [c - 1].Replace("-", "");
                                }
                                if (Expressions [c + 1].Contains("-"))
                                {
                                    lhs = new MathParserExpression(lhs.Data * new Number(-1));
                                    Expressions [c + 1].Replace("-", "");
                                }

                                Number ans  = rhs.Data * lhs.Data;
                                string name = autoNamer();
                                Expressions [c - 1] = name;
                                theData.Add(name, new MathParserExpression(ans));
                            }
                            else if (rhs.Type.Contains("Matrix"))
                            {
                                if (Expressions [c - 1].Contains("-"))
                                {
                                    rhs = new MathParserExpression(rhs.Data * -1);
                                    Expressions [c - 1].Replace("-", "");
                                }
                                if (Expressions [c + 1].Contains("-"))
                                {
                                    lhs = new MathParserExpression(lhs.Data * -1);
                                    Expressions [c + 1].Replace("-", "");
                                }

                                Matrix mrhs = rhs.Data;
                                Matrix mlhs = lhs.Data;

                                if (mrhs.Rows == mlhs.Columns)
                                {
                                    Matrix ans  = rhs.Data * lhs.Data;
                                    string name = autoNamer();
                                    Expressions [c - 1] = name;
                                    theData.Add(name, new MathParserExpression(ans));
                                }
                                else
                                {
                                    Processed = false;
                                    done      = false;
                                    throw new Exception("Invalid matrix multiplication.");
                                }
                            }
                        }
                        else if (lhs.Type.Contains("Number") && rhs.Type.Contains("Matrix"))
                        {
                            Number l = lhs.Data;
                            Matrix r = rhs.Data;

                            Matrix ans  = (double)l.Data * r;
                            string name = autoNamer();
                            Expressions [c - 1] = name;
                            theData.Add(name, new MathParserExpression(ans));
                        }
                        else if (rhs.Type.Contains("Number") && lhs.Type.Contains("Matrix"))
                        {
                            Number r = rhs.Data;
                            Matrix l = lhs.Data;

                            Matrix ans  = l * (double)r.Data;
                            string name = autoNamer();
                            Expressions [c - 1] = name;
                            theData.Add(name, new MathParserExpression(ans));
                        }
                        else
                        {
                            Processed = false;
                            done      = false;
                            throw new Exception("Not a valid multiplication.");
                        }
                        Expressions.RemoveRange(c, 2);
                        c = Expressions.Count - 1;
                    }              // end if
                }                  // end for loop.
            }
            return(done);
        }          // The function deals with the multiplication operations.
Пример #14
0
        bool Order()
        {
            bool done = true;

            if (Expressions.Contains("^"))
            {
                for (int c = Expressions.Count - 1; c >= 0; c--)
                {
                    string Element = Expressions [c];
                    if (Element == "^")
                    {
                        MathParserExpression lhs = theData [Expressions [c - 1].Trim("-".ToCharArray())];
                        MathParserExpression rhs = theData [Expressions [c + 1].Trim("-".ToCharArray())];

                        if (lhs.Type.Contains("Number") && rhs.Type.Contains("Number"))
                        {
                            if (lhs.Data.Data == (double)Math.E)
                            {
                                if (Expressions [c + 1].Contains("-"))
                                {
                                    rhs = new MathParserExpression(rhs.Data * new Number(-1));
                                    Expressions [c + 1].Replace("-", "");
                                }

                                Number ans = new Number(Math.Exp((double)((Number)rhs.Data).Data));

                                if (Expressions [c - 1].Contains("-"))
                                {
                                    ans = ans * new Number(-1);
                                }

                                string name = autoNamer();
                                Expressions [c - 1] = name;
                                theData.Add(name, new MathParserExpression(ans));
                            }
                            else
                            {
                                if (Expressions [c + 1].Contains("-"))
                                {
                                    rhs = new MathParserExpression(rhs.Data * new Number(-1));
                                    Expressions [c + 1].Replace("-", "");
                                }

                                Number ans = new Number(Math.Pow((double)((Number)lhs.Data).Data, (double)((Number)rhs.Data).Data));

                                if (Expressions [c - 1].Contains("-"))
                                {
                                    ans = ans * new Number(-1);
                                }

                                string name = autoNamer();
                                Expressions [c - 1] = name;
                                theData.Add(name, new MathParserExpression(ans));
                            }
                        }
                        else
                        {
                            if (onOrder != null && onOrder(lhs, rhs, theData, Expressions, autoNamer(), c))
                            {
                            }
                            else
                            {
                                Processed = false;
                                done      = false;
                                throw new MathParserException("Invalid base and exponent.");
                            }
                        }
                        Expressions.RemoveRange(c, 2);
                        c = Expressions.Count;
                    }
                }
            }
            return(done);
        }                          // The function deals with the Order/power operation.
Пример #15
0
        bool Division()
        {
            bool done = true;

            if (Expressions.Contains("÷") || Expressions.Contains("/"))
            {
                for (int c = 0; c < Expressions.Count; c++)
                {
                    string Element = Expressions [c];
                    if (Element == "/" || Element == "÷")
                    {
                        MathParserExpression lhs = theData [Expressions [c - 1].Trim("-".ToCharArray())];
                        MathParserExpression rhs = theData [Expressions [c + 1].Trim("-".ToCharArray())];

                        if (lhs.Type.Contains("Number") && rhs.Type.Contains("Number"))
                        {
                            if (Expressions [c + 1].Contains("-"))
                            {
                                rhs = new MathParserExpression(rhs.Data * new Number(-1));
                                Expressions [c + 1].Replace("-", "");
                            }
                            if (Expressions [c - 1].Contains("-"))
                            {
                                lhs = new MathParserExpression(lhs.Data * new Number(-1));
                                Expressions [c - 1].Replace("-", "");
                            }

                            Number l   = lhs.Data;
                            Number r   = rhs.Data;
                            Number ans = new Number((double)l.Data /
                                                    (double)r.Data);
                            string name = autoNamer();
                            theData.Add(name, new MathParserExpression(ans));
                            Expressions [c - 1] = name;
                        }
                        else if (lhs.Type.Contains("Matrix") && rhs.Type.Contains("Number"))
                        {
                            if (Expressions [c + 1].Contains("-"))
                            {
                                rhs = new MathParserExpression(rhs.Data * new Number(-1));
                                Expressions [c + 1].Replace("-", "");
                            }
                            if (Expressions [c - 1].Contains("-"))
                            {
                                lhs = new MathParserExpression(lhs.Data * -1);
                                Expressions [c - 1].Replace("-", "");
                            }


                            Matrix l    = lhs.Data;
                            Number r    = rhs.Data;
                            Matrix ans  = l / ((double)r.Data);
                            string name = autoNamer();
                            theData.Add(name, new MathParserExpression(ans));
                            Expressions [c - 1] = name;
                        }
                        else
                        {
                            if (onDivision != null && onDivision(lhs, rhs, theData, Expressions, autoNamer(), c))
                            {
                            }
                            else
                            {
                                Processed = false;
                                done      = false;
                                throw new MathParserException("Invalid Division.");
                            }
                        }

                        Expressions.RemoveRange(c, 2);
                        c = 0;
                    }
                }
            }
            return(done);
        }          // The function deals with the division operation.
Пример #16
0
 void Solve()
 {
     if (!(ExpressionElements.Contains("(") || ExpressionElements.Contains(")")))
     {
         DMASSolver sol = new DMASSolver(ExpressionElements, theData);
         sol.Solve();
         if (sol.isProcessed())
         {
             solution = sol.getSolution();
         }
         else
         {
             Processed = false;
             throw new MathParserException("The expression could not be solved");
         }
     }
     else
     {
         bool          intake        = false;
         int           bstart        = 0;
         int           belements     = 1;
         List <string> theBraketList = new List <string>();
         for (int c = 0; c < ExpressionElements.Count; c++)
         {
             string Element = ExpressionElements [c];
             if (!ExpressionElements.Contains("(") && !ExpressionElements.Contains("-("))
             {
                 break;
             }
             if (Element == ")")
             {
                 intake = false;
                 DMASSolver sol = new DMASSolver(theBraketList, theData);
                 sol.Solve();
                 if (sol.isProcessed())
                 {
                     MathParserExpression ANS = sol.getSolution();
                     if (ExpressionElements [bstart].Contains("-"))
                     {
                         if (ANS.Type.Contains("Number"))
                         {
                             Number g = ANS.Data;
                             g   = g * new Number((double)-1);
                             ANS = new MathParserExpression(g);
                         }
                         else if (ANS.Type.Contains("Matrix"))
                         {
                             Matrix g = ANS.Data;
                             g   = g * -1;
                             ANS = new MathParserExpression(g);
                         }
                     }
                     string name = autoNamer();
                     theData.Add(name, ANS);
                     ExpressionElements [bstart] = name;
                     ExpressionElements.RemoveRange(bstart + 1, belements + 1);
                     c = -1;
                 }
                 else
                 {
                     Processed = false;
                     throw new MathParserException("Error");
                 }
                 belements = 0;
             }
             if (intake)
             {
                 theBraketList.Add(Element);
                 belements++;
             }
             if (Element.Contains("("))
             {
                 theBraketList = new List <string> ();
                 intake        = true;
                 bstart        = c;
                 belements     = 0;
             }
         }
         BraketSolver bsol = new BraketSolver(ExpressionElements, theData);
         if (bsol.isProcessed())
         {
             solution = bsol.getSolution();
         }
         else
         {
             Processed = false;
             throw new MathParserException("Error");
         }
     }
 }