Equations and systems solver
collapse all in page
Syntax
S = solve(eqn,var)
S = solve(eqn,var,Name,Value)
Y = solve(eqns,vars)
Y = solve(eqns,vars,Name,Value)
[y1,...,yN] = solve(eqns,vars)
[y1,...,yN] = solve(eqns,vars,Name,Value)
[y1,...,yN,parameters,conditions]= solve(eqns,vars,'ReturnConditions',true)
Description
example
S = solve(eqn,var)
solves the equation eqn
for the variable var
. If you do not specify var
, the symvar function determines the variable to solve for. For example, solve(x + 1 == 2, x)
solves the equation x+1=2 for x.
example
S = solve(eqn,var,Name,Value)
uses additional options specified by one or more Name,Value
pair arguments.
example
Y = solve(eqns,vars)
solves the system of equations eqns
for the variables vars
and returns a structure that contains the solutions. If you do not specify vars
, solve
uses symvar to find the variables to solve for. In this case, the number of variables that symvar
finds is equal to the number of equations eqns
.
example
Y = solve(eqns,vars,Name,Value)
uses additional options specified by one or more Name,Value
pair arguments.
example
[y1,...,yN] = solve(eqns,vars)
solves the system of equations eqns
for the variables vars
. The solutions are assigned to the variables y1,...,yN
. If you do not specify the variables, solve
uses symvar
to find the variables to solve for. In this case, the number of variables that symvar
finds is equal to the number of output arguments N
.
[y1,...,yN] = solve(eqns,vars,Name,Value)
uses additional options specified by one or more Name,Value
pair arguments.
example
[y1,...,yN,parameters,conditions]= solve(eqns,vars,'ReturnConditions',true)
returns the additional arguments parameters
and conditions
that specify the parameters in the solution and the conditions on the solution.
Examples
collapse all
Solve Quadratic Equation
Open Live Script
Solve the quadratic equation without specifying a variable to solve for. solve
chooses x
to return the solution.
syms a b c xeqn = a*x^2 + b*x + c == 0
eqn =
S = solve(eqn)
S =
Specify the variable to solve for and solve the quadratic equation for a
.
Sa = solve(eqn,a)
Sa =
Solve Polynomial and Return Real Solutions
Open Live Script
Solve a fifth-degree polynomial. It has five solutions.
syms xeqn = x^5 == 3125;S = solve(eqn,x)
S =
Return only real solutions by setting 'Real'
option to true
. The only real solutions of this equation is 5
.
S = solve(eqn,x,'Real',true)
S =
Numerically Solve Equations
Open Live Script
When solve
cannot symbolically solve an equation, it tries to find a numeric solution using vpasolve
. The vpasolve
function returns the first solution found.
Try solving the following equation. solve
returns a numeric solution because it cannot find a symbolic solution.
syms xeqn = sin(x) == x^2 - 1;S = solve(eqn,x)
Warning: Unable to solve symbolically. Returning a numeric solution using <a href="matlab:web(fullfile(docroot, 'symbolic/vpasolve.html'))">vpasolve</a>.
S =
Plot the left and the right sides of the equation. Observe that the equation also has a positive solution.
fplot([lhs(eqn) rhs(eqn)], [-2 2])
Find the other solution by directly calling the numeric solver vpasolve
and specifying the interval.
V = vpasolve(eqn,x,[0 2])
V =
Solve Multivariate Equations and Assign Outputs to Structure
Open Live Script
When solving for multiple variables, it can be more convenient to store the outputs in a structure array than in separate variables. The solve
function returns a structure when you specify a single output argument and multiple outputs exist.
Solve a system of equations to return the solutions in a structure array.
syms u veqns = [2*u + v == 0, u - v == 1];S = solve(eqns,[u v])
S = struct with fields: u: 1/3 v: -2/3
Access the solutions by addressing the elements of the structure.
ans =
S.v
ans =
Using a structure array allows you to conveniently substitute solutions into other expressions.
Use the subs
function to substitute the solutions S
into other expressions.
expr1 = u^2;e1 = subs(expr1,S)
e1 =
expr2 = 3*v + u;e2 = subs(expr2,S)
e2 =
If solve
returns an empty object, then no solutions exist.
eqns = [3*u+2, 3*u+1];S = solve(eqns,u)
S = Empty sym: 0-by-1
Solve Inequalities
Open Live Script
The solve
function can solve inequalities and return solutions that satisfy the inequalities. Solve the following inequalities.
Set 'ReturnConditions'
to true
to return any parameters in the solution and conditions on the solution.
syms x yeqn1 = x > 0;eqn2 = y > 0;eqn3 = x^2 + y^2 + x*y < 1;eqns = [eqn1 eqn2 eqn3];S = solve(eqns,[x y],'ReturnConditions',true);S.x
ans =
S.y
ans =
S.parameters
ans =
S.conditions
ans =
The parameters u
and v
do not exist in MATLAB® workspace and must be accessed using S.parameters
.
Check if the values u = 7/2
and v = 1/2
satisfy the condition using subs
and isAlways
.
condWithValues = subs(S.conditions, S.parameters, [7/2,1/2]);isAlways(condWithValues)
ans = logical 1
isAlways
returns logical 1 (true
) indicating that these values satisfy the condition. Substitute these parameter values into S.x
and S.y
to find a solution for x
and y
.
xSol = subs(S.x, S.parameters, [7/2,1/2])
xSol =
ySol = subs(S.y, S.parameters, [7/2,1/2])
ySol =
Solve Multivariate Equations and Assign Outputs to Variables
Open Live Script
Solve the system of equations.
When solving for more than one variable, the order in which you specify the variables defines the order in which the solver returns the solutions. Assign the solutions to variables solv
and solu
by specifying the variables explicitly. The solver returns an array of solutions for each variable.
syms u veqns = [2*u^2 + v^2 == 0, u - v == 1];vars = [v u];[solv, solu] = solve(eqns,vars)
solv =
solu =
Entries with the same index form the pair of solutions.
solutions = [solv solu]
solutions =
Use Parameters and Conditions to Refine Solution
Open Live Script
Return the complete solution of an equation with parameters and conditions of the solution by specifying 'ReturnConditions'
as true
.
Solve the equation . Provide two additional output variables for output arguments parameters
and conditions
.
syms xeqn = sin(x) == 0;[solx,parameters,conditions] = solve(eqn,x,'ReturnConditions',true)
solx =
parameters =
conditions =
The solution contains the parameter , where must be an integer. The variable does not exist in the MATLAB® workspace and must be accessed using parameters
.
Restrict the solution to . Find a valid value of for this restriction. Assume the condition, conditions
, and use solve
to find . Substitute the value of found into the solution for .
assume(conditions)restriction = [solx > 0, solx < 2*pi];solk = solve(restriction,parameters)
solk =
valx = subs(solx,parameters,solk)
valx =
Alternatively, determine the solution for by choosing a value of . Check if the value chosen satisfies the condition on using isAlways
.
Check if satisfies the condition on .
condk4 = subs(conditions,parameters,4);isAlways(condk4)
ans = logical 1
isAlways
returns logical 1(true
), meaning that 4 is a valid value for . Substitute with 4 to obtain a solution for . Use vpa
to obtain a numeric approximation.
valx = subs(solx,parameters,4)
valx =
vpa(valx)
ans =
Shorten Result with Simplification Rules
Open Live Script
Solve the equation .
By default, solve
does not apply simplifications that are not valid for all values of . In this case, the solver does not assume that is a positive real number, so it does not apply the logarithmic identity . As a result, solve
cannot solve the equation symbolically.
syms xeqn = exp(log(x)*log(3*x)) == 4;S = solve(eqn,x)
Warning: Unable to solve symbolically. Returning a numeric solution using <a href="matlab:web(fullfile(docroot, 'symbolic/vpasolve.html'))">vpasolve</a>.
S =
Set 'IgnoreAnalyticConstraints'
to true
to apply simplification rules that might allow solve
to find a solution. For details, see Algorithms.
S = solve(eqn,x,'IgnoreAnalyticConstraints',true)
S =
solve
applies simplifications that allow the solver to find a solution. The mathematical rules applied when performing simplifications are not always valid in general. In this example, the solver applies logarithmic identities with the assumption that is a positive real number. Therefore, the solutions found in this mode should be verified.
Ignore Assumptions on Variables
Open Live Script
The sym
and syms
functions let you set assumptions for symbolic variables.
Assume that the variable x
is positive.
syms x positive
When you solve an equation for a variable under assumptions, the solver only returns solutions consistent with the assumptions. Solve this equation for x
.
eqn = x^2 + 5*x - 6 == 0;S = solve(eqn,x)
S =
Allow solutions that do not satisfy the assumptions by setting 'IgnoreProperties'
to true
.
S = solve(eqn,x,'IgnoreProperties',true)
S =
For further computations, clear the assumption that you set on the variable x
by recreating it using syms
.
syms x
Solve Polynomial Equations of High Degree
Open Live Script
When you solve a polynomial equation, the solver might use root
to return the solutions. Solve a third-degree polynomial.
syms x aeqn = x^3 + x^2 + a == 0;solve(eqn, x)
ans =
Try to get an explicit solution for such equations by calling the solver with 'MaxDegree'
. The option specifies the maximum degree of polynomials for which the solver tries to return explicit solutions. The default value is 2
. Increasing this value, you can get explicit solutions for higher order polynomials.
Solve the same equations for explicit solutions by increasing the value of 'MaxDegree'
to 3
.
S = solve(eqn, x, 'MaxDegree', 3)
S =
Return One Solution
Open Live Script
Solve the equation .
Instead of returning an infinite set of periodic solutions, the solver picks three solutions that it considers to be the most practical.
syms xeqn = sin(x) + cos(2*x) == 1;S = solve(eqn,x)
S =
Choose only one solution by setting 'PrincipalValue'
to true
.
S1 = solve(eqn,x,'PrincipalValue',true)
S1 =
Input Arguments
collapse all
eqn
— Equation to solve
symbolic expression | symbolic equation
Equation to solve, specified as a symbolic expression or symbolic equation. The relation operator == defines symbolic equations. If eqn
is a symbolic expression (without the right side), the solver assumes that the right side is 0, and solves the equation eqn == 0
.
var
— Variable for which you solve equation
symbolic variable
Variable for which you solve an equation, specified as a symbolic variable. By default, solve
uses the variable determined by symvar.
eqns
— System of equations
symbolic expressions | symbolic equations
System of equations, specified as symbolic expressions or symbolic equations. If any elements of eqns
are symbolic expressions (without the right side), solve
equates the element to 0
.
vars
— Variables for which you solve an equation or system of equations
symbolic vector | symbolic matrix
Variables for which you solve an equation or system of equations, specified as a symbolic vector or symbolic matrix. By default, solve
uses the variables determined by symvar.
The order in which you specify these variables defines the order in which the solver returns the solutions.
Name-Value Arguments
Example: 'Real',true
specifies that the solver returns real solutions.
Real
— Flag for returning only real solutions
false
(default) | true
Flag for returning only real solutions, specified as the comma-separated pair consisting of 'Real'
and one of these values.
false | Return all solutions. |
true | Return only those solutions for which every subexpression of the original equation represents a real number. This option also assumes that all symbolic parameters of an equation represent real numbers. |
See Solve Polynomial and Return Real Solutions.
ReturnConditions
— Flag for returning parameters and conditions
false
(default) | true
Flag for returning parameters in solution and conditions under which the solution is true, specified as the comma-separated pair consisting of 'ReturnConditions'
and one of these values.
false | Do not return parameterized solutions and the conditions under which the solution holds. The solve function replaces parameters with appropriate values. |
true | Return the parameters in the solution and the conditions under which the solution holds. For a call with a single output variable, solve returns a structure with the fields parameters and conditions . For multiple output variables, solve assigns the parameters and conditions to the last two output variables. This behavior means that the number of output variables must be equal to the number of variables to solve for plus two. |
See Solve Inequalities.
Example: [v1, v2, params, conditions] = solve(sin(x) +y == 0,y^2 == 3,'ReturnConditions',true)
returns the parameters in params
and conditions in conditions
.
IgnoreAnalyticConstraints
— Simplification rules applied to expressions and equations
false
(default) | true
Simplification rules applied to expressions and equations, specified as the comma-separated pair consisting of 'IgnoreAnalyticConstraints'
and one of these values.
false | Use strict simplification rules. |
true | Apply purely algebraic simplifications to expressions and equations. Setting IgnoreAnalyticConstraints to true can give you simpler solutions, which could lead to results not generally valid. In other words, this option applies mathematical identities that are convenient, but the results might not hold for all possible values of the variables. In some cases, it also enables solve to solve equations and systems that cannot be solved otherwise. For details, see Algorithms. |
See Shorten Result with Simplification Rules.
IgnoreProperties
— Flag for returning solutions inconsistent with properties of variables
false
(default) | true
Flag for returning solutions inconsistent with the properties of variables, specified as the comma-separated pair consisting of 'IgnoreProperties'
and one of these values.
false | Do not include solutions inconsistent with the properties of variables. |
true | Include solutions inconsistent with the properties of variables. |
See Ignore Assumptions on Variables.
MaxDegree
— Maximum degree of polynomial equations for which solver uses explicit formulas
2
(default) | positive integer smaller than 5
Maximum degree of polynomial equations for which solver uses explicit formulas, specified as a positive integer smaller than 5. The solver does not use explicit formulas that involve radicals when solving polynomial equations of a degree larger than the specified value.
See Solve Polynomial Equations of High Degree.
PrincipalValue
— Flag for returning one solution
false
(default) | true
Flag for returning one solution, specified as the comma-separated pair consisting of 'PrincipalValue'
and one of these values.
false | Return all solutions. |
true | Return only one solution. If an equation or a system of equations does not have a solution, the solver returns an empty symbolic object. |
See Return One Solution.
Output Arguments
collapse all
S
— Solutions of equation
symbolic array
Solutions of an equation, returned as a symbolic array. The size of a symbolic array corresponds to the number of the solutions.
Y
— Solutions of system of equations
structure
Solutions of a system of equations, returned as a structure. The number of fields in the structure correspond to the number of independent variables in a system. If 'ReturnConditions' is set to true
, the solve
function returns two additional fields that contain the parameters in the solution, and the conditions under which the solution is true.
y1,...,yN
— Solutions of system of equations
symbolic variables
Solutions of a system of equations, returned as symbolic variables. The number of output variables or symbolic arrays must be equal to the number of independent variables in a system. If you explicitly specify independent variables vars, then the solver uses the same order to return the solutions. If you do not specify vars
, the toolbox sorts independent variables alphabetically, and then assigns the solutions for these variables to the output variables.
parameters
— Parameters in solution
vector of generated parameters
Parameters in a solution, returned as a vector of generated parameters. This output argument is only returned if ReturnConditions is true
. If a single output argument is provided, parameters
is returned as a field of a structure. If multiple output arguments are provided, parameters
is returned as the second-to-last output argument. The generated parameters do not appear in the MATLAB® workspace. They must be accessed using parameters
.
Example: [solx, params, conditions] = solve(sin(x) == 0, 'ReturnConditions', true)
returns the parameter k
in the argument params
.
conditions
— Conditions under which solutions are valid
vector of symbolic expressions
Conditions under which solutions are valid, returned as a vector of symbolic expressions. This output argument is only returned if ReturnConditions is true
. If a single output argument is provided, conditions
is returned as a field of a structure. If multiple output arguments are provided, conditions
is returned as the last output argument.
Example: [solx, params, conditions] = solve(sin(x) == 0, 'ReturnConditions', true)
returns the condition in(k, 'integer')
in conditions
. The solution in solx
is valid only under this condition.
Tips
If
solve
cannot find a solution and ReturnConditions isfalse
, thesolve
function internally calls the numeric solvervpasolve
that tries to find a numeric solution. For polynomial equations and systems without symbolic parameters, the numeric solver returns all solutions. For nonpolynomial equations and systems without symbolic parameters, the numeric solver returns only one solution (if a solution exists).If
solve
cannot find a solution andReturnConditions
istrue
,solve
returns an empty solution with a warning. If no solutions exist,solve
returns an empty solution without a warning.If the solution contains parameters and
ReturnConditions
istrue
,solve
returns the parameters in the solution and the conditions under which the solutions are true. IfReturnConditions
isfalse
, thesolve
function either chooses values of the parameters and returns the corresponding results, or returns parameterized solutions without choosing particular values. In the latter case,solve
also issues a warning indicating the values of parameters in the returned solutions.If a parameter does not appear in any condition, it means the parameter can take any complex value.
The output of
solve
can contain parameters from the input equations in addition to parameters introduced bysolve
.Parameters introduced by
solve
do not appear in the MATLAB workspace. They must be accessed using the output argument that contains them. Alternatively, to use the parameters in the MATLAB workspace usesyms
to initialize the parameter. For example, if the parameter isk
, usesyms k
.The variable names
parameters
andconditions
are not allowed as inputs tosolve
.To solve differential equations, use the dsolve function.
When solving a system of equations, always assign the result to output arguments. Output arguments let you access the values of the solutions of a system.
MaxDegree
only accepts positive integers smaller than 5 because, in general, there are no explicit expressions for the roots of polynomials of degrees higher than 4.The output variables y1,...,yN do not specify the variables for which
solve
solves equations or systems. Ify1,...,yN
are the variables that appear in eqns, then there is no guarantee thatsolve(eqns)
will assign the solutions toy1,...,yN
using the correct order. Thus, when you run[b,a] = solve(eqns)
, you might get the solutions fora
assigned tob
and vice versa.To ensure the order of the returned solutions, specify the variables vars. For example, the call
[b,a] = solve(eqns,b,a)
assigns the solutions fora
toa
and the solutions forb
tob
.
Algorithms
When you use IgnoreAnalyticConstraints
, the solver applies some of these rules to the expressions on both sides of an equation.
log(a) + log(b)=log(a·b) for all values of a and b. In particular, the following equality is valid for all values of a, b, and c:
(a·b)c=ac·bc.
log(ab)=b·log(a) for all values of a and b. In particular, the following equality is valid for all values of a, b, and c:
(ab)c=ab·c.
If f and g are standard mathematical functions and f(g(x))=x for all small positive numbers, f(g(x))=x is assumed to be valid for all complex values x. In particular:
log(ex)=x
asin(sin(x))=x, acos(cos(x))=x, atan(tan(x))=x
asinh(sinh(x))=x, acosh(cosh(x))=x, atanh(tanh(x))=x
Wk(x·ex)=x for all branch indices k of the Lambert W function.
The solver can multiply both sides of an equation by any expression except
0
.The solutions of polynomial equations must be complete.
Version History
Introduced before R2006a
expand all
R2018a: Support for character vectors has been removed
Support for character vector or string inputs has been removed. Instead, use syms to declare variables and replace inputs such as solve('2*x == 1','x')
with solve(2*x == 1,x)
.
See Also
Functions
- dsolve | isolate | linsolve | root | subs | symvar | vpasolve
Live Editor Tasks
- Solve Symbolic Equation
Topics
- Solve Algebraic Equations
- Solve System of Algebraic Equations
- Solve System of Linear Equations
- Solve Algebraic Equation Using Live Editor Task
- Select Numeric or Symbolic Solver
- Troubleshoot Equation Solutions from solve Function
External Websites
- Beam Bending and Deflection (MathWorks Teaching Resources)
Commande MATLAB
Vous avez cliqué sur un lien qui correspond à cette commande MATLAB:
Pour exécuter la commande, saisissez-la dans la fenêtre de commande de MATLAB. Les navigateurs web ne supportent pas les commandes MATLAB.
Select a Web Site
Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .
You can also select a web site from the following list:
Americas
- América Latina (Español)
- Canada (English)
- United States (English)
Europe
- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)
- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- Deutsch
- English
- Français
- United Kingdom (English)
Contact your local office