CHAPTER 4

Numerical Variables, Vectors and Matrices

4.1 Variables

The concept of variable, like the concept of function, is essential when working with mathematical software. Obviously, the theoretical concept of a mathematical variable is fixed and independent of the software package, but how to implement and manage variables is very characteristic of each particular program. MATLAB allows you to define and manage variables, and store them in files, in a very simple way.

When extensive calculations are performed, it is convenient to give names to intermediate results. Each intermediate result is assigned to a variable to make it easier to use. For example, we can define the variable x and assign the value 5 to it in the following way:

>> x = 5

x =

     5

From now on, whenever the variable x appears it will be replaced by the value 5, and it will not change its value until it is redefined.

>> x ^ 2

ans =

    25

The variable x will not change until we explicitly assign another value to it.

>> x = 7 + 4

x =

    11

From this moment on, the variable x will take the value 11.

It is very important to stress that the value assigned to a variable will remain fixed until it is expressly changed or if the current MATLAB session is closed. It is common to forget the definitions given to variables during a MATLAB session, causing misleading errors when the variables are used later in the session. For this reason, it is convenient to be able to remove the assignment of a value to a variable. This operation is performed by using the command clear. It is also useful to recall the variables we have defined in the present session, which is done using the command who:

• The expression x = value assigns the value value to the variable x.
• The command clear removes the value assigned to all variables.
• The command clear x removes the value assigned to the variable x.
• The command clear x y removes the value assigned to the variables x and y.
• The command who gives the names of all variables currently in memory (variables in the workspace).
• The command whos gives the names, sizes, number of items, bytes occupied, and the type of all variables currently in memory.

Here are some examples that use the variable handling commands defined above:

>> x = 7, y = 4 + i, z = sqrt (3)

x =

    7

y =

    4.0000 + 1. 0000i

z =

    1.7321

>> p=x+y+z

p =

    12.7321 + 1. 0000i

>> who

Your variables are:

ans       p         x         y         z

>> whos
              Name Size   Elements Bytes Density Complex

               ANS 1 by 1    1        8     Full    No
                 p 1 by 1    1        16    Full    Yes
                 x 1 by 1    1        8     Full    No
                 y 1 by 1    1        16    Full    Yes
                 z 1 by 1    1        8     Full    No

Grand total is 5 elements using 56 bytes

Now we are going to change the value of the variable y, and delete the variable x.

>> y = pi

y =

    3.1416

>> clear x;
>> whos

              Name Size   Elements Bytes Density Complex

               ANS 1 by 1    1        8     Full    No
                 p 1 by 1    1        16    Full    Yes
                 y 1 by 1    1        8     Full    No
                 z 1 by 1    1        8     Full    No

Grand total is 4 elements using 40 bytes

We see that the variable x has disappeared and that the variable y has the new value assigned, but the variable p has not changed, despite having changed two of its components. For an expression that contains a variable whose value has been changed, to update its value it is necessary to rerun it:

>> p=y+z

p =

    4.8736

>> whos
              Name Size   Elements Bytes Density Complex

               ANS 1 by 1   1        8      Full    No
                 p 1 by 1   1        8      Full    No
                 y 1 by 1   1        8      Full    No
                 z 1 by 1   1        8      Full    No

Grand total is 4 elements using 32 bytes

Now all values are updated, including that of p.

As for the names that can be given to the variables, the only restriction is that they cannot start with a number or contain punctuation characters that are assigned a special meaning in MATLAB. It is also advisable to name variables with words that begin with lowercase letters, and in general with words completely in lowercase. This avoids collisions with MATLAB functions beginning with an uppercase letter. MATLAB is case sensitive. There can be any number of characters in the name of a variable, but MATLAB will handle only the first 19.

4.2 Variables and Special Constants

In many kinds of calculations we need to work with variables and special constants that the program has enabled. Here are some examples:

• PI or maple(‘PI’): 3.1415926535897...
• i or j or maple(‘i’): imaginary unit (square root of -1).
• inf or maple(‘infinity’): infinity, returned for example when presented with 1/0.
• NaN (Not a Number): indeterminate, returned for example when presented with 0/0.
• realmin: the smallest usable positive real number.
• realmax: the greatest usable positive real number.
• finite(x): returns 1 if x is finite and zero otherwise.
• isinf(x): returns 1 if x is infinity or -infinity, and zero otherwise.
• isNaN(x): returns 1 if x is undetermined and zero otherwise.
• isfinite(x): returns 1 if x is finite and zero otherwise.
• ana: automatically creates a variable to represent the last unmapped processing result which has not been assigned to a variable.
• eps: returns the distance from 1.0 to the next largest double-precision number. This is the default tolerance for floating-point operations (floating point relative accuracy). In current IEEE machines its value is 2 ^ (-52).
• isieee: returns 1 if the machine is IEEE and 0 otherwise.
• computer: returns the type of the computer.
• flops: returns the number of floating point operations that have been executed in a session (flops(0) resets the operations counter).
• version: returns the current version of MATLAB.
• why: returns a concise message.
• cputime: returns CPU time in seconds used by MATLAB since the beginning of the session.
• clock: returns a list consisting of the following 6 items: [year month day hour minutes seconds].
• date: returns the current calendar date.
• etime: returns the time elapsed between two clock type lists (defined above).
• tic: enables a temporary counter in seconds that ends with the use of the variable toc.
• toc: returns the elapsed time in seconds since the variable tic was activated.
• LastErr: returns the last error message.
• See: gives information about the program and its Toolbox.
• Info: provides information about MATLAB.
• subscribe to: gives information about the subscription to MATLAB.
• whatsnew: provides information about new undocumented MATLAB features.

