Note: This page has been translated by MathWorks. Click here to see

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

Use units of measurement with Symbolic Math Toolbox™. This page shows how to define units, use units in equations (including differential equations), and verify the dimensions of expressions.

Load units by using `symunit`

.

u = symunit;

Specify a unit by using `u.`

* unit*. For example,
specify a distance of

`5`

meters, a weight of `50`

kilograms, and a speed of `10`

kilometers per hour. In displayed output,
units are placed in square brackets `[]`

.d = 5*u.m w = 50*u.kg s = 10*u.km/u.hr

d = 5*[m] w = 50*[kg] s = 10*([km]/[h])

Use tab expansion to find names of units. Type `u.`

,
press **Tab**, and continue typing.

Units are treated like other symbolic expressions and can be used in any standard operation or function. Units are not automatically simplified, which provides flexibility. Common alternate names for units are supported. Plurals are not supported.

Add `500`

meters and `2`

kilometers. The resulting
distance is not automatically simplified.

d = 500*u.m + 2*u.km

d = 2*[km] + 500*[m]

Simplify `d`

by using `simplify`

. The
`simplify`

function automatically chooses the unit to simplify to.

d = simplify(d)

d = (5/2)*[km]

Instead of automatically choosing a unit, convert `d`

to a specific unit
by using `unitConvert`

. Convert `d`

to meters.

d = unitConvert(d,u.m)

d = 2500*[m]

There are more unit conversion and unit system options. See Unit Conversions and Unit Systems.

Find the speed if the distance `d`

is crossed in `50`

seconds. The result has the correct units.

t = 50*u.s; s = d/t

s = 50*([m]/[s])

By default, temperatures are assumed to represent differences and not absolute
measurements. For example, `5*u.Celsius`

is assumed to represent a
temperature difference of 5 degrees Celsius. This assumption allows arithmetical operations on
temperature values.

To represent absolute temperatures, use kelvin, so that you do not have to distinguish an absolute temperature from a temperature difference.

Convert `23`

degrees Celsius to kelvin, treating it first as a
temperature difference and then as an absolute temperature.

u = symunit; T = 23*u.Celsius; diffK = unitConvert(T,u.K)

diffK = 23*[K]

absK = unitConvert(T,u.K,'Temperature','absolute')

absK = (5923/20)*[K]

In longer expressions, visually checking for units is difficult. You can check the dimensions of expressions automatically by verifying the dimensions of an equation.

First, define the kinematic equation $${v}^{2}={v}_{0}{}^{2}+2as$$, where `v`

represents velocity, `a`

represents acceleration, and `s`

represents distance. Assume
`s`

is in kilometers and all other units are in SI base units. To
demonstrate dimension checking, the units of `a`

are intentionally
incorrect.

syms v v0 a s u = symunit; eqn = (v*u.m/u.s)^2 == (v0*u.m/u.s)^2 + 2*a*u.m/u.s*s*u.km

eqn = v^2*([m]^2/[s]^2) == v0^2*([m]^2/[s]^2) + (2*a*s)*(([km]*[m])/[s])

Observe the units that appear in `eqn`

by using
`findUnits`

. The returned units show that both kilometers and meters are
used to represent distance.

findUnits(eqn)

ans = [ [km], [m], [s]]

Check if the units have the same dimensions (such as length or time) by using
`checkUnits`

with the `'Compatible'`

input. MATLAB^{®} assumes symbolic variables are dimensionless. `checkUnits`

returns logical `0`

(`false`

), meaning the units are
incompatible and not of the same physical dimensions.

checkUnits(eqn,'Compatible')

ans = logical 0

Looking at `eqn`

, the acceleration `a`

has incorrect
units. Correct the units and recheck for compatibility again. `eqn`

now has
compatible units.

eqn = (v*u.m/u.s)^2 == (v0*u.m/u.s)^2 + 2*a*u.m/u.s^2*s*u.km; checkUnits(eqn,'Compatible')

ans = logical 1

Now, to check that each dimension is consistently represented by the same unit, use
`checkUnits`

with the `'Consistent'`

input.
`checkUnits`

returns logical `0`

(`false`

) because meters and kilometers are both used to represent distance
in `eqn`

.

checkUnits(eqn,'Consistent')

ans = logical 0

Convert `eqn`

to SI base units to make the units consistent. Run
`checkUnits`

again. `eqn`

has both compatible and
consistent units.

eqn = unitConvert(eqn,'SI')

