## Documentation |

On this page… |
---|

*MATLAB* is an abbreviation for "matrix
laboratory." While other programming languages mostly work with numbers
one at a time, MATLAB^{®} is designed to operate primarily on whole
matrices and arrays.

All MATLAB variables are multidimensional *arrays*,
no matter what type of data. A *matrix* is a
two-dimensional array often used for linear algebra.

To create an array with four elements in a single row, separate
the elements with either a comma (`,`) or a space.

a = [1 2 3 4]

returns

a = 1 2 3 4

This type of array is a *row vector*.

To create a matrix that has multiple rows, separate the rows with semicolons.

a = [1 2 3; 4 5 6; 7 8 10]

a = 1 2 3 4 5 6 7 8 10

Another way to create a matrix is to use a function, such as `ones`, `zeros`,
or `rand`. For example, create a 5-by-1 column vector
of zeros.

z = zeros(5,1)

z = 0 0 0 0 0

MATLAB allows you to process all of the values in a matrix using a single arithmetic operator or function.

a + 10

ans = 11 12 13 14 15 16 17 18 20

sin(a)

ans = 0.8415 0.9093 0.1411 -0.7568 -0.9589 -0.2794 0.6570 0.9894 -0.5440

To transpose a matrix, use a single quote (`'`):

a'

ans = 1 4 7 2 5 8 3 6 10

You can perform standard matrix multiplication, which computes
the inner products between rows and columns, using the `*` operator.
For example, confirm that a matrix times its inverse returns the identity
matrix:

p = a*inv(a)

p = 1.0000 0 -0.0000 0 1.0000 0 0 0 1.0000

Notice that `p` is not a matrix of integer
values. MATLAB stores numbers as floating-point values, and arithmetic
operations are sensitive to small differences between the actual value
and its floating-point representation. You can display more decimal
digits using the `format` command:

```
format long
p = a*inv(a)
```

p = 1.000000000000000 0 -0.000000000000000 0 1.000000000000000 0 0 0 0.999999999999998

Reset the display to the shorter format using

`format short`

`format` affects only the display of numbers,
not the way MATLAB computes or saves them.

To perform element-wise multiplication rather than matrix multiplication,
use the `.*` operator:

p = a.*a

p = 1 4 9 16 25 36 49 64 100

The matrix operators for multiplication, division, and power
each have a corresponding array operator that operates element-wise.
For example, raise each element of `a` to the third
power:

a.^3

ans = 1 8 27 64 125 216 343 512 1000

*Concatenation* is the process of joining
arrays to make larger ones. In fact, you made your first array by
concatenating its individual elements. The pair of square brackets `[]` is
the concatenation operator.

A = [a,a]

A = 1 2 3 1 2 3 4 5 6 4 5 6 7 8 10 7 8 10

Concatenating
arrays next to one another using commas is called *horizontal* concatenation.
Each array must have the same number of rows. Similarly, when the
arrays have the same number of columns, you can concatenate *vertically* using
semicolons.

A = [a; a]

A = 1 2 3 4 5 6 7 8 10 1 2 3 4 5 6 7 8 10

Complex numbers have both real and imaginary parts, where the imaginary unit is the square root of –1.

sqrt(-1)

ans = 0.0000 + 1.0000i

To represent the imaginary part of complex numbers, use either `i` or `j`.

c = [3+4i, 4+3j; -i, 10j]

c = 3.0000 + 4.0000i 4.0000 + 3.0000i 0.0000 - 1.0000i 0.0000 +10.0000i

Was this topic helpful?