Davrot: Created page with "Questions to [mailto:davrot@uni-bremen.de David Rotermund] ''By Jan Wiersig, modified by Udo Ernst and translated into English by Daniel Harnack.'' A great advantage of Matlab is that all variables are matrices (or, more general, arrays). The benefits of this principle are manifold: They encompass the simplicity of the syntax to formulate complex mathematical operations, avoidance of tedious for-loops and optimization of internal processing of huge amounts of data res..."

2025-10-23T14:05:20Z

Created page with "Questions to [mailto:davrot@uni-bremen.de David Rotermund] ''By Jan Wiersig, modified by Udo Ernst and translated into English by Daniel Harnack.'' A great advantage of Matlab is that all variables are matrices (or, more general, arrays). The benefits of this principle are manifold: They encompass the simplicity of the syntax to formulate complex mathematical operations, avoidance of tedious for-loops and optimization of internal processing of huge amounts of data res..."

New page

Questions to [mailto:davrot@uni-bremen.de David Rotermund]

''By Jan Wiersig, modified by Udo Ernst and translated into English by Daniel Harnack.''

A great advantage of Matlab is that all variables are matrices (or, more general, arrays).

The benefits of this principle are manifold: They encompass the simplicity of the syntax to formulate complex mathematical operations, avoidance of tedious for-loops and optimization of internal processing of huge amounts of data resulting in considerable acceleration of the program.

== Basic Syntax ==
The easiest definition of vectors and matrices is to put the elements of a matrix between square brackets. Column vectors are treated in Matlab as matrices of dimension <math display="inline">\;N\times 1</math> , row vectors as matrices of dimension <math display="inline">\;1\times N</math> and scalars (i.e. plain numbers) as matrices of dimension <math display="inline">\;1\times 1</math>.Rows are divided from other rows by the use of a semi-colon, and columns are separated by commata (oder simply by a blank space, as in the last of the following examples). Examples:
{| class="wikitable"
|scalar
|<code>a_scalar = 1;</code>
|1x1-matrix
|-
|column vector
|<code>a_column = [1; 2; 3];</code>
|3x1-matrix
|-
|row vector
|<code>a_row = [1, 2, 3];</code>
|1x3-matrix
|-
|matrix
|<code>a_fullmatrix = [1 2 3; 4 5 6; 7 8 9];</code>
|3x3-matrix
|}
The same rules that subsume single elements or variables to a vector also apply for strings and so-called cell-arrays:<syntaxhighlight lang="matlab">b = ['A ' 'character' 'string' 'of four elements'];

c = {rand([4 4]) 1:17 complex(42) 'this is a cell of a cell-array!'};</syntaxhighlight>For the ones interested to dive deeper into Matlab: Note that cell-arrays are extremely useful to save several aspects of data in the same variable. An example from the laboratory would be a variable that holds the measured data, a date for the day of recording, a description of the experimental setup in a string and the parameters of recording. Furthermore, structures exist, whose constituent parts have names that can be accessed with a syntax similar to the programming language C.

== Definition of Matrices and Arrays ==
Simple vectors can be defined with the already mentioned colon-operator. The syntax is start value:step width:end value. If the step width is omitted, the default step width of <math display="inline">1</math> is used. Examples:

<code>1:7</code> creates a vector with the numbers 1, 2, 3, 4, 5, 6, 7.

<code>1:2:7</code> creates a vector with the numbers 1, 3, 5, 7.

<code>4:-0.3:2.8</code> creates a vector with the numbers 4.0, 3.7, 3.4, 3.1, 2.8.

The vectors defined in this way shall be assigned to a variable:<syntaxhighlight lang="matlab">p = 0:0.01:100;</syntaxhighlight>Such vectors, if used in loops, will be processed element-wise. In the following example, a vector with the numbers 1, 17 and 42 is printed to the screen element-wise:<syntaxhighlight lang="matlab">to_process = [1 17 42];

for k=to_process;

fprintf('k is %i\n', k);

end</syntaxhighlight>The output is:<syntaxhighlight lang="matlab">k is 1

k is 17

k is 42</syntaxhighlight>Furthermore, the colon operator can be used to access columns, rows or arbitrary dimensions of an array. The colon by '''itself''' selects '''all''' elements of the respective dimension. In the syntax introduced above, the colon operator can also be used to select a specific set of indices of a matrix:

<code>b = a(4, 7:5:17);</code> selects, from the 4. row of the matrix a the entries of the columns 7, 5 and 17. It creates a vector from these elements and assigns it to the variable b.

