*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]

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?