Symbolic Math
Toolbox™ provides the `combine`

function
for combining subexpressions of an original expression. The `combine`

function
uses mathematical identities for the functions you specify. For example,
combine the trigonometric expression.

syms x y combine(2*sin(x)*cos(x),'sincos')

ans = sin(2*x)

If you do not specify a target function, `combine`

uses
the identities for powers wherever these identities are valid:

*a*^{b}*a*^{c}=*a*^{b + c}*a*^{c}*b*^{c}= (*a**b*)^{c}(

*a*^{b})^{c}=*a*^{bc}

For example, by default the function combines the following square roots.

combine(sqrt(2)*sqrt(x))

ans = (2*x)^(1/2)

The function does not combine these square roots because the identity is not valid for negative values of variables.

combine(sqrt(x)*sqrt(y))

ans = x^(1/2)*y^(1/2)

To combine these square roots, use the `IgnoreAnalyticConstraints`

option.

combine(sqrt(x)*sqrt(y),'IgnoreanalyticConstraints',true)

ans = (x*y)^(1/2)

`IgnoreAnalyticConstraints`

provides a shortcut
allowing you to combine expressions under commonly used assumptions
about values of the variables. Alternatively, you can set appropriate
assumptions on variables explicitly. For example, assume that `x`

and `y`

are
positive values.

assume([x,y],'positive') combine(sqrt(x)*sqrt(y))

ans = (x*y)^(1/2)

For further computations, clear the assumptions on `x`

and
`y`

by recreating them using `syms`

.

syms x y

As target functions, `combine`

accepts `atan`

, `exp`

, `gamma`

, `int`

, `log`

, `sincos`

,
and `sinhcosh`

.

For elementary expressions, use the `expand`

function
to transform the original expression by multiplying sums of products.
This function provides an easy way to expand polynomials.

expand((x - 1)*(x - 2)*(x - 3))

ans = x^3 - 6*x^2 + 11*x - 6

expand(x*(x*(x - 6) + 11) - 6)

ans = x^3 - 6*x^2 + 11*x - 6

The function also expands exponential and logarithmic expressions. For example, expand this expression containing exponentials.

expand(exp(x + y)*(x + exp(x - y)))

ans = exp(2*x) + x*exp(x)*exp(y)

Expand this logarithm. Expanding logarithms is not valid for generic complex values, but it is valid for positive values.

syms a b c positive expand(log(a*b*c))

ans = log(a) + log(b) + log(c)

For further computations, clear the assumptions.

syms a b c

Alternatively, use the `IgnoreAnalyticConstraints`

option
when expanding logarithms.

expand(log(a*b*c),'IgnoreAnalyticConstraints',true)

ans = log(a) + log(b) + log(c)

`expand`

also works on trigonometric expressions.
For example, expand this expression.

expand(cos(x + y))

ans = cos(x)*cos(y) - sin(x)*sin(y)

`expand`

uses mathematical identities between
the functions.

expand(sin(5*x))

ans = sin(x) - 12*cos(x)^2*sin(x) + 16*cos(x)^4*sin(x)

expand(cos(3*acos(x)))

ans = 4*x^3 - 3*x

`expand`

works recursively for all subexpressions.

expand((sin(3*x) + 1)*(cos(2*x) - 1))

ans = 2*sin(x) + 2*cos(x)^2 - 10*cos(x)^2*sin(x) + 8*cos(x)^4*sin(x) - 2

To prevent the expansion of all trigonometric, logarithmic,
and exponential subexpressions, use the option `ArithmeticOnly`

.

expand(exp(x + y)*(x + exp(x - y)),'ArithmeticOnly',true)

ans = exp(x - y)*exp(x + y) + x*exp(x + y)

expand((sin(3*x) + 1)*(cos(2*x) - 1),'ArithmeticOnly',true)

ans = cos(2*x) - sin(3*x) + cos(2*x)*sin(3*x) - 1

To return all irreducible factors of an expression, use the `factor`

function.
For example, find all irreducible polynomial factors of this polynomial
expression. The result shows that this polynomial has three roots: ```
x
= 1
```

, `x = 2`

, and `x = 3`

.

syms x factor(x^3 - 6*x^2 + 11*x - 6)

