CHAPTER 2

Variables, Numbers, Operators and Functions

Variables

MATLAB does not require a command to declare variables. A variable is created simply by directly allocating a value to it. For example:

>> v = 3

v =

3

The variable v will take the value 3 and using a new mapping will not change its value. Once the variable is declared, we can use it in calculations.

>> v ^ 3

ans =

27

>> v + 5

ans =

8

The value assigned to a variable remains fixed until it is explicitly changed or if the current MATLAB session is closed.

If we now write:

>> v = 3 + 7

v =

10

then the variable v has the value 10 from now on, as shown in the following calculation:

>> v ^ 4

ans =

10000

A variable name must begin with a letter followed by any number of letters, digits or underscores. However, bear in mind that MATLAB uses only the first 31 characters of the name of the variable. It is also very important to note that MATLAB is case sensitive. Therefore, a variable named with uppercase letters is different to the variable with the same name except in lowercase letters.

Vector Variables

A vector variable of n elements can be defined in MATLAB in the following ways:

V = [v1, v2, v3,..., vn]

V = [v1 v2 v3... vn]

When most MATLAB commands and functions are applied to a vector variable the result is understood to be that obtained by applying the command or function to each element of the vector:

>> vector1 = [1,4,9,2.25,1/4]

vector1 =

1.0000 4.0000 9.0000 2.2500 0.2500

>> sqrt (vector1)

ans =

1.0000 2.0000 3.0000 1.5000 0.5000

The following table presents some alternative ways of defining a vector variable without explicitly bracketing all its elements together, separated by commas or blank spaces.

Below are some examples:

>> vector2 = [5:5:25]

vector2 =

5 10 15 20 25

This yields the numbers between 5 and 25, inclusive, separated by 5 units.

>> vector3=[10:30]

vector3 =

Columns 1 through 13

10    11    12    13    14    15    16    17    18    19       20    21    22

Columns 14 through 21

23 24 25 26 27 28 29 30

This yields the numbers between 10 and 30, inclusive, separated by a unit.

>> t:Microsoft.WindowsMobile.DirectX.Vector4 = linspace (10,30,6)

t:Microsoft.WindowsMobile.DirectX.Vector4 =

10 14 18 22 26 30

This yields 6 equally spaced numbers between 10 and 30, inclusive.

>> vector5 = logspace (10,30,6)

vector5 =

1. 0e + 030 *

0.0000 0.0000 0.0000 0.0000 0.0001 1.0000

This yields 6 evenly logarithmically spaced numbers between 10¹⁰ and 10³⁰, inclusive.

One can also consider row vectors 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 quotation mark at the end of its definition.

>> a = [10;20;30;40]

a =

10
20
30
40

>> a = (10:14);b = a'

b =

10
11
12
13
14