Here are some examples:

First we check if our computer is an IEEE machine, determine what type of computer it is, and find the current date and time:

>> isieee

ans =

     1

>> computer

ans =

PCWIN

>> clock

ans =

  1. 0e + 003 *

    1.9950 0.0110 0.0140 0.0100 0.0150 0.0079

>> date

ans =

14-mar-99

Now we check the CPU time (in seconds) that has passed since the beginning of the MATLAB session, as well as the number of floating-point operations that have occurred during that time:

>> cputime

ans =

   23.5100

>> flops

ans =

 1180

4.3 Symbolic and Numeric Variables

MATLAB deems as symbolic any algebraic expression whose variables have previously been defined as symbolic via the command syms. For example, if we want to treat as symbolic the expression 6ab + 3a² + 2ab in order to simplify it, we need to declare the two variables a and b as symbolic as shown below:

>> syms a b
>> simplify(6*a*b + 3*a^2 + 2*a*b)

ans =

8 * a * b + 3 * a ^ 2

The command sym can be used to transform a numeric expression into a symbolic expression. For example, if we want to simplify the numeric expression 2/5 + 6/10 + 8/20, we first need to transform it into a symbolic expression via sym(2/5+6/10+8/20), making the simplification as follows:

>> simplify (sym(2/5+6/10+8/20))

ans =

7/5

The variables contained in a symbolic expressions must be symbolic. Some commands for working with symbolic and numerical variables are described below:

• syms x y z... t: makes the variables x, y, z,..., t  symbolic.
• syms x y z... t real: makes the variables x, y, z,..., t symbolic with real values.
• syms x y z... t unreal: makes the variables x, y, z,..., t symbolic with non-real values.
• syms: lists the symbolic variables in the workspace.
• x = sym (‘x’): x becomes a symbolic variable (equivalent to syms x).
• x = sym (‘x’, real): x becomes a real symbolic variable.
• x = sym(‘x’,unreal): x becomes a symbolic non-real variable.
• S = sym(A): creates a symbolic variable S from A, where A can be a string, a scalar, an array, a numeric expression, etc.
• S = sym(A,‘option’): converts the array, scalar or numeric expression A to a symbolic variable S according to the specified option. The option  can be ‘f’ for floating point, ‘r’ for rational, ‘e’ for error format and ‘d’ for decimal.
• numeric(x): makes the variable or expression x numeric with double precision.
• sym2poly(poly): converts the symbolic polynomial poly to a vector whose components are its coefficients.
• poly2sym(vector): creates a symbolic polynomial whose coefficients are the components of the vector.
• poly2sym(vector,‘v’): converts a symbolic polynomial in the variable v whose coefficients are the components of the vector.
• digits(d): gives symbolic variables to an accuracy of d significant figures.
• digits: returns the current accuracy for symbolic variables.
• vpa(expr): returns the numerical result of the expression to an accuracy determined by digits.
• vpa(expr, n): returns the numerical result of the expression to n significant figures.
• vpa(‘expr’, n): returns the numerical result of the expression to n significant figures.
• pretty(expr): returns the symbolic expression in the form of standard mathematical script.

4.4 Vector Variables

A variable that represents a vector of length n can be defined in MATLAB in the following ways:

variable = [e1, e2, e3,..., en]
variable = [e1 e2 e3 ... en]

Therefore, to define a vector variable, simply insert the vector elements between brackets separated by commas or blank spaces.

When you apply most MATLAB commands and functions to a vector variable, the result obtained is that found by applying the command or function to each element of the vector:

>> vector1 = [1,3,5,2.3,1/2]

vector1 =

    1.0000 3.0000 5.0000 2.3000 0.5000

>> sin(vector1)

ans =

    0.8415 0.1411 - 0.9589 0.7457 0.4794

>> exp (vector1)

ans =

    2.7183 20.0855 148.4132 9.9742 1.6487

>> log (vector1)

ans =

    0 1.0986 1.6094 0.8329 - 0.6931

There are different ways of defining a vector variable without explicitly bracketing all its elements, separated by commas or blank spaces.

• variable = [first_element:last_element]: Defines the vector whose first and last elements are specified, and the intermediate elements differ by one unit.
• variable = [first_element:increase:last_element]: Defines the vector whose first and last elements are specified, and the intermediate elements differ by the amount specified by the increase.
• variable = linspace (first_element, last_element, n): Defines the vector whose first and last elements are specified, and which has in total n evenly spaced elements.
• variable = logspace (a,b,n): Defines the vector whose first and last elements are 10^a and 10^b, and which has in total n evenly logarithmically spaced elements.