ans = [ x - 3, x - 1, x - 2]

If a polynomial expression is irreducible, `factor`

returns
the original expression.

factor(x^3 - 6*x^2 + 11*x - 5)

ans = x^3 - 6*x^2 + 11*x - 5

Find irreducible polynomial factors of this expression. By default, `factor`

uses
factorization over rational numbers keeping rational numbers in their
exact symbolic form. The resulting factors for this expression do
not show polynomial roots.

factor(x^6 + 1)

ans = [ x^2 + 1, x^4 - x^2 + 1]

Using other factorization modes lets you factor this expression further. For example, factor the same expression over complex numbers.

factor(x^6 + 1,'FactorMode','complex')

ans = [ x + 0.86602540378443864676372317075294 + 0.5i,... x + 0.86602540378443864676372317075294 - 0.5i,... x + 1.0i,... x - 1.0i,... x - 0.86602540378443864676372317075294 + 0.5i,... x - 0.86602540378443864676372317075294 - 0.5i]

`factor`

also works on expressions other
than polynomials and rational expressions. For example, you can factor
the following expression that contains logarithm, sine, and cosine
functions. Internally, `factor`

converts such expressions
into polynomials and rational expressions by substituting subexpressions
with variables. After computing irreducible factors, the function
restores original subexpressions.

factor((log(x)^2 - 1)/(cos(x)^2 - sin(x)^2))

ans = [ log(x) - 1, log(x) + 1, 1/(cos(x) - sin(x)), 1/(cos(x) + sin(x))]

Use `factor`

to factor symbolic integers
and symbolic rational numbers.

factor(sym(902834092)) factor(1/sym(210))

ans = [ 2, 2, 47, 379, 12671] ans = [ 1/2, 1/3, 1/5, 1/7]

`factor`

also can factor numbers larger than `flintmax`

that the MATLAB^{®} `factor`

cannot. To represent a large number
accurately, place the number in quotation marks.

factor(sym('41758540882408627201'))

ans = [ 479001599, 87178291199]

The `children`

function returns the subexpressions
of an expression.

Define an expression `f`

with several subexpressions.

syms x y f = exp(3*x)*y^3 + exp(2*x)*y^2 + exp(x)*y;

Extract the subexpressions of `f`

by using
`children`

.

expr = children(f)

expr = [ y^2*exp(2*x), y^3*exp(3*x), y*exp(x)]

You can extract lower-level subexpressions by calling `children`

repeatedly
on the results.

Extract the subexpressions of `expr(1)`

by
calling `children`

repeatedly. When the input to `children`

is
a vector, the output is a cell array.

expr1 = children(expr(1)) expr2 = children(expr1)

expr1 = [ y^2, exp(2*x)] expr2 = 1×2 cell array {1×2 sym} {1×1 sym}

Access the contents of the cell array `expr2`

using
braces.

expr2{1} expr2{2}

ans = [ y, 2] ans = 2*x

If a mathematical expression contains terms with the same powers
of a specified variable or expression, the `collect`

function
reorganizes the expression by grouping such terms. When calling `collect`

,
specify the variables that the function must consider as unknowns.
The `collect`

function regards the original expression
as a polynomial in the specified unknowns, and groups the coefficients
with equal powers. Group the terms of an expression with the equal
powers of `x`

.

syms x y z expr = x*y^4 + x*z + 2*x^3 + x^2*y*z +... 3*x^3*y^4*z^2 + y*z^2 + 5*x*y*z; collect(expr, x)

ans = (3*y^4*z^2 + 2)*x^3 + y*z*x^2 + (y^4 + 5*z*y + z)*x + y*z^2

Group the terms of the same expression with the equal powers
of `y`

.

collect(expr, y)

ans = (3*x^3*z^2 + x)*y^4 + (x^2*z + 5*x*z + z^2)*y + 2*x^3 + z*x

Group the terms of the same expression with the equal powers
of `z`

.

collect(expr, z)

ans = (3*x^3*y^4 + y)*z^2 + (x + 5*x*y + x^2*y)*z + 2*x^3 + x*y^4

If you do not specify variables that `collect`

must
consider as unknowns, the function uses `symvar`

to
determine the default variable.

collect(expr)