Bigger matrices and arrays are defined by the commands zeros, ones and eye. The two arguments of these functions assign the number of columns and rows, e.g. <code>fullofzeros = zeros(17, 42);</code>. zeros fills the created matrix with zeros,

ones with ones, and eye creates an identity matrix. More than two arguments result in multidimensional arrays (tensors). There are several shortened notations of these commands. Some examples:
{| class="wikitable"
|<code>z = zeros([1 17]);</code>
|correct creates 1x17-matrix.
|-
|<code>z = zeros(1, 17);</code>
|correct creates 1x17-matrix.
|-
|<code>z = zeros([1, 17]);</code>
|correct creates 1x17-matrix.
|-
|<code>z = zeros(1:17);</code>
|wrong
|}
tries to create a 1x2x3x4x5x6x7x8x9x10x11x12x13x14x15x16x17-matrix

and does not find enough memory!

A similar problem can occur when invoking the commands with only one argument <math display="inline">n</math>. Matlab will try to create a <math display="inline">n</math> x <math display="inline">n</math> -Matrix instead of a <math display="inline">1</math> x <math display="inline">n</math> -vector (which might have been intended).
{| class="wikitable"
|<code>z = zeros(1e6);</code>
|wrong tries to create a 1000000x1000000-matrix!
|-
|<code>z = zeros(1, 1e6);</code>
|correct creates a 1x1000000-vector.
|}
'''If you are in doubt, use, as always, the help function!''' Multidimensional arrays lend themselves for example to save the color planes of a digital image. A matrix for that purpose would be created by <code>a = zeros([1024 768 3]);</code>.

As the last command in this series we will cover meshgrid. meshgrid takes two vectors as arguments and duplicate the first vector in the rows of the output matrix. The second vector is duplicated along the columns of the output matrix. The number of duplications of a vector is determined by the number of elements of the other vector. Example:

<code>[x_matrix, y_matrix] = meshgrid(-10:10, -10:10);</code> creates two matrices, whose entries of the columns resp. of the rows range from <math display="inline">-10</math> to <math display="inline">10</math>. This command is suitable to define coordinate axes for two-dimensional plots. An example can be found in the chapter ‘Graphics in Matlab’.

When working with initializations and arrays, it is important to be aware of how the contents of these arrays are administrated in the computer. Matlab hides many tasks form our eyes, that have to be attended to in many other programming languages first before being able to work with variables and arrays.

One of these tasks is the declaration of variables. In a ‘proper’ programming language, one has to determine the type of a variable when introducing it. Different types are floating-point numbers, integers, strings, etc.

If a numerical value is assigned to a variable, Matlab automatically assumes that the type of the variable is intended to be a double-precision floating-point number. Other types have to be created by an explicit type conversion.

Another task is the allocation and deallocation of memory: An array needs memory to be represented in the computer. Before the variable can be used, the computer has to be advised first to reserve a fitting space in the memory for this variable (just as a real estate has to be bought first before one is allowed to start building a house on it). In the same manner, memory has to be freed again if it is no longer needed (to prevent that empty real estates are left in the memory that block the space from other house builders). Matlab hides these processes and does all the administrative work for us. This can become critical if one writes into a variable that was previously undefined. For example the command clear; a(100000)=pi; creates a vector with <math display="inline">100000</math> entries, and only in the <math display="inline">100000</math>-th entry the number <math display="inline">\pi</math> is written. If the range of the vector, for which only <math display="inline">100000</math> elements were reserved, is now exceeded by writing a(100001)=pi;, the following will happen:

* a new vector with <math display="inline">100001</math> elements is created.
* into element <math display="inline">100001</math>, <math display="inline">2\pi</math> is written.
* the elements <math display="inline">1</math> bis <math display="inline">100000</math> are copied from the old to the new vector.
* the memory allocated by the old vector is deallocated.
* the new vector takes the name of the old vector.

…a lot of effort to append an element. This is why you should always keep in mind to properly define and initialize arrays (with zeros or ones) before using them!

== Simple, predefined Vector Operations ==
Matlab is capable to process all elements of a vector or a matrix in one go:<syntaxhighlight lang="matlab">a = rand([1 17]);

b = rand([1 17]);

c = a+b;</syntaxhighlight>The mathematical equivalent is <math display="inline">c_i=a_i+b_i</math>, <math display="inline">\forall i=1,\ldots,17</math>.

Vectors and matrices have to match in their dimensions;

