# Create Symbolic Numbers, Variables, and Expressions

This example shows how to create symbolic numbers, variables, and expressions. To learn how to work with symbolic math, see Perform Symbolic Computations.

### Create Symbolic Numbers with Exact Representations

You can create symbolic numbers by using `sym`. Symbolic numbers are exact representations, unlike floating-point numbers.

Create symbolic numbers by using `sym` and compare them to the same floating-point numbers.

`a1Sym = sym(1/3)`
```a1Sym =  $\frac{1}{3}$```
`a1 = 1/3`
```a1 = 0.3333 ```
`a2Sym = sym(pi)`
`a2Sym = $\pi$`
`a2 = pi`
```a2 = 3.1416 ```

The symbolic numbers are represented in exact rational form, while the floating-point numbers are decimal approximations.

Calculations on symbolic numbers are exact. Demonstrate this exactness by finding `sin(pi)` symbolically and numerically. The symbolic result is exact, while the numeric result is an approximation.

`bSym = sin(sym(pi))`
`bSym = $0$`
`b = sin(pi)`
```b = 1.2246e-16 ```

When you use `sym` on a numeric input, the numeric expression is first evaluated to the MATLAB® default double-precision number that can be less accurate. Then, `sym` is applied on that double-precision number. To represent an exact number without evaluating it to double precision, use a character vector with quotes. For example, create a symbolic number to represent a very large integer exactly.

`inaccurateNum = sym(123456789012345678)`
`inaccurateNum = $123456789012345680$`
`accurateNum = sym('123456789012345678')`
`accurateNum = $123456789012345678$`

You can also create symbolic complex numbers, by specifying the imaginary part of a number as `1i`, `2i`, and so on.

`sym('1234567 + 1i')`
`ans = $1234567+\mathrm{i}$`

### Create Symbolic Numbers with Variable Precision

You can create symbolic numbers with variable-precision floating-point arithmetic by using `vpa`. By default, `vpa` calculates values to 32 significant digits.

`piVpa = vpa(pi)`
`piVpa = $3.1415926535897932384626433832795$`

When you use `vpa` on a numeric expression, such as `log(2)`, the expression is first evaluated to the MATLAB default double-precision number that has less than 32 significant digits. Then, `vpa` is applied on that double-precision number, which can be less accurate. For more accurate results, convert double-precision numbers in an expression to symbolic numbers with `sym` and then use `vpa` to evaluate the results with variable precision. For example, find `log(2)` with 17- and 20- digit precision.

`vpaOnDouble = vpa(log(2))`
`vpaOnDouble = $0.69314718055994528622676398299518$`
`vpaOnSym_17 = vpa(log(sym(2)),17)`
`vpaOnSym_17 = $0.69314718055994531$`
`vpaOnSym_20 = vpa(log(sym(2)),20)`
`vpaOnSym_20 = $0.69314718055994530942$`

When you convert large numbers, use quotes to represent them exactly.

`inaccurateNum = vpa(123456789012345678)`
`inaccurateNum = $123456789012345680.0$`
`accurateNum = vpa('123456789012345678')`
`accurateNum = $123456789012345678.0$`

### Create Symbolic Variables

You can create symbolic variables using either `syms` or `sym`. Typical uses of these functions include:

• `sym` – Create numbered symbolic variables, symbolic variables in MATLAB functions, or symbolic numbers whose values differ from their names in the MATLAB workspace.

• `syms` – Create fresh symbolic variables for interactive symbolic workflows, that is, for symbolic variable creation at the MATLAB command line or in MATLAB live scripts. A fresh symbolic variable does not have any assumptions.

The `syms` command is shorthand for the `sym` syntax, but the two functions handle assumptions differently. `syms` clears the assumptions when creating variables. However, recreating a variable using `sym` does not clear its assumptions.

Create the symbolic variables x and y using `syms` and `sym`, respectively.

```syms x y = sym('y')```
`y = $y$`

The first command creates a symbolic variable `x` in the MATLAB workspace with the value $\mathit{x}$ assigned to the variable `x`. The second command creates a symbolic variable `y` with the value $\mathit{y}$.

With `syms`, you can create multiple variables in one command. Create the variables `a`, `b`, and `c`.

`syms a b c`

#### Create Array of Symbolic Variables

If you want to create a MATLAB array of numbered symbolic variables, the `sym` syntax is more convenient than the `syms` syntax. Therefore, use `sym` to create an array of many numbered symbolic variables.

Clear the workspace. Create a row vector containing the symbolic variables ${\mathit{a}}_{1},\dots ,{\mathit{a}}_{20}$ and assign it to the MATLAB variable `A`. Display the variable in the MATLAB workspace.

