Algebraic simplification

`simplify(`

performs
algebraic simplification of `S`

)`S`

. If `S`

is
a symbolic vector or matrix, this function simplifies each element
of `S`

.

`simplify(`

performs
algebraic simplification of `S`

,`Name,Value`

)`S`

using additional
options specified by one or more `Name,Value`

pair
arguments.

Simplify these symbolic expressions:

syms x a b c simplify(sin(x)^2 + cos(x)^2) simplify(exp(c*log(sqrt(a+b))))

ans = 1 ans = (a + b)^(c/2)

Call `simplify`

for this symbolic
matrix. When the input argument is a vector or matrix, `simplify`

tries
to find a simpler form of each element of the vector or matrix.

syms x simplify([(x^2 + 5*x + 6)/(x + 2),... sin(x)*sin(2*x) + cos(x)*cos(2*x); (exp(-x*i)*i)/2 - (exp(x*i)*i)/2, sqrt(16)])

ans = [ x + 3, cos(x)] [ sin(x), 4]

Try to simplify this expression. By default, `simplify`

does
not combine powers and logarithms because combining them is not valid
for generic complex values.

syms x s = (log(x^2 + 2*x + 1) - log(x + 1))*sqrt(x^2); simplify(s)

ans = -(log(x + 1) - log((x + 1)^2))*(x^2)^(1/2)

To apply the simplification rules that let the `simplify`

function
combine powers and logarithms, set `IgnoreAnalyticConstraints`

to `true`

:

simplify(s, 'IgnoreAnalyticConstraints', true)

ans = x*log(x + 1)

Simplify this expression:

syms x f = ((exp(-x*i)*i)/2 - (exp(x*i)*i)/2)/(exp(-x*i)/2 + ... exp(x*i)/2); simplify(f)

ans = -(exp(x*2i)*1i - 1i)/(exp(x*2i) + 1)

By default, `simplify`

uses one internal
simplification step. You can get different, often shorter, simplification
results by increasing the number of simplification steps:

simplify(f, 'Steps', 10) simplify(f, 'Steps', 30) simplify(f, 'Steps', 50)

ans = 2i/(exp(x*2i) + 1) - 1i ans = ((cos(x) - sin(x)*1i)*1i)/cos(x) - 1i ans = tan(x)

To force `simplify`

favor
real values over complex values, set the value of `Criterion`

to `preferReal`

:

syms x f = (exp(x + exp(-x*i)/2 - exp(x*i)/2)*i)/2 -... (exp(- x - exp(-x*i)/2 + exp(x*i)/2)*i)/2; simplify(f, 'Criterion','preferReal', 'Steps', 100)

ans = sin(sin(x))*cosh(x) + cos(sin(x))*sinh(x)*1i

If `x`

is a real value, then this form of expression
explicitly shows the real and imaginary parts.

Although the result returned by `simplify`

with
the default setting for `Criterion`

is shorter, here
the complex value is a parameter of the sine function:

simplify(f, 'Steps', 100)

ans = sin(sin(x) + x*1i)

When you set `Criterion`

to `preferReal`

,
the simplifier disfavors expression forms where complex values appear
inside subexpressions. In case of nested subexpressions, the deeper
the complex value appears inside an expression, the least preference
this form of an expression gets.

Setting `Criterion`

to `preferReal`

helps
you avoid complex arguments in exponents.

Simplify these symbolic expressions:

simplify(sym(i)^i, 'Steps', 100) simplify(sym(i)^(i+1), 'Steps', 100)

ans = exp(-pi/2) ans = (-1)^(1/2 + 1i/2)

Now, simplify the second expression with the `Criterion`

set
to `preferReal`

:

simplify(sym(i)^(i+1), 'Criterion', 'preferReal', 'Steps', 100)

ans = exp(-pi/2)*1i

Besides the general simplification function (`simplify`

),
the toolbox provides a set of functions for transforming mathematical
expressions to particular forms. For example, you can use particular
functions to expand or factor expressions, collect terms with the
same powers, find a nested (Horner) representation of an expression,
or quickly simplify fractions. If the problem that you want to solve
requires a particular form of an expression, the best approach is
to choose the appropriate simplification function. These simplification
functions are often faster than `simplify`

.

Was this topic helpful?