Note: This page has been translated by MathWorks. Please click here

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

To view all translated materials including this page, select Japan from the country navigator on the bottom of 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]

```
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?