```clear A = sym('a',[1 20])```
`A = $\left(\begin{array}{cccccccccccccccccccc}{a}_{1}& {a}_{2}& {a}_{3}& {a}_{4}& {a}_{5}& {a}_{6}& {a}_{7}& {a}_{8}& {a}_{9}& {a}_{10}& {a}_{11}& {a}_{12}& {a}_{13}& {a}_{14}& {a}_{15}& {a}_{16}& {a}_{17}& {a}_{18}& {a}_{19}& {a}_{20}\end{array}\right)$`
`whos`
``` Name Size Bytes Class Attributes A 1x20 8 sym ```

`A` is a `1`-by-`20` array of 20 symbolic variables.

By combining `sym` and `syms`, you can create many fresh symbolic variables with corresponding variable names in the MATLAB workspace.

Clear the workspace. Create the fresh symbolic variables `a1, ..., a10` and assign them the MATLAB variable names `a1, ..., a10`, respectively. Display the variables in the MATLAB workspace.

```clear syms(sym('a',[1 10])) whos```
``` Name Size Bytes Class Attributes a1 1x1 8 sym a10 1x1 8 sym a2 1x1 8 sym a3 1x1 8 sym a4 1x1 8 sym a5 1x1 8 sym a6 1x1 8 sym a7 1x1 8 sym a8 1x1 8 sym a9 1x1 8 sym ```

The MATLAB workspace contains 10 MATLAB variables that are symbolic variables.

The `syms` command is a convenient shorthand for the `sym` syntax, and its typical use is to create fresh symbolic variables for interactive symbolic workflows. Use the `sym` syntax to create the following:

• Symbolic variables in MATLAB functions

• Many numbered symbolic variables

• Symbolic variable whose value differs from its name in the MATLAB workspace

• Symbolic number, such as `sym(5)`

• Symbolic variable that inherits the assumptions from a previously used symbolic variable having the same name

### Create Symbolic Expressions

Suppose you want to use a symbolic variable to represent the golden ratio $\phi =\frac{\text{\hspace{0.17em}}1+\sqrt{\text{\hspace{0.17em}}5}}{2}$.

Use `sym` to create the golden ratio.

`phi = (1 + sqrt(sym(5)))/2;`

Now you can perform various mathematical operations on `phi`. For example:

`f = phi^2 - phi - 1`
```f =  ${\left(\frac{\sqrt{5}}{2}+\frac{1}{2}\right)}^{2}-\frac{\sqrt{5}}{2}-\frac{3}{2}$```

Next, suppose you want to study the quadratic function $\mathit{f}=\mathit{a}{\mathit{x}}^{2}+\mathit{bx}+\mathit{c}$. First, create the symbolic variables `a`, `b`, `c`, and `x`.

`syms a b c x`

Then, create a symbolic expression `f` that represents the arithmetical expression $\mathit{a}{\mathit{x}}^{2}+\mathit{bx}+\mathit{c}$.

`f = a*x^2 + b*x + c`
`f = $a {x}^{2}+b x+c$`

Solve the quadratic equation $\mathit{f}=0$ for $\mathit{x}$ by using `solve`.

`x_0 = solve(f == 0,x)`
```x_0 =  $\left(\begin{array}{c}-\frac{b+\sqrt{{b}^{2}-4 a c}}{2 a}\\ -\frac{b-\sqrt{{b}^{2}-4 a c}}{2 a}\end{array}\right)$```

You can also apply a mathematical function to an arithmetical expression. For example, apply the Bessel function of the first kind ${\mathit{J}}_{0}$ to the arithmetical expression $f$ and find its derivative with respect to $x$.

`J_0 = besselj(0,f)`
`J_0 = ${\mathrm{J}\text{besselj}}_{0}\left(a {x}^{2}+b x+c\right)$`
`DJ_0 = diff(J_0,x)`
`DJ_0 = $-{\mathrm{J}\text{besselj}}_{1}\left(a {x}^{2}+b x+c\right) \left(b+2 a x\right)$`

To create a symbolic number in a symbolic expression, use `sym`. Do not use `syms` to create a symbolic expression that is a constant. For example, to create an expression whose value is `5`, enter `f = sym(5)`. The command `f = 5` does not define `f` as a symbolic expression.

You can also create symbolic expressions from strings by using `str2sym` when reading expressions from text files or when specifying numbers exactly.

### Reuse Names of Symbolic Objects

If you set a variable equal to a symbolic expression and then apply the `syms` command to the variable, MATLAB removes the previously defined expression from the variable.

For example, create a symbolic expression `f`.

```syms a b f = a + b```
`f = $a+b$`

If you recreate f, then MATLAB removes the value $\mathit{a}+\mathit{b}$ from the expression `f`.

```syms f f```
`f = $f$`

You can use the `syms` command to clear variables of definitions that you previously assigned to them in your MATLAB session. `syms` clears the assumptions of the variables. These assumptions (which can be real, integer, rational, and positive) are stored separately from the symbolic object. However, recreating a variable using `sym` does not clear its assumptions. For more information, see Delete Symbolic Objects and Their Assumptions.