Solvers¶
By solving one tries to find a mathematical object that meets certain criteria. This chapter documents the functions that are available to help find solutions to specific types of problems.
Symbolic Solvers¶

Solve
(eq, var)¶ solve an equation
Param eq: equation to solve Param var: variable to solve for This command tries to solve an equation. If {eq} does not contain the {==} operator, it is assumed that the user wants to solve $eq == 0$. The result is a list of equations of the form {var == value}, each representing a solution of the given equation. The {Where} operator can be used to substitute this solution in another expression. If the given equation {eq} does not have any solutions, or if {Solve} is unable to find any, then an empty list is returned. The current implementation is far from perfect. In particular, the user should keep the following points in mind:

OldSolve
(eq, var)¶ old version of {Solve}
Param eq: single identity equation Param var: single variable Param eqlist: list of identity equations Param varlist: list of variables This is an older version of {Solve}. It is retained for two reasons. The first one is philosophical: it is good to have multiple algorithms available. The second reason is more practical: the newer version cannot handle systems of equations, but {OldSolve} can. This command tries to solve one or more equations. Use the first form to solve a single equation and the second one for systems of equations. The first calling sequence solves the equation “eq” for the variable “var”. Use the {==} operator to form the equation. The value of “var” which satisfies the equation, is returned. Note that only one solution is found and returned. To solve a system of equations, the second form should be used. It solves the system of equations contained in the list “eqlist” for the variables appearing in the list “varlist”. A list of results is returned, and each result is a list containing the values of the variables in “varlist”. Again, at most a single solution is returned. The task of solving a single equation is simply delegated to {SuchThat}. Multiple equations are solved recursively: firstly, an equation is sought in which one of the variables occurs exactly once; then this equation is solved with {SuchThat}; and finally the solution is substituted in the other equations by {Eliminate} decreasing the number of equations by one. This suffices for all linear equations and a large group of simple nonlinear equations.
Example: In> OldSolve(a+x*y==z,x) Out> (za)/y; In> OldSolve({a*x+y==0,x+z==0},{x,y}) Out> {{z,z*a}}; This means that "x = (za)/y" is a solution of the first equation and that "x = z", "y = z*a" is a solution of the systems of equations in the second command. An example which {OldSolve} cannot solve: In> OldSolve({x^2x == y^2y,x^2x == y^3+y},{x,y}); Out> {};
See also
Solve()
,SuchThat()
,Eliminate()
,PSolve()
,==()

SuchThat
(expr, var)¶ special purpose solver
Param expr: expression to make zero Param var: variable (or subexpression) to solve for This functions tries to find a value of the variable “var” which makes the expression “expr” zero. It is also possible to pass a subexpression as “var”, in which case {SuchThat} will try to solve for that subexpression. Basically, only expressions in which “var” occurs only once are handled; in fact, {SuchThat} may even give wrong results if the variables occurs more than once. This is a consequence of the implementation, which repeatedly applies the inverse of the top function until the variable “var” is reached.
Example: In> SuchThat(a+b*x, x) Out> (a)/b; In> SuchThat(Cos(a)+Cos(b)^2, Cos(b)) Out> Cos(a)^(1/2); In> A:=Expand(a*x+b*x+c, x) Out> (a+b)*x+c; In> SuchThat(A, x) Out> (c)/(a+b);
See also

Eliminate
(var, value, expr)¶ substitute and simplify
Param var: variable (or subexpression) to substitute Param value: new value of “var” Param expr: expression in which the substitution should take place This function uses {Subst} to replace all instances of the variable (or subexpression) “var” in the expression “expr” with “value”, calls {Simplify} to simplify the resulting expression, and returns the result.
Example: In> Subst(Cos(b), c) (Sin(a)+Cos(b)^2/c) Out> Sin(a)+c^2/c; In> Eliminate(Cos(b), c, Sin(a)+Cos(b)^2/c) Out> Sin(a)+c;
See also

