Create symbolic variables, expressions, functions, matrices

**The syntaxes sym(A,set) and sym(A,'clear') for
a symbolic object A in the MATLAB**

**Support of character vectors that are not valid
variable names and do not define a number will be removed in a future
release. To create symbolic expressions, first create symbolic variables,
and then use operations on them. For example, use syms x;
x + 1 instead of sym('x + 1'), exp(sym(pi)) instead
of sym('exp(pi)'), and syms f(var1,...varN) instead
of f(var1,...varN) = sym('f(var1,...varN)').**

creates an `A`

= sym('`a`

', ```
[n1
... nM]
```

)`n1`

-by-`...`

-by-`nM`

symbolic
array filled with automatically generated elements. For example, ```
A
= sym('a',[1 3])
```

creates the row vector ```
A = [a1
a2 a3]
```

. The auto-generated elements do not appear in the MATLAB workspace.
For arrays, these elements have the prefix `a`

followed
by the element's index using `_`

as a delimiter,
such as `a1_3_2`

.

`sym(___, `

creates
a symbolic variable or array and sets the assumption that the variable
or all array elements belong to a `set`

)`set`

. Here, `set`

can
be `'real'`

, `'positive'`

, `'integer'`

,
or `'rational'`

.

Create the symbolic variables `x`

and `y`

.

x = sym('x'); y = sym('y');

Create a 1-by-4 symbolic vector `a`

with
auto-generated elements `a1`

, ..., `a4`

.

a = sym('a', [1 4])

a = [ a1, a2, a3, a4]

Format the names of elements of `a`

by using
a format character vector as the first argument. `sym`

replaces `%d`

in
the format character vector with the index of the element to generate
the element names.

a = sym('x_%d', [1 4])

a = [ x_1, x_2, x_3, x_4]

This syntax does not create symbolic variables `x_1`

,
..., `x_4`

in the MATLAB workspace. Access elements
of `a`

using standard indexing methods.

a(1) a(2:3)

ans = x_1 ans = [ x_2, x_3]

Create a 3-by-4 symbolic matrix with automatically
generated elements. The elements are of the form `ai_j`

,
which generates the elements `A1_1`

, ..., `A3_4`

.

A = sym('A',[3 4])

A = [ A1_1, A1_2, A1_3, A1_4] [ A2_1, A2_2, A2_3, A2_4] [ A3_1, A3_2, A3_3, A3_4]

Create a 4-by-4 matrix with the element names `x_1_1`

,
..., `x_4_4`

by using a format character vector as
the first argument. `sym`

replaces `%d`

in
the format character vector with the index of the element to generate
the element names.

B = sym('x_%d_%d',4)

B = [ x_1_1, x_1_2, x_1_3, x_1_4] [ x_2_1, x_2_2, x_2_3, x_2_4] [ x_3_1, x_3_2, x_3_3, x_3_4] [ x_4_1, x_4_2, x_4_3, x_4_4]

This syntax does not create symbolic variables `A1_1`

,
..., `A3_4`

, `x_1_1`

, ..., `x_4_4`

in
the MATLAB workspace. To access an element of a matrix, use parentheses.

A(2,3) B(4,2)

ans = A2_3 ans = x_4_2

Create a 2-by-2-by-2 symbolic array with automatically
generated elements `A1_1_1`

, ..., `A2_2_2`

.

A = sym('a',[2 2 2])

A(:,:,1) = [ a1_1_1, a1_2_1] [ a2_1_1, a2_2_1] A(:,:,2) = [ a1_1_2, a1_2_2] [ a2_1_2, a2_2_2]

Convert numeric values to symbolic numbers
or expressions. Use `sym`

on subexpressions instead
of the entire expression for better accuracy. Using `sym`

on
entire expressions is inaccurate because MATLAB first converts
the expression to a floating-point number, which loses accuracy. `sym`

cannot
always recover this lost accuracy.

inaccurate1 = sym(1/1234567) accurate1 = 1/sym(1234567) inaccurate2 = sym(sqrt(1234567)) accurate2 = sqrt(sym(1234567)) inaccurate3 = sym(exp(pi)) accurate3 = exp(sym(pi))

inaccurate1 = 7650239286923505/9444732965739290427392 accurate1 = 1/1234567 inaccurate2 = 4886716562018589/4398046511104 accurate2 = 1234567^(1/2) inaccurate3 = 6513525919879993/281474976710656 accurate3 = exp(pi)

When creating symbolic numbers with 15 or more digits, use quotation marks to accurately represent the numbers.

inaccurateNum = sym(11111111111111111111) accurateNum = sym('11111111111111111111')

inaccurateNum = 11111111111111110656 accurateNum = 11111111111111111111

When you use quotation marks to create symbolic complex numbers,
specify the imaginary part of a number as `1i`

, `2i`

,
and so on.

sym('1234567 + 1i')

ans = 1234567 + 1i

Create a symbolic expression and a symbolic matrix from anonymous functions associated with MATLAB handles.

h_expr = @(x)(sin(x) + cos(x)); sym_expr = sym(h_expr)

sym_expr = cos(x) + sin(x)

h_matrix = @(x)(x*pascal(3)); sym_matrix = sym(h_matrix)

sym_matrix = [ x, x, x] [ x, 2*x, 3*x] [ x, 3*x, 6*x]

Create the symbolic variables `x`

, `y`

, `z`

,
and `t`

simultaneously assuming that `x`

is
real, `y`

is positive, `z`

integer,
and `t`

is rational.

x = sym('x','real'); y = sym('y','positive'); z = sym('z','integer'); t = sym('t','rational');

Check the assumptions on `x`

, `y`

,
and `z`

using `assumptions`

.

assumptions

ans = [ in(t, 'rational'), in(x, 'real'), 0 < y, in(z, 'integer')]

For further computations, clear the assumptions using `assume`

.

assume([x y z t],'clear') assumptions

ans = Empty sym: 1-by-0

Create a symbolic matrix and set assumptions on each element of that matrix.

A = sym('A%d%d',[2 2],'positive')

A = [ A11, A12] [ A21, A22]

Solve an equation involving the first element of `A`

. MATLAB assumes
that this element is positive.

solve(A(1, 1)^2 - 1, A(1, 1))

ans = 1

Check the assumptions set on the elements of `A`

by
using `assumptions`

.

assumptions(A)

ans = [ 0 < A21, 0 < A11, 0 < A22, 0 < A12]

Clear all previously set assumptions on elements of a symbolic
matrix by using `assume`

.

assume(A,'clear'); assumptions(A)

ans = Empty sym: 1-by-0

Solve the same equation again.

solve(A(1, 1)^2 - 1, A(1, 1))

ans = -1 1

Convert `pi`

to a symbolic
value.

Choose the conversion technique by specifying the optional second
argument, which can be `'r'`

, `'f'`

, `'d'`

,
or `'e'`

. The default is `'r'`

.
See the Input Arguments section for the details about conversion techniques.

r = sym(pi) f = sym(pi,'f') d = sym(pi,'d') e = sym(pi,'e')

r = pi f = 884279719003555/281474976710656 d = 3.1415926535897931159979634685442 e = pi - (198*eps)/359

To create several symbolic variables in one function call, use `syms`

.

`assume`

| `assumeAlso`

| `assumptions`

| `clear`

| ```
clear
all
```

| `double`

| `eps`

| `reset`

| `symfun`

| `syms`

| `symvar`

Was this topic helpful?