# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English verison of the page.

# simplify

Algebraic simplification

## Syntax

``simplify(S)``
``simplify(S,Name,Value)``

## Description

example

````simplify(S)` performs algebraic simplification of `S`. If `S` is a symbolic vector or matrix, this function simplifies each element of `S`.```

example

````simplify(S,Name,Value)` performs algebraic simplification of `S` using additional options specified by one or more `Name,Value` pair arguments.```

## Examples

### Simplify Expressions

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)```

### Simplify Matrix Elements

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 M = [(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)]; simplify(M)```
```ans = [ x + 3, cos(x)] [ sin(x), 4]```

### Get Simpler Results For Logarithms and Powers

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)```

### Get Simpler Results Using More Simplification Steps

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)```

If you are unable to return the desired result, try alternate simplification functions. See Choose Function to Rearrange Expression.

### Separate Real and Imaginary Parts

Attempt to separate real and imaginary parts of an expression by setting 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 `Criterion` is not set to `preferReal`, then `simplify` returns a shorter result but the real and imaginary parts are not separated.

`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 nested subexpressions, the deeper the complex value appears inside an expression, the least preference this form of an expression gets.

### Avoid Imaginary Terms in Exponents

Attempt to avoid imaginary terms in exponents by setting `Criterion` to `preferReal`.

Show this behavior by simplifying a complex symbolic expression with and without setting `Criterion` to `preferReal`. When `Criterion` is set to `preferReal`, then `simplify` places the imaginary term outside the exponent.

```expr = sym(i)^(i+1); withoutPreferReal = simplify(expr,'Steps',100)```
```withoutPreferReal = (-1)^(1/2 + 1i/2)```
`withPreferReal = simplify(expr,'Criterion','preferReal','Steps',100)`
```withPreferReal = exp(-pi/2)*1i```

### Simplify Units

Simplify expressions containing symbolic units of the same dimension by using `simplify`.

```u = symunit; expr = 300*u.cm + 40*u.inch + 2*u.m; expr = simplify(expr)```
```expr = (3008/5)*[cm]```

`simplify` automatically chooses the unit to rewrite into. To choose a specific unit, use `rewrite`.

## Input Arguments

collapse all

Input expression, specified as a symbolic expression, function, vector, or matrix.

### Name-Value Pair Arguments

Specify optional comma-separated pairs of `Name,Value` arguments. `Name` is the argument name and `Value` is the corresponding value. `Name` must appear inside single quotes (`' '`). You can specify several name and value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.

Example: `'Seconds',60` limits the simplification process to 60 seconds.

collapse all

Simplification criterion, specified as the comma-separated pair consisting of `'Criterion'` and one of these character vectors.

 `'default'` Use the default (internal) simplification criteria. `'preferReal'` Favor the forms of `S` containing real values over the forms containing complex values. If any form of `S` contains complex values, the simplifier disfavors the 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.

Simplification rules, specified as the comma-separated pair consisting of `'IgnoreAnalyticConstraints'` and one of these values.

 `false` Use strict simplification rules. `simplify` always returns results equivalent to the initial expression. `true` Apply purely algebraic simplifications to an expression. `simplify` can return simpler results for expressions for which it would return more complicated results otherwise. Setting `IgnoreAnalyticConstraints` to `true` can lead to results that are not equivalent to the initial expression.

Time limit for the simplification process, specified as the comma-separated pair consisting of `'Seconds'` and a positive value that denotes the maximal time in seconds.

Number of simplification steps, specified as the comma-separated pair consisting of `'Steps'` and a positive value that denotes the maximal number of internal simplification steps. Note that increasing the number of simplification steps can slow down your computations.

`simplify(S,'Steps',n)` is equivalent to `simplify(S,n)`, where `n` is the number of simplification steps.

## Tips

• Simplification of mathematical expression is not a clearly defined subject. There is no universal idea as to which form of an expression is simplest. The form of a mathematical expression that is simplest for one problem might be complicated or even unsuitable for another problem.

## Algorithms

When you use `IgnoreAnalyticConstraints`, then `simplify` follows these rules:

• 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 of 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 values of k