ans = (3*y^4*z^2 + 2)*x^3 + y*z*x^2 + (y^4 + 5*z*y + z)*x + y*z^2

Collect terms of an expression with respect to several unknowns by specifying those unknowns as a vector.

collect(expr, [y,z])

ans = 3*x^3*y^4*z^2 + x*y^4 + y*z^2 + (x^2 + 5*x)*y*z + x*z + 2*x^3

To present an expression in terms of a particular function,
use `rewrite`

. This function uses mathematical
identities between functions. For example, rewrite an expression containing
trigonometric functions in terms of a particular trigonometric function.

syms x rewrite(sin(x),'tan')

ans = (2*tan(x/2))/(tan(x/2)^2 + 1)

rewrite(cos(x),'tan')

ans = -(tan(x/2)^2 - 1)/(tan(x/2)^2 + 1)

rewrite(sin(2*x) + cos(3*x)^2,'tan')

ans = (tan((3*x)/2)^2 - 1)^2/(tan((3*x)/2)^2 + 1)^2 +... (2*tan(x))/(tan(x)^2 + 1)

Use `rewrite`

to express these
trigonometric functions in terms of the exponential function.

rewrite(sin(x),'exp')

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

rewrite(cos(x),'exp')

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

Use `rewrite`

to express these
hyperbolic functions in terms of the exponential function.

rewrite(sinh(x),'exp')

ans = exp(x)/2 - exp(-x)/2

rewrite(cosh(x),'exp')

ans = exp(-x)/2 + exp(x)/2

`rewrite`

also expresses inverse hyperbolic
functions in terms of logarithms.

rewrite(asinh(x),'log')

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

rewrite(acosh(x),'log')

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

The `partfrac`

function returns a rational
expression in the form of a sum of a polynomial and rational terms.
In each rational term, the degree of the numerator is smaller than
the degree of the denominator. For some expressions, `partfrac`

returns
visibly simpler forms.

syms x n = x^6 + 15*x^5 + 94*x^4 + 316*x^3 + 599*x^2 + 602*x + 247; d = x^6 + 14*x^5 + 80*x^4 + 238*x^3 + 387*x^2 + 324*x + 108; partfrac(n/d, x)

ans = 1/(x + 1) + 1/(x + 2)^2 + 1/(x + 3)^3 + 1

The denominators in rational terms represent the factored common denominator of the original expression.

factor(d)

ans = [ x + 1, x + 2, x + 2, x + 3, x + 3, x + 3]

The `simplifyFraction`

function
represents the original rational expression as a single rational term
with expanded numerator and denominator. The greatest common divisor
of the numerator and denominator of the returned expression is 1.
This function is more efficient for simplifying fractions than the `simplify`

function.

syms x y simplifyFraction((x^3 + 3*y^2)/(x^2 - y^2) + 3)

ans = (x^3 + 3*x^2)/(x^2 - y^2)

`simplifyFraction`

cancels common factors
that appear in numerator and denominator.

simplifyFraction(x^2/(x + y) - y^2/(x + y))

ans = x - y

`simplifyFraction`

also handles expressions
other than polynomials and rational functions. Internally, it converts
such expressions into polynomials or rational functions by substituting
subexpressions with identifiers. After normalizing the expression
with temporary variables, `simplifyFraction`

restores
the original subexpressions.

simplifyFraction((exp(2*x) - exp(2*y))/(exp(x) - exp(y)))

ans = exp(x) + exp(y)

The Horner, or nested, form of a polynomial expression is efficient
for numerical evaluation because it often involves fewer arithmetical
operations than other mathematically equivalent forms of the same
polynomial. Typically, this form of an expression is numerically stable.
To represent a polynomial expression in a nested form, use the `horner`

function.

syms x horner(x^3 - 6*x^2 + 11*x - 6)

ans = x*(x*(x - 6) + 11) - 6

If polynomial coefficients are floating-point numbers, the resulting Horner form represents them as rational numbers.

horner(1.1 + 2.2*x + 3.3*x^2)

ans = x*((33*x)/10 + 11/5) + 11/10

To convert the coefficients in the result to floating-point
numbers, use `vpa`

.

vpa(ans)

ans = x*(3.3*x + 2.2) + 1.1