A prerequisite for the Addition of arrays is that all dimensions have the same size. The same holds for subtraction.

Element-wise multiplication, division and exponentiation is indicated by a preceded dot:<syntaxhighlight lang="matlab">c_mult = a.*b;

c_div = a./b;</syntaxhighlight>This convention was introduced in Matlab to tell apart the element-wise multiplication from the matrix multiplication.
{| class="wikitable"
|<code>C = [1,1;0,1];</code>
|defines the <math display="inline">2\times 2</math> matrix
|<math display="inline">C = \left(\begin{array}{ccc}1 & 1\\0 & 1\\\end{array}\right)</math>
|-
|<code>D = [1,2;3,1];</code>
|defines the <math display="inline">2\times 2</math> matrix
|<math display="inline">D = \left(\begin{array}{ccc}1 & 2\\3 & 1\\\end{array}\right)</math>
|-
|<code>G = C*D;</code>
|gives
|<math display="inline">G = \left(\begin{array}{ccc}4 & 3\\3 & 1\\\end{array}\right)</math>
|}
The mathematical equivalent is <math display="inline">G_{kl} = \sum_{j}C_{kj}D_{jl}</math>.

Transposing a matrix <math display="inline">C^t_{kl} = C_{lk}</math> is done by
{| class="wikitable"
|<code>K = C';</code>
|gives
|<math display="inline">K = \left(\begin{array}{ccc}1 & 0\\1 & 1\\\end{array}\right)</math>
|}
The function <code>transpose(C)</code> can be utilized alternatively.

Inverting a matrix is accomplished by
{| class="wikitable"
|<code>M = D^-1;</code>
|gives
|<math display="inline">M = \left(\begin{array}{ccc}-0.2 & 0.4 \\ 0.6 & -0.2\\ \end{array}\right)</math>
|}
resp. <code>M = inv(D);</code>. Assuming a system of equations

<math display="inline">D\,\vec{x} = \vec{b}</math> and the vector <math display="inline">\vec{b}</math> with

<math display="inline">\vec{b} = \left(\begin{array}{c}3\\ 1\\\end{array}\right) \,</math>

is given, the solution, by using the inverse, is found in Matlab by:

<math>\left(\begin{array}{c} x\\ y\\ \end{array}\right) = M \left(\begin{array}{c}3 \\ 1\\ \end{array}\right) = \left(\begin{array}{c}-0.2 \cdot 3 + 0.4 \cdot 1 \\ 0.6 \cdot 3 - 0.2 \cdot 1 \\ \end{array}\right)= \left(\begin{array}{c}-0.2 \\ 1.6 \\ \end{array}\right)</math>.

The solution of a system of equations can also be found by using the non-inverted matrix and one of the symbols <math display="inline">/</math>, <math display="inline">\backslash</math> resp. the commands mldivide and mrdivide.

Important in a physical or geometrical context is the cross product of two vectors, which is realized in Matlab by the command cross:<syntaxhighlight lang="matlab">a = [0; 0; 1];

b = [1; 0; 0];

c = cross(a, b);

c</syntaxhighlight>The output of these lines is:<syntaxhighlight lang="matlab">c =

0

1

0</syntaxhighlight>

== Reshaping, Copying and Duplication of Matrices/Arrays ==
A useful command to reorganize data is reshape. The content of the array is not altered by this command, only the organization in columns and rows, respectively the other dimensions. The syntax is <code>result = reshape(array, [dim1 dim2 dim3 ... dimN]);</code>.

The result is an array of dimensions <code>dim1</code> to <code>dimN</code>.

The product of these dimension has to equal the product of the '''old''' dimension of the array.

In the following situations, the command is sensibly applied:

* Reshaping of arrays to a form that is suitable for vector operations. Let us assume that we have <math display="inline">8</math> vectors of <math display="inline">10</math> constellations each in a <math display="inline">3</math> x <math display="inline">8</math> x <math display="inline">10</math> -array wit the name <math display="inline">r</math>. Now we want to rotate the vectors with a rotation matrix <math display="inline">D</math> ,to simulate the movement of the night sky:
<syntaxhighlight lang="matlab">dummy = D*reshape(r, [3 80]);

r = reshape(dummy, [3 8 10]);</syntaxhighlight>We first reshaped the <math display="inline">8</math> x <math display="inline">10</math> -matrix of vectors to form a <math display="inline">800</math> -element vector, then we applied the rotation and finally brought the result matrix back to its original form.