PSolve
(poly, var)¶ solve a polynomial equation
Param poly: a polynomial in “var” Param var: a variable This commands returns a list containing the roots of “poly”, considered as a polynomial in the variable “var”. If there is only one root, it is not returned as a oneentry list but just by itself. A double root occurs twice in the result, and similarly for roots of higher multiplicity. All polynomials of degree up to 4 are handled.
Example: In> PSolve(b*x+a,x) Out> a/b; In> PSolve(c*x^2+b*x+a,x) Out> {(Sqrt(b^24*c*a)b)/(2*c),((b+ Sqrt(b^24*c*a)))/(2*c)};

MatrixSolve
(A, b)¶ solve a system of equations
Param A: coefficient matrix Param b: row vector {MatrixSolve} solves the matrix equations {A*x = b} using Gaussian Elimination with Backward substitution. If your matrix is triangular or diagonal, it will be recognized as such and a faster algorithm will be used.
Example: In> A:={{2,4,2,2},{1,2,4,3},{3,3,8,2},{1,1,6,3}}; Out> {{2,4,2,2},{1,2,4,3},{3,3,8,2},{1,1,6,3}}; In> b:={4,5,7,7}; Out> {4,5,7,7}; In> MatrixSolve(A,b); Out> {1,2,3,4}; Numeric solvers
Numeric Solvers¶

Newton
(expr, var, initial, accuracy)¶ solve an equation numerically with Newton’s method
Param expr: an expression to find a zero for Param var: free variable to adjust to find a zero Param initial: initial value for “var” to use in the search Param accuracy: minimum required accuracy of the result Param min: minimum value for “var” to use in the search Param max: maximum value for “var” to use in the search This function tries to numerically find a zero of the expression {expr}, which should depend only on the variable {var}. It uses the value {initial} as an initial guess. The function will iterate using Newton’s method until it estimates that it has come within a distance {accuracy} of the correct solution, and then it will return its best guess. In particular, it may loop forever if the algorithm does not converge. When {min} and {max} are supplied, the Newton iteration takes them into account by returning {Fail} if it failed to find a root in the given range. Note this doesn’t mean there isn’t a root, just that this algorithm failed to find it due to the trial values going outside of the bounds.
Example: In> Newton(Sin(x),x,3,0.0001) Out> 3.1415926535; In> Newton(x^21,x,2,0.0001,5,5) Out> 1; In> Newton(x^2+1,x,2,0.0001,5,5) Out> Fail;
See also

FindRealRoots
(p)¶ find the real roots of a polynomial
Param p: a polynomial in {x} Return a list with the real roots of $ p $. It tries to find the realvalued roots, and thus requires numeric floating point calculations. The precision of the result can be improved by increasing the calculation precision.
Example: In> p:=Expand((x+3.1)^5*(x6.23)) Out> x^6+9.27*x^50.465*x^4300.793*x^3 1394.2188*x^22590.476405*x1783.5961073; In> FindRealRoots(p) Out> {3.1,6.23};
See also
SquareFree()
,NumRealRoots()
,MinimumBound()
,MaximumBound()
,Factor()

NumRealRoots
(p)¶ return the number of real roots of a polynomial
Param p: a polynomial in {x} Returns the number of real roots of a polynomial $ p $. The polynomial must use the variable {x} and no other variables.
Example: In> NumRealRoots(x^21) Out> 2; In> NumRealRoots(x^2+1) Out> 0;
See also
FindRealRoots()
,SquareFree()
,MinimumBound()
,MaximumBound()
,Factor()

MinimumBound
(p)¶ return lower bounds on the absolute values of real roots of a polynomial
Param p: a polynomial in $x$ Return minimum and maximum bounds for the absolute values of the real roots of a polynomial {p}. The polynomial has to be converted to one with rational coefficients first, and be made squarefree. The polynomial must use the variable {x}.
Example: In> p:=SquareFree(Rationalize((x3.1)*(x+6.23))) Out> (40000*x^2125200*x+772520)/870489; In> MinimumBound(p) Out> 5000000000/2275491039; In> N(%) Out> 2.1973279236; In> MaximumBound(p) Out> 10986639613/1250000000; In> N(%) Out> 8.7893116904;
See also