eqn = v^2*([m]^2/[s]^2) == v0^2*([m]^2/[s]^2) + (2000*a*s)*([m]^2/[s]^2)

checkUnits(eqn)

ans = struct with fields: Consistent: 1 Compatible: 1

After you finish working with units and only need the dimensionless equation or
expression, separate the units and the equation by using
`separateUnits`

.

[eqn,units] = separateUnits(eqn)

eqn = v^2 == v0^2 + 2000*a*s units = 1*([m]^2/[s]^2)

You can return the original equation with units by multiplying `eqn`

with
`units`

and expanding the result.

expand(eqn*units)

ans = v^2*([m]^2/[s]^2) == v0^2*([m]^2/[s]^2) + (2000*a*s)*([m]^2/[s]^2)

To calculate numeric values from your expression, substitute for symbolic variables using
`subs`

, and convert to numeric values using `double`

or `vpa`

.

Solve `eqn`

for `v`

. Then find the value of
`v`

where `v0 = 5`

, `a = 2.5`

, and
`s = 10`

. Convert the result to double.

v = solve(eqn,v); v = v(2); % choose the positive solution vSol = subs(v,[v0 a s],[5 2.5 10]); vSol = double(vSol)

vSol = 223.6627

Use units in differential equations just as in standard equations. This section shows how
to use units in differential equations by deriving the velocity relations *v* = *v*_{0} + *a**t* and $${v}^{2}={v}_{0}{}^{2}+2as$$ starting from the definition of acceleration $$a=\frac{dv}{dt}$$.

Represent the definition of acceleration symbolically using SI units. Given that the
velocity `V`

has units, `V`

must be differentiated with
respect to the correct units as `T = t*u.s`

and not just
`t`

.

syms V(t) a u = symunit; T = t*u.s; % time in seconds A = a*u.m/u.s^2; % acceleration in meters per second eqn1 = A == diff(V,T)

eqn1(t) = a*([m]/[s]^2) == diff(V(t), t)*(1/[s])

Because the velocity `V`

is unknown and does not have units,
`eqn1`

has incompatible and inconsistent units.

checkUnits(eqn1)

ans = struct with fields: Consistent: 0 Compatible: 0

Solve `eqn1`

for `V`

with the condition that the initial
velocity is *v _{0}*. The result is the equation

syms v0 cond = V(0) == v0*u.m/u.s; eqn2 = V == dsolve(eqn1,cond)

eqn2(t) = V(t) == v0*([m]/[s]) + a*t*([m]/[s])

Check that the result has the correct dimensions by substituting
`rhs(eqn2)`

into `eqn1`

and using
`checkUnits`

.

checkUnits(subs(eqn1,V,rhs(eqn2)))

ans = struct with fields: Consistent: 1 Compatible: 1

Now, derive $${v}^{2}={v}_{0}{}^{2}+2as$$. Because velocity is the rate of change of distance, substitute
`V`

with the derivative of distance `S`

. Again, given that
`S`

has units, `S`

must be differentiated with respect to
the correct units as `T = t*u.s`

and not just `t`

.

syms S(t) eqn2 = subs(eqn2,V,diff(S,T))

eqn2(t) = diff(S(t), t)*(1/[s]) == v0*([m]/[s]) + a*t*([m]/[s])

Solve `eqn2`

with the condition that the initial distance covered is
`0`

. Get the expected form of `S`

by using
`expand`

.

cond2 = S(0) == 0; eqn3 = S == dsolve(eqn2,cond2); eqn3 = expand(eqn3)

eqn3(t) = S(t) == t*v0*[m] + ((a*t^2)/2)*[m]

You can use this equation with the units in symbolic workflows. Alternatively, you can
remove the units by returning the right side using `rhs`

, separating units
by using `separateUnits`

, and using the resulting unitless
expression.

[S units] = separateUnits(rhs(eqn3))

S(t) = (a*t^2)/2 + v0*t units(t) = [m]

When you need to calculate numeric values from your expression, substitute for symbolic
variables using `subs`

, and convert to numeric values using
`double`

or `vpa`

.

Find the distance traveled in `8`

seconds where ```
v0 =
20
```

and `a = 1.3`

. Convert the result to double.

S = subs(S,[v0 a],[20 1.3]); dist = S(8); dist = double(dist)

dist = 201.6000

`checkUnits`

| `findUnits`

| `isUnit`

| `newUnit`

| `separateUnits`

| `symunit2str`

| `unitConversionFactor`

| `unitConvert`