>> c = (a')'

c =

10 11 12 13 14

You can also select an element of a vector or a subset of elements. The rules are summarized in the following table:

Here are some examples:

>> x = (1:10)

x =

1     2     3     4     5     6     7     8     9    10

>> x (6)

ans =

6

This yields the sixth element of the vector x.

>> x (4:7)

ans =

4 5 6 7

This yields the elements of the vector x located between the fourth and seventh elements, inclusive.

>> x(2:3:9)

ans =

2 5 8

This yields the three elements of the vector x located between the second and ninth elements, inclusive, but separated in steps of three units.

>> x(9:-3:2)

ans =

9 6 3

This yields the three elements of the vector x located between the ninth and second elements, inclusive, but separated in steps of three units and starting at the ninth.

Matrix Variables

MATLAB defines arrays 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 = [a11a12 a13;a21a22a23;a31a32a33]
M = [a11,a12,a13;a21,a22,a23;a31,a32,a33]

Similarly we can define an array of variable 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 table shows different ways to define matrix variables.

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

Character Variables

A character variable (chain) is simply a character string enclosed in single quotes that MATLAB treats as a vector form. The general syntax for character variables is as follows:

c = 'string'

Among the MATLAB commands that handle character variables we have the following:

Here are some examples:

>> hex2dec ('3ffe56e')

ans =

67102062

Here MATLAB has converted a hexadecimal string into a decimal number.

>> dec2hex (1345679001)

ans =

50356E99

The program has converted a decimal number into 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 strings (with default precision).

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

ans =

121.0001

Here a numeric string has been passed to an exact numerical format (with default precision).

>> num2str (pi)

ans =

3.142

The constant π  has been converted into a string.

>> str2num('15/14')

ans =

1.0714

The string has been converted into a numeric value with default precision.

>> setstr(32:126)

ans =

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

This yields the ASCII characters associated with the whole numbers between 32 and 126, inclusive.

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

ans =

123 93 125 62 60 35 161 191 63 186 170

This yields the integers corresponding to the ASCII characters specified in the argument of abs.

>> lower ('ABCDefgHIJ')

ans =

abcdefghij

The text has been converted to lowercase.

>> upper('abcd eFGHi jKlMn')

ans =

ABCD EFGHI JKLMN

The text has been converted to uppercase.

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

ans =

The world
The country
Daily 16
ABC

The chains comprising the arguments of str2mat have been converted to a text array.

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

ans =

This text will appear on the screen

Here the argument of the command disp has been displayed on the screen.

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

ans =

This is a bad example

The string good has been replaced by bad in the chain c. The following instruction locates the initial position of each occurrence of is within the chain c.

>> findstr (c, 'is')

ans =

3 6

Numbers

In MATLAB the arguments of a function can take many different forms, including different types of numbers and numerical expressions, such as integers and rational, real and complex numbers.

Arithmetic operations in MATLAB are defined according to the standard mathematical conventions. MATLAB is an interactive program that allows you to perform a simple variety of mathematical operations. MATLAB assumes the usual operations of sum, difference, product, division and power, with the usual hierarchy between them:

To add two numbers simply enter the first number, a plus sign (+) and the second number. Spaces may be included before and after the sign to ensure that the input is easier to read.

>> 2 + 3

ans =

5

We can perform power calculations directly.

>> 100 ^ 50

ans =

1. 0000e + 100

Unlike a calculator, when working with integers, MATLAB displays the full result even when there are more digits than would normally fit across the screen. For example, MATLAB returns the following value of 99 ^ 50 when using the vpa function (here to the default accuracy of 32 significant figures).

>> vpa '99 ^ 50'

ans =

. 60500606713753665044791996801256e100

To combine several operations in the same instruction one must take into account the usual priority criteria among them, which determine the order of evaluation of the expression. Consider, for example:

>> 2 * 3 ^ 2 + (5-2) * 3

ans =

27

Taking into account the priority of operators, the first expression to be evaluated is the power 3^2. The usual evaluation order can be altered by grouping expressions together in parentheses.

In addition to these arithmetic operators, MATLAB is equipped with a set of basic functions and you can also define your own functions. MATLAB functions and operators can be applied to symbolic constants or numbers.

One of the basic applications of MATLAB is its use in realizing arithmetic operations as if it were a conventional calculator, but with one important difference: the precision of the calculation. Operations are performed to whatever degree of precision the user desires. This unlimited precision in calculation is a feature which sets MATLAB apart from other numerical calculation programs, where the accuracy is determined by a word length inherent to the software, and cannot be modified.

The accuracy of the output of MATLAB operations can be relaxed using special approximation techniques which are exact only up to a certain specified degree of precision. MATLAB represents results with accuracy, but even if internally you are always working with exact calculations to prevent propagation of rounding errors, different approximate representation formats can be enabled, which sometimes facilitate the interpretation of the results. The commands that allow numerical approximation are the following:

Using format gives a numerical approximation of 174/13 in the way specified after the format command:

>> 174/13

ans =

13.3846

>> format long; 174/13

ans =

13.38461538461539

>> format long e; 174/13

ans =

1.338461538461539e + 001

>> format short e; 174/13

ans =

1.3385e + 001

>> format long g; 174/13

ans =

13.3846153846154

>> format short g; 174/13

ans =

13.385

>> format bank; 174/13

ans =

13.38

>> format hex; 174/13

ans =

402ac4ec4ec4ec4f

Now we will see how the value of sqrt (17) can be calculated to any precision that we desire:

>> vpa ' 174/13 ' 10

ans =

13.38461538

>> vpa ' 174/13 ' 15

ans =

13.3846153846154

>> digits (20); vpa ' 174/13 '

ans =

13.384615384615384615

Integers

In MATLAB all common operations with whole numbers are exact, regardless of the size of the output.  If we want the result of an operation to appear on screen to a certain number of significant figures, we use the symbolic computation command vpa (variable precision arithmetic), whose syntax we already know.

For example, the following calculates 6^400 to 450 significant figures:

>>  '6 vpa ^ 400' 450

ans =

182179771682187282513946871240893712673389715281747606674596975493339599720905327003028267800766283867331479599455916367452421574456059646801054954062150177042349998869907885947439947961712484067309738073652485056311556920850878594283008099992731076250733948404739350551934565743979678824151197232629947748581376.

The result of the operation is precise, always displaying a point at the end of the result. In this case it turns out that the answer has fewer than 450 digits anyway, so the solution is exact. If you require a smaller number of significant figures, that number can be specified and the result will be rounded accordingly. For example, calculating the above power to only 50 significant figures we have:

>>  '6 vpa ^ 400' 50

ans =

. 18217977168218728251394687124089371267338971528175e312

Functions of Integers and Divisibility

There are several functions in MATLAB with integer arguments, the majority of which are related to divisibility. Among the most typical functions with integer arguments are the following:

Below are some examples.

The remainder of division of 17 by 3:

>> rem (17,3)

ans =

2

The remainder of division of 4.1 by 1.2:

>> rem (4.1,1.2)

ans =

0.5000

The remainder of division of - 4.1 by 1.2:

>> rem (-4.1,1.2)

ans =

-0.5000

The greatest common divisor of 1000, 500 and 625:

>> gcd (1000, gcd (500,625))

ans =

125.00

The least common multiple of 1000, 500 and 625:

>> lcm (1000, lcm (500,625))

ans =

5000.00

Alternative Bases

MATLAB allows you to work with numbers to any base, as long as the extended symbolic math toolbox is available. It also allows you to express all kinds of numbers in different bases. This is implemented via the following functions:

Below are some examples.

Represent in base 10 the base 2 number 100101.

>> base2dec('100101',2)

ans =

37.00

Represent in base 10 the hexadecimal number FFFFAA00.

>> base2dec ('FFFFAA0', 16)

ans =

268434080.00

Represent the result of the base 16 operation FFFAA2+FF-1 in base 10.

>> base2dec('FFFAA2',16) + base2dec('FF',16)-1

ans =

16776096.00

Real Numbers

As is well known, the set of real numbers is the disjoint union of the set of rational numbers and the set of irrational numbers. A rational number is a number of the form p/q, where p and q are integers. In other words, the rational numbers are those numbers that can be represented as a quotient of two integers. The way in which MATLAB treats rational numbers differs from the majority of calculators. If we ask a calculator to calculate the sum 1/2 + 1/3 + 1/4, most will return something like 1.0833, which is no more than an approximation of the result.

The rational numbers are ratios of integers, and MATLAB can work with them in exact mode, so the result of an arithmetic expression involving rational numbers is always given precisely as a ratio of two integers. To enable this, activate the rational format with the command format rat. If the reader so wishes, MATLAB can also return the results in decimal form by activating any other type of format instead (e.g. format short or format long). MATLAB evaluates the above mentioned sum in exact mode as follows:

>> format rat
>> 1/2 + 1/3 + 1/4

ans =

13/12

Unlike calculators, MATLAB ensures its operations with rational numbers are accurate by maintaining the rational numbers in the form of ratios of integers. In this way, calculations with fractions are not affected by rounding errors, which can become very serious, as evidenced by the theory of errors. Note that, once the rational format is enabled, when MATLAB adds two rational numbers the result is returned in symbolic form as a ratio of integers, and operations with rational numbers will continue to be exact until an alternative format is invoked.

A floating point number, or a number with a decimal point, is interpreted as exact if the rational format is enabled. Thus a floating point expression will be interpreted as an exact rational expression while any irrational numbers in a rational expression will be represented by an appropriate rational approximation.

>> format rat
>> 10/23 + 2.45/44

ans =

1183 / 2412

The other fundamental subset of the real numbers is the set of irrational numbers, which have always created difficulties in numerical calculation due to their special nature. The impossibility of representing an irrational number accurately in numeric mode (using the ten digits from the decimal numbering system) is the cause of most of the problems. MATLAB represents the results with an accuracy which can be set as required by the user. An irrational number, by definition, cannot be represented exactly as the ratio of two integers. If ordered to calculate the square root of 17, by default MATLAB returns the number 5.1962.

>> sqrt (27)

ans =

5.1962

MATLAB incorporates the following common irrational constants and notions:

The following examples illustrate how MATLAB outputs these numbers and notions.

>> long format
>> pi

ans =

3.14159265358979

>> exp (1)

ans =
2.71828182845905

>> 1/0

Warning: Divide by zero.

ans =

Inf

>> 0/0

Warning: Divide by zero.

ans =

NaN

>> realmin

ans =

2. 225073858507201e-308

>> realmax

ans =

1. 797693134862316e + 308

Functions with Real Arguments

The disjoint union of the set of rational numbers and the set of irrational numbers is the set of real numbers. In turn, the set of rational numbers has the set of integers as a subset. All functions applicable to real numbers are also valid for integers and rational numbers. MATLAB provides a full range of predefined functions, most of which are discussed in the subsequent chapters of this book. Within the group of functions with real arguments offered by MATLAB, the following are the most important:

Trigonometric functions

Hyperbolic functions

Exponential and logarithmic functions

Numeric variable-specific functions

Here are some examples:

>> sin(pi/2)

ans =

1

>> asin (1)

ans =

1.57079632679490

>> log (exp (1) ^ 3)

ans =

3.00000000000000

The function round is demonstrated in the following two examples:

>> round (2.574)

ans =

3

>> round (2.4)

ans =

2

The function ceil is demonstrated in the following two examples:

>> ceil (4.2)

ans =

5

>> ceil (4.8)

ans =

5

The function floor is demonstrated in the following two examples:

>> floor (4.2)

ans =

4

>> floor (4.8)

ans =

4

The fix function simply removes the fractional part of a real number:

» fix (5.789)

ans =

5

Complex Numbers

Operations on complex numbers are well implemented in MATLAB. MATLAB follows the convention that i or j represents the key value in complex analysis, the imaginary number √- 1. All the usual arithmetic operators can be applied to complex numbers, and there are also some specific functions which have complex arguments. Both the real and the imaginary part of a complex number can be a real number or a symbolic constant, and operations with them are always performed in exact mode, unless otherwise instructed or necessary, in which case an approximation of the result is returned. As the imaginary unit is represented by the symbol i or j, the complex numbers are expressed in the form a+bi or a+bj. Note that you don't need to use the product symbol (asterisk) before the imaginary unit:

>>  (1-5i)*(1-i)/(-1+2i)

ans =

-1.6000 + 2.8000i

>> format rat
>>  (1-5i) *(1-i) /(-1+2i)

ans =

-8/5 + 14/5i

Functions with Complex Arguments

Working with complex variables is very important in mathematical analysis and its many applications in engineering. MATLAB implements not only the usual arithmetic operations with complex numbers, but also various complex functions. The most important functions are listed below.

Trigonometric functions

Hyperbolic functions

Exponential and logarithmic functions

Specific functions for the real and imaginary part

Specific functions for complex numbers

Below are some examples of operations with complex numbers.

>> round(1.5-3.4i)

ans =

2       -    3i

>> real(i^i)

ans =

0.2079

>>  (2+2i)^2/(-3-3*sqrt(3)*i)^90

ans =

0502e-085 - 1 + 7. 4042e-070i

>> sin (1 + i)

ans =

1.2985 + 0. 6350i

Elementary Functions that Support Complex Vector Arguments

MATLAB easily handles vector and matrix calculus. Indeed, its name, MAtrix LABoratory, already gives an idea of its power in working with vectors and matrices. MATLAB allows you to work with functions of a complex variable, but in addition this variable can even be a vector or a matrix. Below is a table of functions with complex vector arguments.

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 = 2:7, W = [5 + 3i 2-i 4i]

V =

2     3     4     5     6     7

W =

2.0000 - 1.0000i        0 + 4.0000i   5.0000 + 3.0000i

>> diff(V), diff(W)

ans =

1     1     1     1     1

ans =

-2.0000 + 5.0000i   5.0000 - 1.0000i

>> cumprod(V), cumsum(V)

ans =

2     6     24     120     720     5040

ans =

2     5     9    14    20    27

>> cumsum(W), mean(W), std(W), sort(W), sum(W)

ans =

2.0000 - 1.0000i   2.0000 + 3.0000i   7.0000 + 6.0000i

ans =

2.3333 + 2.0000i

ans =

3.6515

ans =

2.0000 - 1.0000i 0 + 4.0000i   5.0000 + 3.0000i

ans =

7.0000 + 6.0000i

>> mean(V), std(V), sort(V), sum(V)

ans =

4.5000

ans =

1.8708

ans =

2     3     4     5     6     7

ans =

27

>> fft(W), ifft(W), fft2(W)

ans =

7.0000 + 6.0000i   0.3660 - 0.1699i  -1.3660 - 8.8301i

ans =

2.3333 + 2.0000i  -0.4553 - 2.9434i   0.1220 - 0.0566i

ans =

7.0000 + 6. 0000i 0.3660 - 0. 1699i - 1.3660 - 8. 8301i

Elementary Functions that Support Complex Matrix Arguments

Here are some examples:

>> A = [7 8 9; 1 2 3; 4 5 6], B = [1+2i 3+i;4+i,i]

A =

7     8     9
1     2     3
4     5     6

B =

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

>> sin(A), sin(B), exp(A), exp(B), log(B), sqrt(B)

ans =

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

ans =

3.1658 + 1.9596i   0.2178 - 1.1634i
-1.1678 - 0.7682i        0 + 1.1752i

ans =

1.0e+003 *

1.0966    2.9810    8.1031
0.0027    0.0074    0.0201
0.0546    0.1484    0.4034

ans =

-1.1312 + 2.4717i  10.8523 +16.9014i
29.4995 +45.9428i   0.5403 + 0.8415i

ans =

0.8047 + 1.1071i   1.1513 + 0.3218i
1.4166 + 0.2450i        0 + 1.5708i

ans =

1.2720 + 0.7862i   1.7553 + 0.2848i
2.0153 + 0.2481i   0.7071 + 0.7071i

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), logm(A), abs(B), imag(B)

