Exemple #1
0
        public static IEquationSolutions Solve(Equation equation, string variable)
        {
            EquationClassifier.Classify(equation, variable);
            var sols = Solve(variable, equation.Left, equation.Classification);

            var newSols = new EquationSolutions();

            RecursiveSolve(variable, sols, newSols);

            return(newSols);
        }
Exemple #2
0
        public void Linear_Variables_3()
        {
            //Arrange
            var text       = "y*y*x - 4*y + 5";
            var expression = ExpressionBuilder.BuildFlat(RPNParser.Parse(text).Output).Execute();
            var equation   = new Equation(text, expression, null);

            //Act
            var sut = EquationClassifier.Classify(equation, "x");

            //Assert
            Assert.AreEqual(EquationTypes.Linear, sut.Classification.EquationType);
        }
Exemple #3
0
        public void Linear_NumbersOnly_Contract()
        {
            //Arrange
            var text       = "2*x^2 + 3*x - 2*x^2";
            var expression = ExpressionBuilder.BuildFlat(RPNParser.Parse(text).Output).Execute();
            var equation   = new Equation(text, expression, null);

            //Act
            var sut = EquationClassifier.Classify(equation, "x");

            //Assert
            Assert.AreEqual(EquationTypes.Linear, sut.Classification.EquationType);
        }
        public void Quadratic_NumbersOnly()
        {
            //Arrange
            //-2*x^2 + 5*x - 1
            var text       = "2*x + 2*x^2 - 2 + 3*x - 4*x^2 + 1";
            var expression = ExpressionBuilder.BuildFlat(RPNParser.Parse(text).Output).Execute();
            var equation   = new Equation(text, expression, null);

            //Act
            var sut = EquationClassifier.Classify(equation, "x");

            //Assert
            Assert.AreEqual(EquationTypes.Quadratic, sut.Classification.EquationType);
        }
Exemple #5
0
        private static void RecursiveSolve(string variable, IEquationSolutions sols, IEquationSolutions newSols)
        {
            var keys = sols.Solutions.Keys.ToList();

            foreach (var k in keys)
            {
                if (k != variable)
                {
                    var s = sols.Solutions[k];
                    foreach (var e in s.Item2)
                    {
                        var tmpEq = new FlatAddExpression();
                        tmpEq.Add(s.Item1);
                        tmpEq.Add(new UnaryExpression(Enums.Operators.OperatorTypes.Sign, e));
                        var emp = tmpEq.Execute();

                        var c   = EquationClassifier.Classify(emp, variable);
                        var tmp = Solve(variable, tmpEq, c);
                        foreach (var ns in tmp.Solutions)
                        {
                            RecursiveSolve(variable, tmp, newSols);
                        }
                    }
                }
                else
                {
                    var s = sols.Solutions[k];
                    if (!newSols.Solutions.ContainsKey(variable))
                    {
                        newSols.Solutions.Add(variable, new Tuple <IExpression, List <IExpression> >(s.Item1, new List <IExpression>()));
                    }

                    newSols.Solutions[variable].Item2.AddRange(s.Item2);
                }
            }
        }