Numeric to Symbolic Conversion

This topic shows how Symbolic Math Toolbox™ converts numbers into symbolic form. For an overview of symbolic and numeric arithmetic, see Choose Numeric or Symbolic Arithmetic.

To convert numeric input to symbolic form, use the sym command. By default, sym returns a rational approximation of a numeric expression.

t = 0.1;
sym(t)

ans = 
$$\frac{1}{10}$$

sym determines that the double-precision value 0.1 approximates the exact symbolic value $\frac{1}{10}$. In general, sym tries to correct the round-off error in floating-point inputs to return the exact symbolic form. Specifically, sym corrects round-off error in numeric inputs that match the forms $\frac{\mathit{p}}{\mathit{q}}$, $\frac{\mathit{p}\pi }{\mathit{q}}$, ${\left(\frac{\mathit{p}}{\mathit{q}}\right)}^{\frac{1}{2}}$, $2^{\mathit{q}}$, and ${10}^{\mathit{q}}$, where $\mathit{p}$ and $\mathit{q}$ are modest-sized integers.

For these forms, demonstrate that sym converts floating-point inputs to the exact symbolic form. First, numerically approximate $\frac{1}{7}$, $\pi$, and $\frac{1}{\sqrt{2}}$.

N = [1/7 pi 1/sqrt(2)]

N = 1×3

    0.1429    3.1416    0.7071

Convert the numeric approximations to exact symbolic form. sym corrects the round-off error.

S = sym(N)

S = 
$$\left(\begin{array}{ccc}\frac{1}{7}& \pi & \frac{\sqrt{2}}{2}\end{array}\right)$$

You can force sym to accept the input as is by placing the input in quotes. Demonstrate this behavior on the previous input 0.142857142857143. The sym function does not convert the input to 1/7.

sym('0.142857142857143')

ans = $$0.142857142857143$$

When you convert large numbers, use quotes to exactly represent them. Demonstrate this behavior by comparing sym(133333333333333333333) with sym('133333333333333333333').

sym(1333333333333333333)

ans = $$1333333333333333248$$

sym('1333333333333333333')

ans = $$1333333333333333333$$

You can specify the technique used by sym to convert floating-point numbers using the optional second argument, which can be 'f', 'r', 'e', or 'd'. The default flag is 'r', for rational form.

Conversion to Rational Symbolic Form

Convert input to exact rational form by calling sym with the 'r' flag. This is the default behavior when you call sym without flags.

t = 0.1;
sym(t,'r')

ans = 
$$\frac{1}{10}$$

Conversion by Using Floating-Point Expansion

If you call sym with the flag 'f', sym converts double-precision, floating-point numbers to their numeric value by using $\mathit{N}\cdot 2^{\mathit{e}}$, where $\mathit{N}$ and $\mathit{e}$ are the exponent and mantissa respectively.

Convert t by using a floating-point expansion.

sym(t,'f')

ans = 
$$\frac{3602879701896397}{36028797018963968}$$

Conversion to Rational Symbolic Form with Error Term

If you call sym with the flag 'e', sym returns the rational form of t plus the error between the estimated, exact value for t and its floating-point representation. This error is expressed in terms of eps (the floating-point relative precision).

Convert t to symbolic form. Return the error between its estimated symbolic form and its floating-point value.

sym(t,'e')

ans = 
$$\frac{\mathrm{eps}}{40}+\frac{1}{10}$$

The error term eps/40 is the difference between sym('0.1') and sym(0.1).

Conversion to Decimal Form

If you call sym with the flag 'd', sym returns the decimal expansion of the input. The digits function specifies the number of significant digits used. The default value of digits is 32.

sym(t,'d')

ans = $$0.10000000000000000555111512312578$$

Change the number of significant digits by using digits.

digitsOld = digits(7);
sym(t,'d')

ans = $$0.1$$

For further calculations, restore the old value of digits.

digits(digitsOld)

Conversion to 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 input, such as log(2), the numeric 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 numeric expressions to symbolic expressions with sym and then use vpa to evaluate the results with variable precision. For example, find log(2) with 17 and 20 digits 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 exactly represent them.

inaccurateNum = vpa(123456789012345678)

inaccurateNum = $$123456789012345680.0$$

accurateNum = vpa('123456789012345678')

accurateNum = $$123456789012345678.0$$