Main Content

Check for compatible dimensions and consistent units

`C = checkUnits(`

checks
`expr`

)`expr`

for compatible dimensions and consistent units and returns a
structure containing the fields `Consistent`

and
`Compatible`

. The fields contain logical `0`

(`false`

) or logical `1`

(`true`

)
depending on the check results.

`expr`

has compatible dimensions if all terms have the same
dimensions, such as length or time. `expr`

has consistent units if all
units of the same dimension can be converted to each other with a conversion factor of
1.

Check the dimensions of an equation or expression. The dimensions are checked to confirm that the equation or expression is valid.

Verify the dimensions of the equation

$$A\text{}\frac{\text{m}}{\text{s}}=B\text{}\frac{\text{kg}}{\text{s}}$$

by using `checkUnits`

with the option
`'Compatible'`

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

function returns logical `0`

(`false`

) because the dimensions of the equation are not
compatible.

u = symunit; syms A B eqn = A*u.m/u.s == B*u.kg/u.s; checkUnits(eqn,'Compatible')

ans = logical 0

Replace `u.kg`

with `u.m`

by using
`subs`

and repeat the check. Because the dimensions are now compatible,
`checkUnits`

returns logical `1`

(`true`

).

eqn = subs(eqn,u.kg,u.m); checkUnits(eqn,'Compatible')

ans = logical 1

Checking units for consistency is a stronger check than
compatibility. Units are consistent when all units of the same dimension can be converted
to each other with a conversion factor of 1. For example, 1 Newton is consistent with 1 kg
m/s^{2} but not with 1 kg
cm/s^{2}.

Show that `1`

Newton is consistent with `1`

kg
m/s^{2} by checking `expr1`

but not with
`1`

kg cm/s^{2} by checking
`expr2`

.

u = symunit; expr1 = 1*u.N + 1*u.kg*u.m/u.s^2; expr2 = 1*u.N + 1*u.kg*u.cm/u.s^2; checkUnits(expr1,'Consistent')

ans = logical 1

checkUnits(expr2,'Consistent')

ans = logical 0

Show the difference between compatibility and consistency by showing that
`expr2`

has compatible dimensions but not consistent units.

checkUnits(expr2,'Compatible')

ans = logical 1

Check multiple equations or expressions by placing them in an array.
`checkUnits`

returns an array whose elements correspond to the
elements of the input.

Check multiple equations for compatible dimensions. `checkUnits`

returns `[1 0]`

, meaning that the first equation has compatible dimensions
while the second equation does not.

u = symunit; syms x y z eqn1 = x*u.m == y*u.m^2/(z*u.m); eqn2 = x*u.m + y*u.s == z*u.m; eqns = [eqn1 eqn2]; compatible = checkUnits(eqns,'Compatible')

compatible = 1×2 logical array 1 0

Check for both compatible dimensions and consistent units of the
equation or expression by using `checkUnits`

.

Define the equations for x- and y-displacement of a moving projectile. Check their units for compatibility and consistency.

u = symunit; g = 9.81*u.cm/u.s^2; v = 10*u.m/u.s^2; syms theta x(t) y(t) x(t) = v*cos(theta)*t; y(t) = v*sin(theta)*t + (-g*t^2)/2; S = checkUnits([x y])

S = struct with fields: Consistent: [1 0] Compatible: [1 1]

The second equation has compatible dimensions but inconsistent units. This inconsistency
is because `g`

incorrectly uses cm instead of m. Redefine
`g`

and check the equations again. The second equation now has consistent
units.

g = 9.81*u.m/u.s^2; y(t) = v*sin(theta)*t + (-g*t^2)/2; S = checkUnits([x y])

S = struct with fields: Consistent: [1 1] Compatible: [1 1]

`findUnits`

| `isUnit`

| `newUnit`

| `separateUnits`

| `str2symunit`

| `symunit`

| `symunit2str`

| `unitConversionFactor`