ans =

-27.9191 +14.8698i -20.0011 +12.0638i
-24.7950 + 17.6831i-17.5059 + 14.0445i

ans =

11.9650 12.8038 - 19.9093
-21.7328-22.1157 44.6052
11.8921 12.1200 - 21.2040

ans =

2.2361 3.1623
4.1231 1.0000

ans =

2     1
1     1

>> fix(sin(B)), ceil(log(A)), sign(B), rem(A,3*ones(3))

ans =

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

ans =

2     3     3
0     1     2
2     2     2

ans =

0.4472 + 0.8944i   0.9487 + 0.3162i
0.9701 + 0.2425i        0 + 1.0000i

ans =

1     2     0
1     2     0
1     2     0

Random Numbers

MATLAB can easily generate (pseudo) random numbers. The function rand generates uniformly distributed random numbers and the function randn generates normally distributed random numbers. The most interesting features of MATLAB’s random number generator are presented in the following table.

Here are some examples:

>>  [rand, rand (1), randn, randn (1)]

ans =

0.9501    0.2311   -0.4326   -1.6656

>>  [rand(2), randn(2)]

ans =

0.6068    0.8913             0.1253   -1.1465
0.4860    0.7621             0.2877    1.1909

>>  [rand(2,3), randn(2,3)]