* Interpretation of data, that was initially written from a file into a one-dimensional array. Example:
<syntaxhighlight lang="matlab">f = fopen('digitalfphoto.bin', 'r');

a = fread(f, 'uint8=>uint8');

fclose(f);

imagesc(reshape(a, [500 375 3]));

set(gca, 'DataAspectRatio', [1 1 1]);</syntaxhighlight>The second to last command reshaped the array to enable the usage of imagesc to display the image correctly.

In the last example, the Matlab user might be annoyed that the imagesc-command projects the first dimension of the array (with length 500, thus e.g. the <math display="inline">x</math> -axis of a photo in landscape format!) onto the <math display="inline">y</math> -axis. The versatile command permute remedies this situation – this command '''swaps''' single dimensions of an array. It is important to understand that not only the organization of an array in rows and columns is changed, but also the sequence of the entries in the memory! The syntax of the command is <code>permuted = permute(array, [dimidx_dim1, dimidx_dim2, ..., dimidx_dimN]);</code>. Here, the second argument holds the numbers from <math display="inline">1</math> to <math display="inline">N</math> (where <math display="inline">N</math> is the number of dimensions of an array, i.e. <math display="inline">N=2</math> for a matrix), that specify the permutation of the dimensions. In the array permuted, the first dimension will be the dimidx_dim1-th dimension of the old array array, the second dimension the dimidx_dim2-th dimension of the old array, etc.

In order to display the digital photo from our example correctly, we thus have to type:<syntaxhighlight lang="matlab">a_permuted = permute(reshape(a, [500 375 3]), [2 1 3]);

imagesc(a_permuted);</syntaxhighlight>This interchanges the <math display="inline">x</math> - and the <math display="inline">y</math> - direction, while the color information is preserved in the third dimension.

<code>repmat</code>, another important command, duplicates an array or matrix along one or several dimensions. The syntax is similar to reshape,<syntaxhighlight lang="matlab">result = repmat(array, [rep_dim1 rep_dim2 rep_dim3 ... rep_dimN]);</syntaxhighlight>The matrix array is cloned

<code>rep_dim1</code>-times along the first dimension, rep_dim2-times along the second dimension, etc.

For example, the following commands,<syntaxhighlight lang="matlab">a = [1 2; 3 4];

repmat(a, [3 4])</syntaxhighlight>give the output:<syntaxhighlight lang="matlab">ans =

1 2 1 2 1 2 1 2

3 4 3 4 3 4 3 4

1 2 1 2 1 2 1 2

3 4 3 4 3 4 3 4

1 2 1 2 1 2 1 2

3 4 3 4 3 4 3 4</syntaxhighlight>Using this command makes sense, if matrix operations are repeated with different operands on the same initial vector. An example may be found in the section ‘vectorization’.

== What Size does an Array have? ==
Especially when manipulating a lot of different arrays, when a function is supposed to operate on an array of previously unknown size or when one wants to find out whether two arrays are compatible to serve as an input to a matrix operation, the following commands will be helpful: size, length and numel.

It follows a short explanation for their function:

* <code>size</code> returns the size of an array in a vector that has as many elements as the array has dimensions. Example:
<syntaxhighlight lang="matlab">size(zeros([17 42]))

ans =

17 42</syntaxhighlight>

* <code>length</code>

returns the longest dimension of an array, irrespective of which dimension this is. Example:<syntaxhighlight lang="matlab">length(zeros([17 42]))

ans =

42</syntaxhighlight><syntaxhighlight lang="matlab">length(zeros([42 17]))

ans =

42</syntaxhighlight>

* <code>numel</code> returns the total number of all elements of an array and is identical with the construct <code>prod(size(array));</code>. Example:
<syntaxhighlight lang="matlab">numel(zeros([17 42]))

ans =

714</syntaxhighlight>

== Example: Vectorization of a Program ==
To close this chapter, we will discuss two examples of what to do when vectorizing a program. First, consider the problem of generating a <math display="inline">N</math> x <math display="inline">N</math> -Matrix with entries <math display="inline">a_{ij} = i \cdot j</math>.

The tedious way via loops looks like this:<syntaxhighlight lang="matlab">N = 17;

a1 = zeros([N N]);

for i=1:N,
for j=1:N;
a1(i, j) = i*j;
end;
end</syntaxhighlight>It is much simpler to first create a row vector of the numbers <math display="inline">1</math> bis <math display="inline">N</math>, and subsequently duplicate this this vector via repmat to obtain a <math display="inline">N</math> x <math display="inline">N</math> -matrix. Finally, this matrix is multiplied element-wise with its transpose:<syntaxhighlight lang="matlab">N = 17;

