>> In this section we will tell you about the MATLAB operators. An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. MATLAB is designed to operate primarily on whole matrices and arrays. Therefore, operators in MATLAB work both on scalar and non-scalar data.
MATLAB allows the following types of elementary operations:
1. Arithmetic Operators
2. Relational Operators
3. Logical Operators
4. Bitwise Operations
5. Set Operations
1. Arithmetic Operators
MATLAB allows two different types of arithmetic operations:
a. Matrix arithmetic operations
b. Array arithmetic operations
Matrix arithmetic operations are same as defined in linear algebra. Array operations are executed element by element, both on one dimensional and multi-dimensional array.
The matrix operators and arrays operators are differentiated by the period (.) symbol. However, as the addition and subtraction operation is same for matrices and arrays, the operator is same for both cases.
The following table gives brief description of the operators:
Addition or unary plus. A+B adds A and B. A and B must have the same size, unless one is a scalar. A scalar can be added to a matrix of any size.
| |
-
|
Subtraction or unary minus. A-B subtracts B from A. A and B must have the same size, unless one is a scalar. A scalar can be subtracted from a matrix of any size.
|
*
|
Matrix multiplication. C = A*B is the linear algebraic product of the matrices A and B. For nonscalar A and B, the number of columns of A must equal the number of rows of B. A scalar can multiply a matrix of any size.
|
.*
|
Array multiplication. A.*B is the element-by-element product of the arrays A and B. A and B must have the same size, unless one of them is a scalar.
|
^
|
Matrix power. X^p is X to the power p, if p is a scalar. If p is an integer, the power is computed by repeated squaring. If the integer is negative, X is inverted first. For other values of p, the calculation involves eigenvalues and eigenvectors, such that if [V,D] = eig(X), then X^p = V*D.^p/V.
|
.^
|
Array power. A.^B is the matrix with elements A(i,j) to the B(i,j) power. A and B must have the same size, unless one of them is a scalar.
|
\
|
Backslash or matrix left division. If A is a square matrix, A\B is roughly the same as inv(A)*B, except it is computed in a different way. If A is an n-by-n matrix and B is a column vector with n components, or a matrix with several such columns, then X = A\B is the solution to the equation AX = B. A warning message is displayed if A is badly scaled or nearly singular.
|
/
|
Slash or matrix right division. B/A is roughly the same as B*inv(A). More precisely, B/A = (A'\B')'.
|
.\
|
Array left division. A.\B is the matrix with elements B(i,j)/A(i,j). A and B must have the same size, unless one of them is a scalar.
|
./
|
Array right division. A./B is the matrix with elements A(i,j)/B(i,j). A and B must have the same size, unless one of them is a scalar.
|
:
|
Generates regularly spaced elements and represents an entire row or column.
|
( )
|
Encloses function arguments and array indices; overrides precedence.
|
Matrix transpose. A' is the linear algebraic transpose of A. For complex matrices, this is the complex conjugate transpose.
|
.'
|
Array transpose. A.' is the array transpose of A. For complex matrices, this does not involve conjugation.
|
Example:
If you enter the following operation in MATLAB
a = 10;
b = 20;
c = a + b
d = a - b
e = a * b
f = a / b
g = a \ b
x = 7;
y = 3;
z = x ^ y
you will get
Apart from the above-mentioned arithmetic operators, MATLAB provides the following commands/functions used for similar purpose. There are a variety of other functions available in MATLAB that are not so commonly used, but which will definitely be useful:
round(x)
|
Rounds a number to the nearest integer
|
ceil(x)
|
Rounds a number up to the nearest integer
|
floor(x)
|
|
fix(x)
|
Rounds a number to the nearest integer towards zero
|
rem(x,y)
|
The remainder left after division
|
mod(x,y)
|
The signed remainder left after division
|
abs(x)
|
The absolute value of x
|
sign(x)
|
|
factor(x)
|
|
uplus(a)
|
Unary plus; increments by the amount a
|
plus (a,b)
|
Plus; returns a + b
|
uminus(a)
|
Unary minus; decrements by the amount a
|
minus(a, b)
|
Minus; returns a - b
|
times(a, b)
|
Array multiply; returns a.*b
|
mtimes(a, b)
|
Matrix multiplication; returns a* b
|
rdivide(a, b)
|
Right array division; returns a ./ b
|
ldivide(a, b)
|
Left array division; returns a.\ b
|
mrdivide(A,B)
|
Solve systems of linear equations xA = B for x
|
mldivide(A,B)
|
Solve systems of linear equations Ax = B for x
|
power(a, b)
|
Array power; returns a.^b
|
mpower(a, b)
|
Matrix power; returns a ^ b
|
diff(X,n)
|
Applies diff recursively n times, resulting in the nth difference.
|
idivide(a, b, 'round')
|
Fractional quotients are rounded to the nearest integers.
|
sum(A,dim)
|
Sums along the dimension of A specified by scalar dim.
|
| divide(a, b) idivide(a, b,'fix') |
2. Relation operation:
Relational operators can also work on both scalar and non-scalar data. Relational operators for arrays perform element-by-element comparisons between two arrays and return a logical array of the same size, with elements set to logical 1 (true) where the relation is true and elements set to logical 0 (false) where it is not.
The following are the relational operators:
< Less than
<= Less than or equal to
> Greater than
>= Greater than or equal to
== Equal to
~= Not equal to
Examples:
There are a variety of other functions available in MATLAB which is given below:
eq(a, b)
|
Tests whether a is equal to b
|
ge(a, b)
|
Tests whether a is greater than or equal to b
|
gt(a, b)
|
Tests whether a is greater than b
|
le(a, b)
|
Tests whether a is less than or equal to b
|
lt(a, b)
|
Tests whether a is less than b
|
ne(a, b)
|
Tests whether a is not equal to b
|
isequal
|
Tests arrays for equality
|
isequaln
|
Tests arrays for equality, treating NaN values as equal
|
Example:
Create a script file and type the following and check it:
% comparing two values
a = 100;
b = 200;
if (ge(a,b))
max = a
else
max = b
end
% comparing two different values
a = 340;
b = 520;
if (le(a, b))
disp(' a is either less than or equal to b')
else
disp(' a is greater than b')
end
3. Logical operations:
MATLAB offers two types of logical operators and functions:
Element-wise - these operators operate on corresponding elements of logical arrays.
Short-circuit - these operators operate on scalar, logical expressions.
Element-wise logical operators operate element-by-element on logical arrays. The symbols &, |, and ~ are the logical array operators AND, OR, and NOT respectively.
Short-circuit logical operators allow short-circuiting on logical operations. The symbols && and || are the logical short-circuit operators AND and OR respectively.
Example:
Functions for Logical Operations:
Below are some function for logical operations.
Finds logical AND of array or scalar inputs; performs a logical AND of all input arrays A, B, etc. and returns an array containing elements set to either logical 1 (true) or logical 0 (false). An element of the output array is set to 1 if all input arrays contain a nonzero element at that same array location. Otherwise, that element is set to 0.
|
|
not(A)
|
Finds logical NOT of array or scalar input; performs a logical NOT of input array A and returns an array containing elements set to either logical 1 (true) or logical 0 (false). An element of the output array is set to 1 if the input array contains a zero value element at that same array location. Otherwise, that element is set to 0.
|
or(A, B)
|
Finds logical OR of array or scalar inputs; performs a logical OR of all input arrays A, B, etc. and returns an array containing elements set to either logical 1 (true) or logical 0 (false). An element of the output array is set to 1 if any input arrays contain a nonzero element at that same array location. Otherwise, that element is set to 0.
|
xor(A, B)
|
Logical exclusive-OR; performs an exclusive OR operation on the corresponding elements of arrays A and B. The resulting element C(i,j,...) is logical true (1) if A(i,j,...) or B(i,j,...), but not both, is nonzero.
|
all(A)
|
Determine if all array elements of array A are nonzero or true.
If A is a vector, all(A) returns logical 1 (true) if all the elements are nonzero and returns logical 0 (false) if one or more elements are zero.
If A is a nonempty matrix, all(A) treats the columns of A as vectors, returning a row vector of logical 1's and 0's.
If A is an empty 0-by-0 matrix, all(A) returns logical 1 (true).
If A is a multidimensional array, all(A) acts along the first nonsingleton dimension and returns an array of logical values. The size of this dimension reduces to 1 while the sizes of all other dimensions remain the same.
|
all(A, dim)
|
Tests along the dimension of A specified by scalar dim.
|
any(A)
|
Determine if any array elements are nonzero; tests whether any of the elements along various dimensions of an array is a nonzero number or is logical 1 (true). The any function ignores entries that are NaN (Not a Number).
If A is a vector, any(A) returns logical 1 (true) if any of the elements of A is a nonzero number or is logical 1 (true), and returns logical 0 (false) if all the elements are zero.
If A is a nonempty matrix, any(A) treats the columns of A as vectors, returning a row vector of logical 1's and 0's.
If A is an empty 0-by-0 matrix, any(A) returns logical 0 (false).
If A is a multidimensional array, any(A) acts along the first nonsingleton dimension and returns an array of logical values. The size of this dimension reduces to 1 while the sizes of all other dimensions remain the same.
|
any(A,dim)
|
Tests along the dimension of A specified by scalar dim.
|
false
|
Logical 0 (false)
|
false(n)
|
is an n-by-n matrix of logical zeros
|
false(m, n)
|
is an m-by-n matrix of logical zeros.
|
false(m, n, p, ...)
|
is an m-by-n-by-p-by-... array of logical zeros.
|
false(size(A))
|
is an array of logical zeros that is the same size as array A.
|
false(...,'like',p)
|
is an array of logical zeros of the same data type and sparsity as the logical array p.
|
Find indices and values of nonzero elements; locates all nonzero elements of array X, and returns the linear indices of those elements in a vector. If X is a row vector, then the returned vector is a row vector; otherwise, it returns a column vector. If X contains no nonzero elements or is an empty array, then an empty array is returned.
|
|
nd = find(X, k)
ind = find(X, k, 'first')
|
Returns at most the first k indices corresponding to the nonzero entries of X. k must be a positive integer, but it can be of any numeric data type.
|
ind = find(X, k, 'last')
|
returns at most the last k indices corresponding to the nonzero entries of X.
|
[row,col] = find(X, ...)
|
|
[row,col,v] = find(X, ...)
|
Returns a column or row vector v of the nonzero entries in X, as well as row and column indices. If X is a logical expression, then v is a logical array. Output v contains the non-zero elements of the logical array obtained by evaluating the expression X.
|
islogical(A)
|
Determine if input is logical array; returns true if A is a logical array and false otherwise. It also returns true if A is an instance of a class that is derived from the logical class.
|
logical(A)
|
|
true
|
|
true(n)
|
|
true(m, n)
|
|
true(m, n, p, ...)
|
|
true(size(A))
|
|
true(...,'like', p)
|
4. Bitwise operations:
Bitwise operator works on bits and performs bit-by-bit operation. The truth tables for &, |, and ^ are as follows:
p
|
q
|
p & q
|
p | q
|
p ^ q
|
0
|
||||
0
|
||||
1
|
||||
1
|
1
|
1
|
A = 0011 1100
B = 0000 1101
Then the function operate as follow:
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
The following table shows the commonly used bitwise operations:
bitand(a, b)
|
|
bitcmp(a)
|
|
bitget(a,pos)
|
|
bitor(a, b)
|
|
bitset(a, pos)
|
|
bitshift(a, k)
|
|
bitxor(a, b)
|
|
swapbytes
|
Swap byte ordering
|
Example:
4. Set operations:
MATLAB provides various functions for set operations, like union, intersection and testing for set membership, etc.
The following table shows some commonly used set operations:
intersect(A,B)
|
Set intersection of two arrays; returns the values common to both A and B. The values returned are in sorted order.
|
intersect(A,B,'rows')
|
Treats each row of A and each row of B as single entities and returns the rows common to both A and B. The rows of the returned matrix are in sorted order.
|
ismember(A,B)
|
Returns an array the same size as A, containing 1 (true) where the elements of A are found in B. Elsewhere, it returns 0 (false).
|
ismember(A,B,'rows')
|
Treats each row of A and each row of B as single entities and returns a vector containing 1 (true) where the rows of matrix A are also rows of B. Elsewhere, it returns 0 (false).
|
issorted(A)
|
Returns logical 1 (true) if the elements of A are in sorted order, and logical 0 (false) otherwise. Input A can be a vector or an N-by-1 or 1-by-N cell array of strings. A is considered to be sorted if A and the output of sort(A) are equal.
|
issorted(A, 'rows')
|
Returns logical 1 (true) if the rows of two-dimensional matrix A are in sorted order, and logical 0 (false) otherwise. Matrix A is considered to be sorted if A and the output of sortrows(A) are equal.
|
setdiff(A,B)
|
Set difference of two arrays; returns the values in A that are not in B. The values in the returned array are in sorted order.
|
setdiff(A,B,'rows')
|
Treats each row of A and each row of B as single entities and returns the rows from A that are not in B. The rows of the returned matrix are in sorted order. The 'rows' option does not support cell arrays.
|
setxor
|
|
union
|
|
unique
|
Unique values in array
|
Example:
0Awesome Comments!