ans =

0.3529 0.0099 0.2028   -0.1364 1.0668-0.0956
0.8132 0.1389 0.1987 0.1139 0.0593 - 0.8323

Operators

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

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 are presented in the following table.

Simple mathematical operations between scalars and vectors apply the scalar to all elements of the vector according to the defined operation, and simple operators between vectors are performed element by element. Below is the specification of these operators:

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 must be followed by a point.

The following example involves all of the above operators.

>> X = [5,4,3]; Y = [1,2,7]; a = X + Y, b = X-Y, c = x * Y, d = 2. * X,...
e = 2/X, f = 2. Y, g = x / Y, h =. X, i = x ^ 2, j = 2. ^ X, k = X. ^ Y

a =

6     6    10

b =

4     2    -4

c =

5     8    21

d =

10     8     6

e =

0.4000    0.5000    0.6667

f =

0.5000    1.0000    3.5000

g =

5.0000    2.0000    0.4286

h =

5.0000    2.0000    0.4286

i =

25    16     9

j =

32 16 8

k =

5 16 2187

The above operations are all valid since in all cases the variable operands are of the same dimension, so the operations are successfully carried out element by element. For the sum and the difference there is no distinction between vectors and matrices, as the operations are identical in both cases.

The most important operators for matrix variables are specified below:

Here are some examples:

>> X = [5,4,3]; Y = [1,2,7]; l = X'* Y, m = X * Y ', n = 2 * X, o = X / Y, p = YX

l =

5 10 35
4 8 28
3 6 21

m =

34

n =

10 8 6

o =

0.6296

p =

0         0         0
0         0         0
0.7143 0.5714 0.4286

All of the above matrix operations are well defined since the dimensions of the operands are compatible in every case. We must not forget that a vector is a particular case of matrix, but to operate with it in matrix form (not element by element), it is necessary to respect the rules of dimensionality for matrix operations. For example, the vector operations X. ' * Y and X.*Y' make no sense, since they involve vectors of different dimensions. Similarly, the matrix operations X * Y, 2/X, 2Y, X ^ 2, 2 ^ X and X ^ Y make no sense, again because of a conflict of dimensions in the arrays.

Here are some more examples of matrix operators.

>> M = [1,2,3;1,0,2;7,8,9]

M =

1 2 3
1 0 2
7 8 9

>> B = inv (M), C = M ^ 2, D = M ^(1/2), E = 2 ^ M

B =

-0.8889    0.3333    0.2222
0.2778   -0.6667    0.0556
0.4444    0.3333   -0.1111

C =

24    26    34
15    18    21
78    86   118