onefold = 1:N;

manifold = repmat(onefold, [N 1]);

a2 = manifold.*manifold';</syntaxhighlight>However, this is still not yet the pinnacle of elegance that can be reached. Thinking a little about this problem, one might come to the conclusion that the mathematical operation that is intended can be described as a matrix multiplication of a <math display="inline">N</math> x <math display="inline">1</math> -matrix with a <math display="inline">1</math> x <math display="inline">N</math> -matrix (the so-called outer product of two vectors):<syntaxhighlight lang="matlab">N = 17;

onefold = 1:N;

a3 = onefold'*onefold;</syntaxhighlight>As a second example we consider the following program: It defines two vectors with <math display="inline">x</math> - and <math display="inline">y</math> -coordinates, performs a translation of these coordinates and finally a rotation.<syntaxhighlight lang="matlab">%%% Example: before vectorizing

x = [ 0 -1 0 -2 0 -3 0 -4 0 -5 0 0 ...
0 5 0 4 0 3 0 2 0 1 0];
y = [ 6 4 4 2 2 0 0 -2 -2 -4 -4 -6 ...
-4 -4 -2 -2 0 0 2 2 4 4 6];

%%% Translation in x- and y-direction
trans_x = 4;
trans_y = -4;

%%% Rotation
phi = pi/4;

n = numel(x);
for i=1:n

%%% apply translation to x,y
x(i) = x(i)+trans_x;
y(i) = y(i)+trans_y;

end

for i=1:n

%%% apply rotation to x,y
x_temp = x(i)*cos(phi)+y(i)*sin(phi);
y_temp = -x(i)*sin(phi)+y(i)*cos(phi);

x(i) = x_temp;
y(i) = y_temp;

end</syntaxhighlight>As a first step, we can subsume the <math display="inline">23</math> coordinate-tuple to a <math display="inline">2x23</math> -matrix, that we call r:<syntaxhighlight lang="matlab">r = [x; y];</syntaxhighlight>Here we used the semicolon to stack the row vectors on top of each other. Every column of the matrix r now holds a coordinate tuple. In the next step, we rewrite the translation vector as well as a column vector:<syntaxhighlight lang="matlab">trans = [trans_x; trans_y];</syntaxhighlight>Now we might be tempted to replace the first for-loop by an element-wise addition of trans and r. But beware! The dimensions of both variables are not compatible, trans has only one column. Thus we use the command repmat, to duplicate trans <math display="inline">23</math> times. After this we can perform the addition:<syntaxhighlight lang="matlab">r = r+repmat(trans, [1 size(trans, 2)]);</syntaxhighlight>Here, we used the command size to avoid having to use the constant 23 – the code will thus also work with other, longer or shorter variables x or y.

Next up is the rotation. The rotation matrix <code>D</code> is quickly defined,<syntaxhighlight lang="matlab">D = [cos(phi) sin(phi); -sin(phi) cos(phi)];</syntaxhighlight>and equally quickly applied to <code>r</code>:<syntaxhighlight lang="matlab">r = D*r;</syntaxhighlight>In the end, we assign the result again to the variables x and y . For this we use the colon-operator that selects whole rows of the matrix r:<syntaxhighlight lang="matlab">x = r(1, :);

y = r(2, :);</syntaxhighlight>We can even integrate rotation and translation:<syntaxhighlight lang="matlab">r = D*(r+repmat(trans, [1 size(r, 2)]));</syntaxhighlight>This gives the vectorized program code:<syntaxhighlight lang="matlab">%%% Example: AFTER vectorization

x = [ 0 -1 0 -2 0 -3 0 -4 0 -5 0 0 ...
0 5 0 4 0 3 0 2 0 1 0];
y = [ 6 4 4 2 2 0 0 -2 -2 -4 -4 -6 ...
-4 -4 -2 -2 0 0 2 2 4 4 6];

%%% Translation in x- and y-direction
trans_x = 4;
trans_y = -4;

%%% Rotation
phi = pi/4;

%%% Definition of the vectors
r = [x; y];
trans = [trans_x; trans_y];
D = [cos(phi) sin(phi); -sin(phi) cos(phi)];

%%% Two to three loops vectorized:
r = D*(r+repmat(trans, [1 size(r, 2)]));

%%% assign the result
x = r(1, :);
y = r(2, :);</syntaxhighlight>

Vectorization and Vector Calculus in Matlab - Revision history