Here are some examples:

>> vector2 = [0:5:20]

vector2 =

     0 5 10 15 20

We have obtained the numbers between 0 and 20 separated by 5 units.

>> vector3 = [0:20]


vector3 =

  Columns 1 through 12

     0     1     2     3     4     5     6     7     8     9    10    11

  Columns 13 through 21

    12 13 14 15 16 17 18 19 20

We have obtained the numbers between 0 and 20 separated by units.

>> vector4 = linspace(0,10,11)

vector4 =

     0     1     2     3     4     5     6     7     8     9    10

We have obtained the numbers between 0 and 10 separated by units.

>> vector5 = linspace(0,20,6)

vector5 =

     0 4 8 12 16 20

We have obtained 6 equally spaced numbers between 0 and 20.

>> vector6 = logspace(0,2,6)

vector6 =

    1.0000 2.5119 6.3096 15.8489 39.8107 100.0000

We have obtained 6 evenly logarithmically spaced numbers between 10⁰ and 10².

We can also consider row and column vectors in MATLAB. A column vector is obtained by separating its elements by semicolons, or by transposing a row vector using a single apostrophe at the end of its definition.

>> a=[1;2;3;4]

a =

     1
     2
     3
     4

>> a=[1:4];b=a'

b =

     1
     2
     3
     4