D =

0.5219 + 0.8432i   0.5793 - 0.0664i   0.7756 - 0.2344i
0.3270 + 0.0207i   0.3630 + 1.0650i   0.4859 - 0.2012i
1.7848 - 0.5828i   1.9811 - 0.7508i   2.6524 + 0.3080i

E =

1. 0e + 003 *

0.8626 0.9568 1.2811
0.5401 0.5999 0.8027
2.9482 3.2725 4.3816

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 zero if the corresponding relationship is true, or one 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 table of these operators.

Logical Operators

MATLAB provides symbols to denote logical operators. The logical operators shown in the following table offer a way to combine or negate relational expressions.

Here are some examples:

>> A = 2:7;P =(A>3) & (A<6)

P =

0     0     1     1     0     0

Returns 1 when the corresponding element of A is greater than 3 and less than 6, and returns 0 otherwise.

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

ans =

0 0 0
0 0 0
1 1 1

The elements of the solution array corresponding to those elements of X which are greater than or equal to the equivalent entry of the matrix [7 8 9; 4 5 6 ; 1 2 3] are assigned the value 1. The remaining elements are assigned the value 0.

Logical Functions

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

Below are some examples using the above defined logical functions.

>> V = [1,2,3,4,5,6,7,8,9], isprime(V), isnumeric(V), all(V), any(V)

V =

1     2     3     4     5     6     7     8     9

ans =

0     1     1     0     1     0     1     0     0

ans =

1

ans =

1

ans =

1

>> B = [Inf, -Inf, pi, NaN], isinf(B), isfinite(B), isnan(B), isreal(B)

B =

Inf - Inf 3.1416 NaN

ans =

1 1 0 0

ans =

0 0 1 0

ans =

0 0 0 1

ans =

1

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

ans =

1 0 1

ans =

1