>> c=(a')'

c =

     1 2 3 4

You can also select an element of a vector or a subset of elements.

• x(n): returns the n-th element of the vector x.
• x(a:b): returns the a-th through b-th elements of the vector x, both inclusive.
• x(a:p:b): returns the a-th through b-th elements of the vector x, both inclusive, each separated from the next by p units (a < b).
• x(b:-p:a): returns the b-th through a-th elements of the vector x, both inclusive, each separated from the next by p units and starting with the b-th (b > a).

Here are some examples:

>> x =(1:10)

x =

     1     2     3     4     5     6     7     8     9    10

>> x(6)

ans =

     6

We have obtained the sixth element of the vector x.

>> x(4:7)

ans =

     4 5 6 7

We have obtained the elements of the vector x located between the fourth and the seventh elements, both inclusive.

>> x(2:3:9)

ans =

     2 5 8

We have obtained the elements of the vector x located between the second and ninth elements, both inclusive, but separated from each other by three units.

>> x(9:-3:2)

ans =

     9 6 3

We have obtained the elements of the vector x located between the ninth and second elements, both inclusive, but separated from each other by three units and starting at the ninth.

Simple mathematical operations between scalars and vectors scale each element of the vector according to the defined operation, and simple operations between vectors are performed elementwise.

Below is a summary of these operations:

• a = {a1, a2,..., an}, b = {b1, b2,..., bn}, c = scalar
• a + c = [a1 + c, a2 + c,..., an + c]: sum of a scalar and a vector
• a * c = [a1 * c, a2 * c,..., an * c]: product of a scalar and a vector
• a + b = [a1 + b1, a2 + b2,... an + bn]: sum of two vectors
• a. * b = [a1 * b1, a2 * b2,... , an * bn]: product of two vectors
• a. / b = [a1/b1 a2/b2... an/bn]: right ratio of two vectors
• a. b = [a11 a22... ann]: left ratio of two vectors
• a. ^ c = [a1 ^ c, a2 ^ c,..., an ^ c]: scalar power of a vector
• c. ^ a = [c ^ a1, c ^ a2,... ,c ^ an]: vector power of a scalar
• a. ^ b = [a1 ^ b1, a2 ^ b2,... ,an ^ bn]: vector power of a vector

It must be borne in mind that the vectors must be of the same length, and that in the product, quotient, and power the first operand is followed by a point.

On the other hand, you can also set the vector variables to be symbolic using the command syms.

>> syms t
>> A=sym([sin(t),cos(t)])

A =

[sin (t), cos (t)]

4.5 Matrix Variables

MATLAB defines matrices by inserting in brackets all its row vectors separated by a semicolon. Vectors can be entered by separating their components by spaces or by commas, as we already know.  For example, a 3 × 3 matrix variable can be entered in the following two ways:

M = [a11 a12 a13;a21 a22 a23;a31 a32 a33]
M = [a11, a12 ,a13;a21, a22, a23;a31, a32, a33]

Similarly we can define a matrix of general dimension (M×N). Once a matrix variable has been defined, MATLAB enables many ways to insert, extract, renumber, and generally manipulate its elements. The following list summarizes different ways to define matrix variables.

• A(m,n) defines the (m, n)-th element of the matrix A (row m and column n)
• A(a:b,c:d) defines the subarray of A formed between the a-th and the b-th rows and between the c-th and the d-th columns, inclusive
• A(a:p:b,c:q:d) defines the subarray of A formed by every p-th row between the a-th and the b-th rows, inclusive, and every q-th column between the c-th and the d-th columns, inclusive
• A([a b],[c d]) defines the subarray of A formed by the intersection of the a-th through b-th rows and c-th through d-th columns, inclusive
• A([a b c...],[e f g...]) defines the subarray of A formed by the intersection of rows a, b, c,... and columns e, f, g,...
• A(:,c:d) defines the subarray of A formed by all the rows in A and the c-th through to the d-th columns
• A(:,[c d e ...]) defines the subarray of A formed by all the rows in A and columns c, d, e,...
• A(a:b,:) defines the subarray of A formed by all the columns in A and the a-th through to the b-th rows
• A([a b c...],:) defines the subarray of A formed by all the columns in A and rows a, b, c,...
• A(a,:) defines the a-th row of the matrix A
• A(:,b) defines the b-th column of the matrix A
• A(:) defines a column vector whose elements are the columns of A placed in order below each other
• A(:,:) this is equivalent to the entire matrix A
• [A, B, C,...] defines the matrix formed by the matrices A, B, C,...
• S_A = [] clears the subarray of the matrix A, SA, and returns the remainder
• diag(v) creates a diagonal matrix with the vector v in the diagonal
• diag(A) extracts the diagonal of the matrix as a column vector
• eye(n) creates the identity matrix of order n
• eye(m,n) creates an m×n matrix with ones on the main diagonal and zeros elsewhere
• zeros(m,n) creates the zero matrix of order m×n
• ones(m,n) creates the matrix of order m×n with all its elements equal to 1
• rand(m,n) creates a uniform random matrix of order m×n
• randn(m,n) creates a normal random matrix of order m×n
• flipud(A) returns the matrix whose rows are those of A but placed in reverse order (from top to bottom)
• fliplr(A) returns the matrix whose columns are those of A but placed in reverse order (from left to right)
• rot90(A) rotates the matrix A counterclockwise by 90 degrees
• reshape(A,m,n) returns an m×n matrix formed by taking consecutive entries of A by columns
• size(A) returns the order (size) of the matrix A
• find(cond_A) returns all A items that meet a given condition
• length(v) returns the length of the vector v
• tril(A) returns the lower triangular part of the matrix A
• triu(A) returns the upper triangular part of the matrix A
• A' returns the transpose of the matrix A
• inv(A) returns the inverse of the matrix A

Here are some examples:

We consider first the 2 × 3 matrix whose rows are the first six consecutive odd numbers:

>> A = [1 3 5; 7 9 11]

A =

1 3 5
7 9 11

Now we are going to change the (2,3)-th element, i.e. the last element of A, to zero:

>> A(2,3) = 0

A =

1 3 5
7 9 0

We now define the matrix B to be the transpose of A:

>> B = A'

B =

1 7
3 9
5 0

We now construct a matrix C, formed by attaching the identity matrix of order 3 to the right of the matrix B:

>> C = [B eye (3)]

C =

1     7     1     0     0
3     9     0     1     0
5     0     0     0     1

We are going to build a matrix D by extracting the odd columns of the matrix C, a matrix E formed by taking the intersection of the first two rows of C and its third and fifth columns, and a matrix F formed by taking the intersection of the first two rows and the last three columns of the matrix C:

>> D = C(:,1:2:5)

D =

1 1 0
3 0 0
5 0 1

>> E = C([1 2],[3 5])

E =

1 0
0 0


>> F = C([1 2],3:5)

F =

1 0 0
0 1 0

Now we build the diagonal matrix G such that the elements of the main diagonal are the same as those of the main diagonal of D:

>> G = diag(diag(D))

G =

1 0 0
0 0 0
0 0 1

We then build the matrix H, formed by taking the intersection of the first and third rows of C and its second, third and fifth columns:

>> H = C([1 3],[2 3 5])

H =

7 1 0
0 0 1

Now we build an array I formed by the identity matrix of order 5 × 4, appending the zero matrix of the same order to its right and to the right of that, the unit matrix, again of the same order. Then we extract the first row of I and, finally, form the matrix J comprising the odd rows and even columns of I and calculate its order (size).

>> I = [eye(5,4) zeros(5,4) ones(5,4)]

ans =

1     0     0     0     0     0     0     0     1     1     1     1
0     1     0     0     0     0     0     0     1     1     1     1
0     0     1     0     0     0     0     0     1     1     1     1
0     0     0     1     0     0     0     0     1     1     1     1
0     0     0     0     0     0     0     0     1     1     1     1


>> I(1,:)

ans =

1     0     0     0     0     0     0     0     1     1     1     1


>> J = I(1:2:5,2:2:12)

J =

0     0     0     0     1     1
0     0     0     0     1     1
0     0     0     0     1     1

>> size(J)

ans =

3 6

We now construct a random matrix K of order 3 × 4, reverse the order of the rows of K, reverse the order of the columns of K and then perform both operations simultaneously. Finally, we find the matrix L of order 4 × 3 whose columns are obtained by taking the elements of K sequentially by columns.

>> K = rand(3,4)

K =

0.5269    0.4160    0.7622    0.7361
0.0920    0.7012    0.2625    0.3282
0.6539    0.9103    0.0475    0.6326

>> K(3:-1:1,:)

ans =

0.6539    0.9103    0.0475    0.6326
0.0920    0.7012    0.2625    0.3282
0.5269    0.4160    0.7622    0.7361

>> K(:,4:-1:1)

ans =

0.7361    0.7622    0.4160    0.5269
0.3282    0.2625    0.7012    0.0920
0.6326    0.0475    0.9103    0.6539


>> K(3:-1:1,4:-1:1)

ans =

0.6326    0.0475    0.9103    0.6539
0.3282    0.2625    0.7012    0.0920
0.7361    0.7622    0.4160    0.5269

>> L = reshape(K,4,3)

L =

0.5269 0.7012 0.0475
0.0920 0.9103 0.7361
0.6539 0.7622 0.3282
0.4160 0.2625 0.6326

4.6 Character Variables

MATLAB is a powerful numerical calculation program, but it is also a versatile character variable (i.e. text) manipulator. A character variable (or chain) is simply a string of characters contained within single quotes that MATLAB interprets as a vector form. For example:

>> c = 'string'

c =

character string

We have thus defined the character variable c. Among the MATLAB commands that handle character variables we have the following:

• abs(‘character_string’) returns the array of ASCII characters equivalent to each character in the string
• setstr(numeric_vector) returns the string of ASCII characters that are equivalent to the elements of the vector
• str2mat(t1,t2,t3,...) returns the matrix whose rows are the strings t1, t2, t3,..., respectively
• str2num(‘string’) converts the string to its exact numeric value used by MATLAB
• num2str(number) returns the exact number in its equivalent string with fixed precision
• int2str(integer) converts the integer to a string
• sprintf(‘format’, a) converts a numeric array into a string in the specified format
• sscanf(‘string’, ‘format’) converts a string to a numeric value in the specified format
• dec2hex(integer) converts a decimal integer into its equivalent string in hexadecimal
• hex2dec(‘string_hex’) converts a hexadecimal string into its integer equivalent
• hex2num(‘string_hex’) converts a hexadecimal string into the equivalent IEEE floating point number
• lower(‘string’) converts a string to lowercase
• upper(‘string’) converts a string to uppercase
• strcmp(s1,s2) compares the strings s1 and s2 and returns 1 if they are equal and 0 otherwise
• strcmp(s1,s2,n) compares the strings s1 and s2 and returns 1 if their first n characters are equal and 0 otherwise
• strrep(c,‘exp1’, ‘exp2’) replaces exp1 by  exp2 in the chain c
• findstr(c, ‘exp’) finds where exp is in the chain c
• isstr(expression) returns 1 if the expression is a string and 0 otherwise
• ischar(expression) returns 1 if the expression is a string and 0 otherwise
• strjust(string) right justifies the string
• blanks(n) generates a string of n spaces
• deblank(string) removes blank spaces from the right of the string
• eval(expression) executes the expression, even if it is a string
• disp(‘string’) displays the string (or array) as written, and continues the MATLAB process
• input(‘string’) displays the string on the screen and waits for a key press to continue

Here are some examples:

>> eval ('4 * atan(1)')

ans =

    3.1416

This shows how MATLAB numerically evaluates the contents of a string (according to the program’s standard interpretation of the syntax).

>> hex2dec ('3ffe56e')

ans =

    67102062

 MATLAB has converted a hexadecimal string to a decimal string.

>> dec2hex (1345679001)

ans =

    50356E99

The program has converted a decimal string to a hexadecimal string.

>> sprintf('%f',[1+sqrt(5)/2,pi])

ans =

 2.118034 3.141593

The exact numerical components of a vector have been converted to a string (to default precision).

>> sscanf('121.00012','%f')

ans =

  121.0001

A numeric string has been passed to exact numerical format (with default precision). Later we will see which alternative formats are possible.

>> num2str(pi)

ans =

3.142

The exact number π has been approximated to default precision and converted to a string.

>> str2num('15/14')

ans =

    1.0714

A string representing a rational number has been approximated to default precision and converted to a string.

>> setstr(32:126)

ans =

!"#$% &' () * +, -. / 0123456789:; < = >? @ABCDEFGHIJKLMNOPQRSTUVWXYZ [] ^ _'abcdefghijklmnopqrstuvwxyz {|}~

The ASCII characters associated with whole numbers between 32 and 126 have been generated.

>> abs('{]}><#¡¿?°ª')

ans =

   123 93 125 62 60 35 161 191 63 186 170

The integers corresponding to the given ASCII characters have been generated.

>> lower('ABCDefgHIJ')

ans =

abcdefghij

The given string has been converted to lowercase text.

>> upper('abcd eFGHi jKlMn')

ans =

ABCD EFGHI JKLMN

The given string has been converted to uppercase text.

>> str2mat(' The world ',' The country ',' Daily 16 ', ' ABC ')

ans =

The world
The country
Daily 16
ABC

The chains given as arguments of the command str2mat have been converted into rows of an array.

>> disp('This text will appear on the screen')

This text will appear on the screen

The argument of the command disp is displayed on screen.

>> c = 'this is a good example';
>> strrep(c, 'good', 'bad')

ans =

this is a bad example

The string good has been replaced by the string bad in the string c.

>> findstr(c, 'is')

ans =

     3 6

The positions of the first character of the string is in c are given.

4.7 Operators

MATLAB features arithmetic, logical, relational, conditional and structural operators.

4.7.1 Arithmetic Operators

There are two types of arithmetic operators in MATLAB: matrix arithmetic operators, which are governed by the rules of linear algebra, and arithmetic operators on vectors, which are performed elementwise. The operators involved, which we have already seen, are summarized below.

• +       Sum of scalars, vectors or matrices
• -        Subtraction of scalars, vectors, or matrices
• *        Product of scalar or matrix
• . *      Product of scalar or vector
•        AB = inv (A) * B, where A and B are matrices
• .       A. B = [B(i,j) /A (i, j)] where A and B vectors (dim (A) = dim (B))
• /        Quotient, or B/A = B * inv (A), where A and B are matrices
• ./       A ./ B = [A(i,j)/B (i, j)], where A and B are vectors [dim (A) = dim (B)]
• ^        Power of a scalar or matrix (M^p)
• . ^       Power of vectors (A. ^ B = [A(i,j)^{B (i, j)}], for vectors A and B)

4.7.2 Relational Operators

MATLAB also provides relational operators. Relational operators perform element by element comparisons between two matrices and return an array of the same size whose elements are one if the corresponding relationship is true, or zero if the corresponding relation is false. The relational operators can also compare scalars with vectors or matrices, in which case the scalar is compared to all the elements of the array. Below is a summary of these operators.

• <         less than (for complex numbers this applies only to the real parts)
• < =      less than or equal (only applies to real parts of complex numbers)
• >         greater than (only applies to real parts of complex numbers)
• > =      greater than or equal (only applies to real parts of complex numbers)
• x == y  equality (also applies to complex numbers)
• x ~ = y  inequality (also applies to complex numbers)

Here are some examples:

>> X = 5 * ones(3,3); X > = [1 2 3; 4 5 6 ; 7 8 9]

ans =

     1 1 1
     1 1 0
     0 0 0

The elements of the array X which are greater than or equal to the corresponding element of the matrix [1 2 3; 4 5 6; 7 8 9] are given the value 1 in the response matrix. The rest of the elements are assigned the value 0 (the result of the operation would have been the same if we had compared the scalar 5 to the matrix [1 2 3; 4 5 6; 7 8 9] using the expression X = 5; X > = [1 2 3; 4 5 6; 7 8 9]).

Next we see another example that combines an arithmetic operation with a relational operation:

>> A = 1:9, B = 9-A, Y = A > 4, Z = B-(A>2)

A =

     1     2     3     4     5     6     7     8     9

B =

     8     7     6     5     4     3     2     1     0

Y =

     0     0     0     0     1     1     1     1     1

Z =

     8     7     5     4     3     2     1     0    -1

The values of Y equal to 1 correspond to elements of A larger than 4. The Z values result from subtracting 1 from the corresponding elements of B if the corresponding element of A is greater than 2, or 0 if the corresponding element of A is less than or equal to 2.

4.7.3 Logical Operators

MATLAB provides symbols to denote logical operators. The logical operators shown below offer a way to combine or negate relational expressions.

• ~ A           logical negation (NOT) or the complement of A
• A & B      logical conjunction (AND) or the intersection of A and B
• A | B         logical disjunction (OR) or the union of A and B
• xor(A,B)  exclusive or (XOR) or the symmetric difference of A and B (gives 1 if A or B, but not both, are 1)

Here are some examples:

>> A = 1:9; P =(A>2) &(A<6)

P =

     0     0     1     1     1     0     0     0     0

Returns 1 when A is greater than 2 and less than 6, and returns 0 otherwise.

>> A=[1 1 2 2 3 4 5 6 7 8 9],P=(A>=1)&(A<6),xor(A,P)

A =

     1     1     2     2     3     4     5     6     7     8     9

P =

     1     1     1     1     1     1     1     0     0     0     0

ans =

     0     0     0     0     0     0     0     1     1     1     1

Returns 1 when A or P, but not both, have the value 1.

4.8 Logic Functions

MATLAB implements logical functions whose output can take the value true (1) or false (0). The following list summarizes the most important logical functions.

• exist(A) checks if the variable or function exists (returns 0 if A does not exist and a number between 1 and 5, depending on the type, if it does exist)
• any(V) returns 0 if all elements of the vector V are null and returns 1 if some element of V is non-zero
• any(A) returns 0 for each column of the matrix A with all null elements and returns 1 for each column of the matrix A which has non-null elements
• all(V)   returns 1 if all the elements of the vector V are non-null and returns 0 if some element of V is null
• all(A) returns 1 for each column of the matrix A with all non-null elements and returns 0 for each column of the matrix A with at least one null element
• find(V)  returns the places (or indices) occupied by the non-null elements of the vector V
• isNaN(V)   returns 1 for the elements of V that are indeterminate and returns 0 for those that are not
• isinf(V)    returns 1 for the elements of V that are infinite and returns 0 for those that are not
• isfinite(V)   returns 1 for the elements of V that are finite and returns 0 for those that are not
• isempty(A)  returns 1 if A is an empty array and returns 0 otherwise (an empty array is an array such that one of its dimensions is 0)
• issparse(A) returns 1 if A is a sparse matrix and returns 0 otherwise
• isreal(V) returns 1 if all the elements of V are real and returns 0 otherwise
• isprime(V) returns 1 for all elements of V that are prime and returns 0 for all elements of V that are not prime
• islogical(V) returns 1 if V is a logical vector and 0 otherwise
• isnumeric(V) returns 1 if V is a numeric vector and 0 otherwise
• ishold returns 1 if the properties of the current graph are retained for the next graph and only new elements will be added and 0 otherwise
• isieee returns 1 if the computer is capable of IEEE standard operations
• isstr(S) returns 1 if S is a string and 0 otherwise
• ischart(S)  returns 1 if S is a string and 0 otherwise
• isglobal(A) returns 1 if A is a global variable and 0 otherwise
• isletter(S) returns 1 if S is a letter of the alphabet and 0 otherwise
• isequal(A,B) returns 1 if the matrices or vectors A and B are equal, and 0 otherwise
• ismember(V,W) returns 1 for every element of V which is in W and 0 for every element V that is not in W

Here are some examples:

>> isinf ([pi NaN Inf - Inf])

ans =

     0     0     1     1

>> any([pi NaN Inf -Inf])

ans =

     1

>> ismember([1,2,3,5],[8,12,1,3,56,5])

ans =

     1     0     1     1

>> A=[2,0,1]; B=[4,0,2];
>> isequal(2*A,B)

ans =

     1

>> V=[-10,5,3,12,0];
>> isprime(V)

ans =

     0     1     1     0     0

>> isnumeric(V)

ans =

     1

>> all(V)

ans =

     0

>> any(V)

ans =

     1

>> C=[0 2 3;0 1 2 ;0 4 6],D=[0 0 0 0;4 3 1 2;6 0 0 4]
>> any(C),all(C),any(D),all(D)

ans =

     0 1 1

ans =

     0 1 1

ans =

     1 1 1 1

ans =

     0 0 0 0

4.9 Elementary Functions that Support Complex Matrix Arguments

Here are some examples:

>> A = [1 2 3; 4 5 6; 7 8 9]

A =

     1     2     3
     4     5     6
     7     8     9

>> sin(A)

ans =

    0.8415  0.9093  0.1411
   -0.7568 -0.9589 -0.2794
    0.6570  0.9894  0.4121

>> B=[1+i 2+i;3+i,4+i]

B =

   1.0000 + 1.0000i 2.0000 + 1.0000i
   3.0000 + 1.0000i 4.0000 + 1.0000i

>> sin(B)

ans =

   1.2985 + 0.6350i  1.4031 - 0.4891i
   0.2178 - 1.1634i -1.1678 - 0.7682i

>> exp(A)

ans =

  1. 0e + 003 *

    0.0027 0.0074 0.0201
    0.0546 0.1484 0.4034
    1.0966 2.9810 8.1031

>> exp(B)

ans =

     1.4687 + 2.2874i   3.9923 + 6.2177i
    10.8523 +16.9014i  29.4995 +45.9428i

>> log(B)

ans =

   0.3466 + 0.7854i   0.8047 + 0.4636i
   1.1513 + 0.3218i   1.4166 + 0.2450i

>> sqrt(B)

ans =

   1.0987 + 0.4551i   1.4553 + 0.3436i
   1.7553 + 0.2848i   2.0153 + 0.2481i

The exponential functions, square root and logarithm used above apply to the array elementwise and have nothing to do with the matrix exponential and logarithmic functions that are used below.

>> expm(B)

ans =

  1.0e+002 *

  -0.3071 + 0.4625i  -0.3583 + 0.6939i
  -0.3629 + 1.0431i  -0.3207 + 1.5102i

>> logm(A)

ans =

  -5.6588 + 2.7896i  12.5041 - 0.4325i  -5.6325 - 0.5129i
  12.8139 - 0.7970i -23.3307 + 2.1623i  13.1237 - 1.1616i
  -5.0129 - 1.2421i  13.4334 - 1.5262i  -4.4196 + 1.3313i

>> abs(B)

ans =

    1.4142    2.2361
    3.1623    4.1231

>> imag(B)

ans =

     1     1
     1     1

>> fix(sin(B))

ans =

   1.0000           1.0000
   0 - 1.0000i     -1.0000

>> ceil(log(A))

ans =

     0     1     2
     2     2     2
     2     3     3

>> sign(B)

ans =

   0.7071 + 0.7071i   0.8944 + 0.4472i
   0.9487 + 0.3162i   0.9701 + 0.2425i

>> rem(A,3*ones(3))

ans =

     1     2     0
     1     2     0
     1     2     0

>> funm(B,'sinh')

ans =

 -15.8616 +23.2384i -17.6536 +34.7072i
 -17.7736 +52.1208i -16.2216 +75.4791i

The result of the last function is equivalent to sinh(B), but the algorithm used is different.

4.10 Elementary Functions that Support Complex Vector Arguments

max(V) The maximum component of V. (max is calculated for complex vectors as the complex number with the largest complex modulus (magnitude), computed with max(abs(V)). Then it computes the largest phase angle with max(angle(x)), if necessary.)

min(V) The minimum component of V. (min is calculated for complex vectors as the complex number with the smallest complex modulus (magnitude), computed with min(abs(A)). Then it computes the smallest phase angle with min(angle(x)), if necessary.)

mean(V) Average of the components of V.

median(V) Median of the components of V.

std(V) Standard deviation of the components of V.

sort(V) Sorts the components of V in ascending order. For complex entries the order is by absolute value and argument.

sum(V) Returns the sum of the components of V.

prod(V) Returns the product of the components of V, so, for example, n! = prod(1:n).

cumsum(V) Gives the cumulative sums of the components of V.

cumprod(V) Gives the cumulative products of the components of V.

diff(V) Gives the vector of first differences of V (V_t - V_t-1).

gradient(V) Gives the gradient of V.

del2(V) Gives the Laplacian of V (5-point discrete).

fft(V) Gives the discrete Fourier transform of V.

fft2(V) Gives the two-dimensional discrete Fourier transform of V.

ifft(V) Gives the inverse discrete Fourier transform of V.

ifft2(V) Gives the inverse two-dimensional discrete Fourier transform of V.

These functions also support a complex matrix as an argument, in which case the result is a vector of column vectors whose components are the results of applying the function to each column of the matrix.

Here are some examples:

>> V = 1:5, W = [1-i 2i 2 + 3i]

V =

     1     2     3     4     5

W =

   1.0000 - 1.0000i        0 + 2.0000i   2.0000 + 3.0000i

>> diff(V)

ans =

     1     1     1     1

>> diff(W)

ans =

  -1.0000 + 3.0000i   2.0000 + 1.0000i

>> cumprod(V)

ans =

     1     2     6    24   120

>> cumsum(W)

ans =

   1.0000 - 1.0000i   1.0000 + 1.0000i   3.0000 + 4.0000i

>> mean(W)

ans =

   1.0000 + 1.3333i

>> std(V)

ans =

    1.5811

>> sort(W)

ans =

   1.0000 - 1.0000i        0 + 2.0000i   2.0000 + 3.0000i

>> sum(W)

ans =

   3.0000 + 4.0000i

>> prod(V)

ans =

   120

>> gradient(W)

ans =

  -1.0000 + 3.0000i   0.5000 + 2.0000i   2.0000 + 1.0000i

>> del2(W)

ans =

        0             1.5000 - 1.0000i        0

>> fft(W)

ans =

   3.0000 + 4.0000i  -0.8660 - 1.7679i   0.8660 - 5.2321i


>> ifft(W)

ans =

   1.0000 + 1.3333i   0.2887 - 1.7440i    -0.2887 - 0.5893i

>> fft2(W)

ans =

   3.0000 + 4.0000i   - 0.8660 - 1.7679i   0.8660 - 5.2321i

4.11 Vector Functions of Several Variables

Functions of one or several variables are defined via the command maple as follows:

• maple(‘f: = x - > f (x)’) or maple f: = x - > f (x): defines the function f(x)
• maple(‘f:=(x,y,z...))(- > f(x,y,z...)’): defines the function f(x,y,z,..)
• maple(‘f:=(x,y,z...))(- > (f1 (x, y...), f2(x,y..),...)’): defines the vector function (f1(x,y,..), f2(x,y,..),...)

To find the value of the function (x, y, z) - > f(x,y,z...) at the point (a, b, c,...) the expression maple (‘f(a,b,c,...)’) is used.

We find the value of the vector function f:=(x,y,..)-> (f1(x,y,..), f2(x,y,..),...) at the point (a, b,...) by using the expression maple (‘f(a,b,..)’).

The function  f(x,y) = 2x  + y is defined in the following way:

>> maple ('f:=(x,y) - > 2 * x + y ');

f(2,3) and f(a,b) are calculated as follows:

>> maple('f(2,3)')

ans =

7

>> maple('f(a,b)')

ans =

2 * a + b

4.12 Functions of One Variable

Functions of one variable are a special case of functions of several variables, but they can also be defined in MATLAB via the command f = ‘function’.

To find the value of the function f at a point, you use the command subs, whose syntax is as follows:

• subs(f, a) applies the function f at the point a
• subs (f, a, b) assigns the value of the function at the point a to the variable b

Let’s see how to define the function f(x) = x ^ 2 :

>> f ='x ^ 2'

f =

x ^ 2

Now we calculate the values f(4), f(a+1) and f(3x+x^2):

>> syms a x
>>  A=subs(f,4),B=subs(f,a+1),C=subs(f,3*x+x^2)

A =

16

B =

(a+1) ^ 2

C =

(3 * x + x ^ 2) ^ 2

It should also be borne in mind that if we use the command maple, the special constants π , e, i, and ∞ are defined as maple(‘Pi’), maple(‘exp(1)’), maple(‘i’) and maple(‘infinity’) respectively.