Lab 1

LAB 1
INTRODUCTION TO COMMUNICATION SYSTEM USING

MATLAB
College of Engineering & Technology

Department of Electrical Engineering and Technology
MSU-Iligan Institute of Technology

ECE 112 Communication Systems (LAB) Laboratory 1
EXPERIMENT 1
INTRODUCTION TO COMMUNICATION SYSTEMS
USING MATLAB
1.0 OBJECTIVE
1.1 To study MATLAB and communication tool box
2.0 Equipment / Apparatus

Computer
MATLAB Software
3.0 THEORY
MATLAB
1. INTRODUCTION
( a ) What is MATLAB?
MATLAB is an interactive, matrix-based system for scientific and engineering numeric
computation and visualization. The word MATLAB stands for MATrix LABoratory. Each
entry is taken as a matrix in it, in particular scalar is considered as a 1 by 1 matrix.
MATLAB is available for a number of operating systems like Windows, Linux etc.
MATLAB was originally written in FORTRAN and is licensed by The Math Works, Inc,
(http:// www.mathworks.com). The version of MATLAB we use is ver 6.1. There is a
relatively inexpensive student edition available from Prentice Hall Publishers.
( b ) What is the advantage of MATLAB over FORTRAN or C?

In languages like FORTRAN & C we have to declare dimensions of matrices used. But,
here, by default each entry is a matrix, therefore dimensioning of a variable is not required.
We can solve complex numerical problems in a fraction of the time required with a
programming language such as FORTRAN or C. MATLAB is also a programmable
system. It contains so many useful algorithms as built-in functions and hence
programming itself is easier. The graphic and multimedia capabilities are also
commendable.
( c ) Where can we use MATLAB?

MATLAB is recognized as the interactive program for numerical linear algebra and matrix
computation. In industries, MATLAB is used for research and to solve practical
engineering and mathematical problems. Also, in automatic control theory, statistics and
digital signal processing (Time-Series Analysis) one can use MATLAB. The following tool
boxes make it useful in soft computing at various industrial and scientific areas:
(i) Neural Networks (ii) Optimization
(iii) Genetic Algorithms (iv) Wavelets
(v) Fuzzy Logic (vi) Control systems
(vi) Signal Processing
2
2. MATLAB GETTING STARTED

By clicking the MATLAB shortcut icon on the desktop of your computer (or selecting from
the program menu) you can access MATLAB. This results in getting MATLAB command
window with its prompt:
>>
with a blinking cursor appearing right of the prompt, telling you that MATLAB is waiting to
perform a mathematical operation you would like to give.
Simple Math Calculations
( i ) If you want to add two numbers say 7 & 12, type as follows
>> 7+12
and press the ENTER or return key, you see the following output:
ans =
19
Here, ans stands for the answer of computation. Similarly, the following gives product and
difference of these numbers,
>> 7*12 <ENTER>

ans =
84
>> 12-7 <ENTER>

ans =
5
( ii ) If you want to store the values 7 and 12 in MATLAB variables a & b and store
the values of their product and division in c and d, do as follows:
>> a =7 <ENTER>
a =
7
>>b =12 <ENTER>

b =
12
>>c= a*b <ENTER>

c =
84
>>d = 12/7 <ENTER>

d =
1.7143
3
You can exit MATLAB with the command exit or quit. A computation can be stopped
with[ctrl-c]
The basic arithmetic operations are given by:
Operation Symbol Example

Addition + 7+12
a+b
Subtraction - 12-7
a-b
Multiplication * 12*7
a.b
Division / or \ 12/7 = 7\12
a/b
Exponential ^ 7^12
ab
Variables, Expressions & Statements:

Variable names must be a single word containing no space and up to 31 characters.
Variables names are case sensitive and a variable name must start with a letter.
Punctuation characters are not allowed.
MATLAB’s statements are of the form:
>> variables = expression or

>> expression
Expressions are composed of operators, function and variable names. After evaluation
the value is assigned to the variable and displayed. If the variable name and = sign are
omitted, a variable ans (for answer) is automatically created and the result is assigned
to it.
A statement is normally terminated with the carriage returns. However, a statement can
be continued on the next line with three or more periods followed by a carriage return.
Several statements can be placed on a single line if separated by commas or semicolons.
If the last character of a statement is a semicolon, then values of the variable printing to
the screen will be suppressed, but the assignment is still carried out.
Rules of Precedence:
Expressions are evaluated from left to right with exponential operation having the
highest precedence, followed by multiplication and division having equal
precedence, followed by addition and subtracting having equal precedence.
Parentheses can be used to alter this ordering in which case these rules of precedence
are applied within each set of parentheses starting with the innermost set and proceeding
outward.
4
( iii ) The most recent values assigned to the variables you used in the current
session are available. For example, if you type a at the prompt you get the output
as:
>> a
a =
7
If you cannot remember the names of the variables, you have used in the current session,
you can use the who command for a list of variables it has in the current session.
>> who
Your variables are
ans a b c d
The command whos will list the variables in the workspace and their size.
The command
>> clear
will remove all current variables from the memory of the system.
>> clear a
will clear only the variable a.
( iv) To recall previous commands, MATLAB uses the cursor keys , , →,  on

your
keyboard.
 - recalls the most recent command to the MATLAB prompt.
 - scrolls forward through commands.
 - moves one within a command at the MATLAB prompt.
→
( v ) The display of numerical values can have different format as we see below:
>> e= 1/3
e =
0.3333
>> format long (long decimal format)
>> e
e =
0.33333333333333
>> format short e (short exponential format)
>> e
e =
3.3333 e-01
5
>>format long e (long exponential format)

e =
3.33333333333333 e-04
>>format (default format)
>>e
e =
0.3333
( vi ) To suppress the display of output of a command on screen put semicolon

‘;’ after the command.
>> a=3;
>>
( vii ) To end a session, type quit or exit at the MATLAB prompt.
>> exit
When we log out or exit, MATLAB will lose all the current variables from the memory.
To save the current session, type
>> save
This saves the all current variables to a binary diskfile matlab.mat. When you later re-
enter MATLAB, the command
>> load
will restore the workspace to list former state.
( viii ) Complex numbers i or j stands for - 1 and pi gives the value of P .
>> c = 1-2i
c =
1.000–2.0000 i
Some functions deals with complex numbers are as follows:

>> abs( c )
ans =
2.2361
>> real( c )
ans =
1
>> imag( c )
ans =
-2
6
>> angle( c )
ans =
-1.1071
Information about any command or operation is available by typing:
>> help command
and to get menu of help commands type
>> help
3. WORKING WITH MATRICES:

MATLAB works with essentially only one kind of objects, i.e. a rectangular numerical
matrix with possibly complex entries. All variables represent matrices.
Scalers - 1 by 1 matrix
Row vector - matrix with one row
Column vector - matrix with one column.
1 2 3
If you want to store a matrix |4 5 6| in a variable a in the MATLAB’s current
7 8 9
memory, you type the following in the MATLAB prompt.
>> a = [1 2 3; 4 5 6; 7 8 9]
a=
1 2 3
4 5 6
7 8 9
The rows are separated by semicolons and elements are separated by space or by
comma. That is, the above matrix can also be stored by the following command.
>> a = [1,2,3;4,5,6;7,8,9];
or by the statement
>> a = [
1 2 3
4 5 6
7 8 9 ];
The semicolon at the end of a command suppresses the output.

The matrix a is transposed and is stored in b by the following command
7
>> b = a’
b=
1 4 7
2 5 8
3 6 9
The following matrix operations are available in MATLAB
Function Task
+ Addition
- Subtraction
* Multiplication
^ Power
‘ Transpose
\ Left Division
/ Right Division
Examples:
>> a1 = a+b (matrices a and b are added and stores in a1)
a1 =
2 6 10
6 10 14
10 14 18
>> b1 = a-b (b is subtracted from a and stores in b1)

b1 =
0 -2 -4
2 0 -2
4 2 0
>> c = a*b (a is multiplied with b and stores in c)

c =
14 32 50
32 77 122
50 122 194
The operations *, ^, \, / can be made to operate entry-wise by preceding them by a

period.
>> [ 1 2 3 4] .* [1 2 3 4] (element-wise product)

ans =
1 4 9 16
>> [1 2 3 4] .^ 2 (element-wise power)

ans =
1 4 9 16
8
>> m = [ 2 1 5; 5 4 9;8 6 3];

>> n = inv(m) (Computes the inverse of the matrix a)
n =
1.1351 -0.7297 0.2973
-1.5405 0.9189 -0.1892
0.0541 0.1081 -0.0811
>> l = det(m) (Computes the determinant of a)
l =
-37
>> eig(a) (display eigen values of a)
ans =
16.1168
-1.1168
0.0000
>> [v,d]=eig(a) (gives eigen values and eigen vectors vof a)
v =
0.2320 0.7858 0.4082
0.5253 0.0868 -0.8165
0.8187 -0.6123 0.4082
d =
16.1168 0 0
0 -1.1168 0
0 0 0.0000
>> size(a) (gives size of the matrix a)

ans =
3 3
>> rank(a) (Displays rank of a)

ans =
2
>> clear (Clear’s All variables a, b, c, a1, b1, d)
>>clc (Clears Screen)
The following are some special matrices generated by built-in statements and functions
>> a = magic(4) (Produces Magic square of size 4)

a =
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
9
>> b = rand(5) (Generates Random matrix of size 5)

b =
0.9501 0.7621 0.6154 0.4057 0.0579
0.2311 0.4565 0.7919 0.9355 0.3529
0.6068 0.0185 0.9218 0.9169 0.8132
0.4860 0.8214 0.7382 0.4103 0.0099
0.8913 0.4447 0.1763 0.8936 0.1389
>> a = hilb(5)
a =
1.0000 0.5000 0.3333 0.2500 0.2000
0.5000 0.3333 0.2500 0.2000 0.1667
0.3333 0.2500 0.2000 0.1667 0.1429
0.2500 0.2000 0.1667 0.1429 0.1250
0.2000 0.1667 0.1429 0.1250 0.1111
is the Hilbert matrix, the king of ill-conditioned matrix of order 5.
>> ones(5) (generates square matrix of order 5 with all entries 1)

ans =
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
>> zeros(6) (generates matrix with all entries zero)

ans =
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
Matrix building functions

1. eye(n) - Identity matrix of order n
2. diag(a) - Vector consisting of diagonal of a
3. triu(a) - Upper triangular part of a
4. tril(a) - Lower triangular part of a
We can also load a matrix from an external ASCII file, say data.ext (where .ext is any
extension). If this ascii file contain a rectangular array of just the numeric matrix entries,
then to load the matrix type the command
10
Submatrices and Colon Notation
Consider a matrix a given by
>> a = [1 2 3 4;5 6 7 1;2 3 4 5]

a =
1 2 3 4
5 6 7 1
2 3 4 5
>> b= a(1:2,3) (Vector consisting of the first 2 entries of the 3rd column of a)
b =
3
7
>>c = a(:,3) (Vector consisting of 3rd column of a)

c =
3
7
4
>> d = a(1:2,:) (First two rows)

d =
1 2 3 4
5 6 7 1
>> e = a(3,:) (Third row of a)

e =
2 3 4 5
>> f = a(:,[2 4]) (Columns 2 and 4)

f =
2 4
6 1
3 5
>> aa = a(1:2, 3:4) (Submatrix)

aa =
3 4
7 1
Matrices can be built from blocks of matrices
>> a = [1 2 3;4 5 6;7 8 9]
11
>> b = [a, zeros (3,2); ones(2,3),eye(2)] ( will build a 5 by 5 matrix)

b =
1 2 3 0 0
4 5 6 0 0
7 8 9 0 0
1 1 1 1 0
1 1 1 0 1
Functions of vectors
>> t = [1:2:10] (Makes a row vector t having element starting from 1 up to 10 with step size 2)
t =
1 3 5 7 9
>> tt = [5:-1:0] (Here increment is –1)

tt =
5 4 3 2 1 0
>> x = 1:.2:2 (Here increment is not an integer)

x =
1.0000 1.2000 1.4000 1.6000 1.8000 2.0000
>> max(t) (maximum element in the vector t)

ans =
9
>> min(t) (minimum element in the vector t)
ans =
1
>> sum(t) (sum of all elements in the vector t)

ans =
25
>> mean(t) (mean of elements of t)

ans =
5
>>sort(t) (arrange in ascending order)
ans =
1 3 5 7 9
>> prod(t) (Product of elements)

ans =
945
>> median(t) (computes median)

ans =
5
12
>> any(t)
ans =
1
>> all(t)
ans =
1
>> std(t) (standard deviation)

ans =
3.1623
4. PLOTTING GRAPHS
2-D plots:
Suppose we want to plot the graph of y = sin(x), in a interval [0,10]. Type as follows
>> x = 0:0.5:10; (generates points in the given interval)

>> y = sin(x); (calculate function values at the x points)
>> plot(x,y) (Plots x verses y)
This will display the following graph:
13
More on plots
plot(x,y) plots vector y versus vector x.
If x or y is a matrix, then the vector is plotted versus the rows or columns of the matrix,
whichever line up.
plot(y) plots the columns of y versus their index.

If y is complex, plot(y) is equivalent to plot(real(y),imag(y)).
In all other uses of plot, the imaginary part is ignored. various line types, plot symbols
and colors may be obtained with plot(x,y,s) where s is a character string made
from one element from any or all the following columns:
o circle . point - solid m magenta

x x-mark : dotted -- dashed y yellow
-. dashdot + plus V triangle (down) c cyan
d diamond * star ^ triangle (up) r red
s square < triangle (left) g green
p pentagram > triangle (right) b blue
h hexagram w white
k black
Example:
plot(x,y,'c+:') plots a cyan dotted line with a plus at each data point.
plot(x,y,'bd') plots blue diamond at each data point but does not draw any line.
More than one plot in the same graph
>> plot(x, y, ‘b’, x, z, ‘g’)
puts two plots, plot(x, y, ‘b’) and plot(x, z, ‘g’) in one graph. The
first one with blue color and
the second with green color.
Example:
>> t = linspace(0,2*pi); (line space generates 100 t points between 0 and 2P)
>> x = sin(t);
>> y = cos(t);
>> plot(t, x,’*’, t, y,’-’) (plots sine and cos graphs in the same plot)
>> legend(‘x = sin(t)’, ’y = cos(t)’) (provides legends for graphs)
>> grid (provides grid lines)
14
plot(x1,y1,s1,x2,y2,s2,x3,y3,s3,...) combines the plots defined by the

(x,y,s) triples, where the x's and y's are vectors or matrices and the s's are strings.
plot(x,y,'y-',x,y,'go') plots the data twice, with a solid yellow line

interpolating green circles at the data points.
Subplots
You can hold more than one set of axes on one figure window. The command
subplot(m,n,p) subdivides the current figure window into an m-by-n matrix of
plotting areas and chooses the pth area to be active.
Example:
>> x = -2*pi:pi/10:2*pi;
>> y = x.^2;
>> z = sin(x);
>> y1 = cos(x);
>> z1 = exp(x);
>> subplot(2,2,1),plot(x,y)
>> grid
>> subplot(2,2,2),plot(x,z)
>> grid
>> subplot(2,2,3),plot(x,y1)
15
>> grid
>> subplot(2,2,4),plot(x,z1)
>>grid
It displays the graph as follows:
Functions for 2-D Plots
Function Task
plot - Linear plot
hold - Hold current graph
loglog - Log-log scale plot
semilogx - Semi-log scale plot
semilogy - Semi-log scale plot
axes - Create axes in arbitrary positions
subplot - Create axes in tiled positions
legend - Graph legend
title - Graph title
polar - Polar coordinate plot
xlabel - X-axis label
ylabel - Y-axis label
text - Text annotation
16
Function Task
plotyy - Graphs with y tick labels on the left and right
grid - Grid lines
gtext - Place text with mouse
box - Axis box
MATLAB Programming
We can also do programming in MATLAB as we are doing in FORTRAN, C & C++. To
make a file in MATLAB we have to click on “New” in the file menu in menu bar. It will open a
new file as we are doing in “word”; and if we save this file (called m-file), will be saved in
“bin” folder of MATLAB.
Such files are called “M-files” because they have an extension of “.m” in its filename. Much
of your work with MATLAB will be creating and refining M-files.
There are two types of M-files: Script Files and Function Files
Script Files
A script file consists of a sequence of normal MATLAB statements. If the file has the
filename, say, rkg.m, then the MATLAB command >> rkg will cause the statements in the
file to be executed. Variables in a script file are global and will change the value of variables
of the same name in the environment of the current MATLAB session.
Script files are often used to enter data into a large matrix; in such a file, entry errors can
be easily edited out.
Example: In a file rkg.m enter the following:

% This is a sample m-file
a = [1,2,3;0,1,1;1,2,3]
b =a’;
c = a+b
d = inv(c)
save this file. Then to execute this file, type
>> rkg <ENTER>

a =
1 2 3
0 1 1
1 2 3
b =
1 0 1
2 1 2
3 1 3
c =
2 2 4
2 2 3
4 3 6
17
d =
-1.5000 0 1.0000
0 2.0000 -1.0000
1.0000 -1.0000 0
The % symbol indicates that the rest of the line is a comment. MATLAB will ignore the rest
of the line. However, the first comment lines which document the m-file are available to the
online help facility and will be displayed
A M-file can also reference other M-files, including referencing itself recursively.
Function Files
Function files provide extensibility to MATLAB. You can create new functions specific to
your problem which will then have the same status as other MATLAB functions. Variables in
a function file are by default local. However, you can declare a variable to be global if you
wish.
Example
function y = prod (a,b)
y = a*b;
Save this file with filename prod.m then type on the MATLAB prompt
>> prod (3,4)

ans =
12
In MATLAB to get input from user the syntax rule is :
variable name = input (‘variable’);
As we know that if we don’t write “;” after a statement in MATLAB, it will print the
output also. That means if in a programme we write:
a=input (‘ Enter a number ‘);
And on command prompt if we run this program it will be displayed like:
>> Enter a number
If we type 2 at the cursor then we get the output as

a=2
Control Flow
MATLAB offers the following decision making or control flow structures:
1. If- Else –End Construction
2. For loops
18
3. While loops
4. Switch-Case constructions etc.
SYNTAX RULE FOR CONTROLLING THE FLOW:

1) if statement condition:
The general form of the if statement is:
if expression
statements
elseif expression
statements
else
statements
end
The statements are executed if the real part of the expression has all non-zero elements.
The else and elseif parts are optional. zero or more elseif parts can be used as well as
nested if's. The expression is usually of the form
expr rop expr
where rop is ==, <, >, <=, >=, or ~=.
Example:
if i == j
a(i,j) = 2;
elseif abs(i-j) == 1
a(i,j) = -1;
else
2) else used with if:

else is used with if. The statements after the else are executed if all the preceeding if and
elseif expressions are false.
The general form of the if statement is:
if expression
statements
elseif expression
statements
else
statements
end
3) elseif if statement condition:

elseif is used with if. The statements after the elseif are executed if the expression is true
and all the preceding if and elseif expressions are false. An expression is considered true if
the real part has all non-zero elements. elseif does not need a matching end, while else if
does.
19
the general form of the if statement is:
if expression
statements
elseif expression
statements
else
statements
end
4) end terminate scope of for, while, switch, try, and if statements. Without end's, for,
while, switch, try, and if wait for further input. each end is paired with the closest previous
unpaired for, while, switch, try or if and serves to terminate its scope. end can also serve as
the last index in an indexing expression. in that context,
end = size(x,k) when used as part of the k-th index. examples of this use are,
x(3:end) and x(1,1:2:end-1). when using end to grow an array, as in x(end+1) = 5,
make sure x exists first.
5) for repeat statements a specific number of times:

The general form of a for statement is:
for variable = expr, statement, ..., statement

end
The columns of the expression are stored one at a time in the variable and then the
following statements, up to the end, are executed. The expression is often of the form x:y, in
which case its columns are simply scalars. some examples
Example: (assume n has already been assigned a value)

for i = 1:n,
for j = 1:n,
a(i,j) = 1/(i+j-1);
end
end
for s = 1.0: -0.1: 0.0, end steps s with increments of -0.1

for e = eye(n), ... end sets e to the unit n-vectors.
Long loops are more memory efficient when the colon expression appears in the for
statement since the index vector is never created.
6) The break statement can be used to terminate the loop prematurely. break terminate
execution of while or for loop. In nested loops, break exits from the innermost loop only.
7) while repeat statements an indefinite number of times.

The general form of a while statement is:
while expression
statements
end
20
The statements are executed while the real part of the expression has all non-zero
elements. The expression is usually the result of expr rop expr where rop is ==, <,
>, <=, >=, or ~=.
Example:
(assuming a already defined)

e = 0*a; f = e + eye(size(e)); n = 1;
while norm(e+f-e,1) > 0,
e = e + f;
f = a*f/n;
n = n + 1;
end
8) switch switches among several cases based on expression:

the general form of the switch statement is:
switch switch_expr
case case_expr,
statement, ..., statement
case {case_expr1, case_expr2, case_expr3,...}
...
otherwise,
end
The first case where the switch_expr matches the case_expr is executed. when the case
expression is a cell array (as in the second case above), the case_expr matches if any of
the elements of the cell array match the switch expression. If none of the case expressions
match the switch expression then the otherwise case is executed (if it exists). Only one
case is executed and execution resumes with the statement after the end. the switch_expr
can be a scalar or a string. A scalar switch_expr matches a case_expr if
switch_expr==case_expr. A string switch_expr matches a case_expr if
strcmp(switch_expr,case_expr) returns 1 (true).
Example:
(assuming method exists as a string variable):

switch lower(method)
case {'linear','bilinear'}, disp('method is linear')
case 'cubic', disp('method is cubic')
case 'nearest', disp('method is nearest')
otherwise, disp('unknown method.')
end
21
9) case switch statement case:

case is part of the switch statement syntax, whose general form is:
switch switch_expr
case case_expr,
...
otherwise,
end
10) otherwise default switch statement case.

otherwise is part of the switch statement syntax, whose general form is:
switch switch_expr
case case_expr,
...
otherwise,
end
The otherwise part is executed only if none of the preceding case expressions match the
switch expression.
11) try begin try block:

The general form of a try statement is:
try, statement, ..., statement, catch, statement, ..., statement end
Normally, only the statements between the try and catch are executed. however, if an error
occurs while executing any of the statements, the error is captured into lasterr and the
statements between the catch and end are executed. if an error occurs within the catch
statements, execution will stop unless caught by another try...catch block. The error string
produced by a failed try block can be obtained with lasterr.
12) catch begin catch block:

The general form of a try statement is:
try statement, ..., statement, catch statement, ..., statement end
13) return returns to invoking function:

return causes a return to the invoking function or to the keyboard. It also terminates the
keyboard mode. Normally, functions return when the end of the function is reached. A return
statement can be used to force an early return.
22
Example:
function d = det(a)
if isempty(a)
d = 1;
return
else
...
End
How to run a program in MATLAB?

Suppose we have created a m-file & saved. Now to run this program, on command prompt
type the file name and just press the ENTER KEY that will run the file.
Data File:
Now to make a data file in MATLAB, we just make a file in which all the data are stored.
Now we make another file in which the operation on that data is to be done. Then in this file,
where we have to call that data we have to just type the file name of the file in which data is
stored and write the rest of the programming statements. So when run this file the file in
which data is stored will be called and then rest of the programming statements are
executed & finally we get the output.
MEX-Files:
We can call our C programs from MATLAB as if they were built in functions. Those
programs in C which are callable in MATLAB are referred as MEX-Files. MEX-files are
dynamically linked subroutines that the MATLAB interpreter can automatically load &
execute.
For example the following program in C to add two integers having file name “add”.
#include<stdio.h>
main( )
{ int a=2,b=3;
d=a+b;
printf(‘sum is:’,d);
return 0;
}
To compile & link this example at the MATLAB prompt, type
>>mex add.c
and press the “ENTER”key, it will give the output.
Some useful commands for programming:
>> echo on --- Echoing of commands in all script files

>> echo off --- Turns off echo
>> echo on all --- turns on of command including function files
23
>> disp(‘Any string’) --- Displays the string

>> diary file --- Causes copy of all subsequent keyboard input and most of the resulting output (but not
graphs) to
be written on the named file.
>> pause --- causes to stop execution of until any key is pressed.
Some Examples:
1) Example for if, else
for i = 1:n
for j = 1:n
if i==j
a(i, j) = 2
elseif abs(i – j) ==1
a(i, j) = -1;
else
a(i, j) = 0;
end
end
end
2) Example for while
eps = 1
while (1+eps)>1
eps = eps/2;
end
eps = eps*2
3) Gauss Elimination Method
function [x] = gausselim(A,b)

% This subroutine will perform Gaussian elimination on the
% matrix you pass and solve the system AX = b
N = max(size(A))
for j = 2:N
for i = j:N
m = A(j,j-1) / A(j-1,j-1);
A(i, :) = A(i, :) – A(j-1,:)*m;
b(i) = b(i) – m*b(j-1);
end
end
%Perform back substitution
x = zeros(N, 1)
x(N) = b(N) / A(N, N)
for j = N-1:-1:1
x(j) = (b(j)-A(j,j+1:N)) / A(j, j)
end
24
RELATIONAL OPERATORS
MATLAB relational operators includes the following:
Relational Operator Description

< Less than
<= Less than or equal to
> Greater than
>= Greater than or equal to
== Equal to
~= Not equal to
MATLAB relational operators can be used to compare two arrays of the same size, or to
compare an array to a scalar. When we compare an array to a scalar, scalar expansion is
used to compare the scalar to each array element and the result has the same size as the
array.
NOTE: = and == mean two different things:
== compares two variables and returns ones where they are equal and zeros where
they are not; while, = is used to assign the output of an operation to a variables.
Example:
>> a = 1:0.5:10;
>> b = 5:0.5:14;
>> c = a > 5
c =
Columns 1 through 12
0 0 0 0 0 0 0 0 0 1 1 1
1 1 1 1 1 1 1
>> d = (a ==b)
d =
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
LOGICAL OPERATORS
MATLAB logical operators include the following:
Logical Operator Description

& AND
| OR
~ NOT
Example:
>> a = 1:15;
25
>> b = ~ ( a < 5 )
b =
0 0 0 0 1 1 1 1 1 1 1 1
1 1 1
>> c = ( a > 2 ) & (a < 8 )

c =
0 0 1 1 1 1 1 0 0 0 0 0
0 0 0
>> d = ( a > 2 ) | ( a < 8 )

d =
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1
RULES FOR CONSTRUCTING M-FILES

Function M-files must satisfy a number of criteria. Some of them are as follows:
1. The function M-file name and the function name ( e.g., rkg) that appears in the first
line of the file should be identical. In reality, MATLAB ignores the function name in the
first line and executes functions based on the file name stored on disk.
2. Function M-file names can have up to 31 characters. This maximum may be limited
by the operating system, in which case the lower limit applies. MATLAB ignores
characters beyond the thirty-first or the operating system limit, so longer names can
be used, provided the legal characters point to a unique file name.
3. Function names must begin with a letter. Any combination of letters, numbers, and
underscores can appear after the first character. This naming rule is identical to that
for variables.
4. The first line of a function M-file is called the function declaration line and must
contain the word function followed by the calling syntax for the function in its most
general form. The input and output variables identified in the first line are variables
local to the function. The input variables contain data passed to the function and the
output variables contain data passed back from the function. It is not possible to pass
data back though the input variables.
5. The first sets of contiguous comment lines after the function declaration line are the
help text for the function. The first comment line is called the H1 line and is the line
searched by the lookfor command. The H1 line typically contains the function name
in uppercase characters and a concise description of the function’s purpose. Comment
lines after the first describe possible calling syntaxes, algorithms used, and simple
examples, if appropriate.
6. All statements after the first set of contiguous comment lines compose the body of the
function. The body of a function contains MATLAB statements that operate on the
input arguments and produce results in the output arguments.
26
7. A function M-file terminates after the last line in the file is executed or whenever a
return statement is encountered.
8. A function can abort operation and return control to the command window by calling
the function error. This function is useful for flagging improper function usage, as
shown in the following file fragment:
if length ( mat ) > 1
error ( ‘MAT must be a scalar.’)
end
if the function error is executed as shown, the string ‘VAL must be a scalar.’ Is
displayed in the command window after a line identifying the file the error message
originated from. If the function error is given a zero-length character string, it takes no
action.
9. A function can report a warning and then continue operation by calling the function
warning. This function is useful for reporting exceptions and other anomalous
behavior. warning (‘some message’) displays a character string in the command
window. The difference between the function warning and the function disp is that
warning messages can be turned on or off globally by issuing the commands warning
on and warning off, respectively.
10. Function M-files can contain calls to script files. When a script file is encountered, it is
evaluated in the function’s workspace, not the MATLAB workspace.
11. Multiple functions can appear in a single function M-file. Additional functions, called
subfunctions or local functions, are simply appended to the end of the primary function.
Subfunctions begin with a standard function statement line and follow function
construction rules.
12. Subfunctions can be called by the primary function in the M-file as well as by other
subfunctions in the same M-file. As with all functions, subfunctions have their own
individual workspaces.
13. Subfunctions can appear in any order after the primary function in a M-file. Help text
for subfunctions is not returned by the help command.
14. It is suggested that subfunction names begin with the word local (e.g., local_bsr).
Doing so improves the readability of the primary function because calls to local
functions are clearly identifiable. All local function names can have up to 31 characters.
15. In addition to subfunctions, M-files can call private M-files, which are standard function
M-files that reside in a subdirectory of the calling function that is entitled private. Only
functions in the immediate parent directory of private M-files have access to private
M-file.
16. It is suggested that private M-file names begin with the word private (e.g.,
private_bsr). Doing so improve the readability of the primary function because calls
to private functions are clearly identifiable. As with other function names, all private M-
file names can have up to 31 characters.
INPUT AND OUTPUT ARGUMENTS

MATLAB functions can have any number of input and output arguments. The features and
criteria of these arguments are as follows:
1. Function M-files can have zero input and zero output arguments.
2. Functions can be called with fewer input and output arguments than the function
definition line in the M-file specifies. Functions cannot be called with more input or
output arguments than the M-file specifies.
27
3. The number of input and output arguments used in a function call can be determined
by calls to the functions nargin and nargout, respectively. Since nargin and
nargout are functions, not variables, one cannot reassign them with statements
such as
Nargin = nargin – 1
4. When a function is called, the input variables are not copied into the function’s
workspace, but their values are made readable within the function. However, if any
values in the input variables are changed, the array is then copied into the function’s
workspace. Thus, to conserve memory and increase speed, it is best to extract
elements from large arrays and then modify them, rather than forcing the entire array
to be copied into the function’s workspace. Note that using the same variable name
for both an input and output argument causes an immediate copying of the contents
of the variable into the function’s workspace. For example,
function y = myfunction (x, y, z)
causes the variable y to be copied immediately into the workspace of myfunction.

5. If a function declares one or more output arguments, but no output is desired, simply
do not assign values to the output variable or variables.
6. Functions can accept a variable and unlimited number of input arguments by
specifying varargin as the last input argument in the function declaration line.
Varargin is a predefined cell array whose ith cell is the ith argument starting from
where varargin appears. For example, consider a function having the function
declaration line
Function a = myfunction(varargin)
If this function is called as a = myfunction(x, y, z), then inside the function varargin(1)
contains the array x, varargin(2) contains the array y, and varargin(3) contains the
array z. Likewise, if the function is called as a = myfunction(x), varargin has length
1 and varargin{1} = x. Every time myfunction is called, it can be called with a
different number of arguments. In any case, the function nargin returns the actual
number of input arguments used.
In those cases where one or more input arguments are fixed, varargin must appear
as the last argument, such as
Function a = myfunction (x, y, varargin)
If this function is called as a = myfunction(x, y, z), then inside the function x and y
are available and varargin(1) contains z.
7. Functions can accept a variable and unlimited number of output arguments by
specifying varargout as the last output argument in the function declaration line.
Varargout is a predefined cell array whose ith cell is the ith argument starting from
where varargout appears. For example, consider a function having the function
declaration line
function varargout = myfunction (x)
28
If this function is called as [a, b] = function (x), then inside the function the contents of
varargout(1) must be assigned to the data that become the variable a, and
varargout(2) must be assigned to the data that become the variable b. As with
varargin, the length of varargout is equal to the number of output arguments used
and nargout returns this length. In those cases where one or more output arguments
are fixed, varargout must appear as the last argument in the function declaration line
–for example, function [a, b, varargout] = myfunction (x).
FUNCTION WORKSPACES
Functions accept inputs, act on those inputs, and create outputs. Any and all variables
created within the function are hidden from the MATLAB or base workspace. Each function
has its own temporary workspace that is created with each function call and then deleted
when the function completes execution. MATLAB functions can be called recursively and
each call has a separate workspace. In addition to input and output arguments, MATLAB
provides several techniques for communicating among function workspaces and the
MATLAB or base workspace.
1. Function can share variables with other function, the MATLAB workspace, and
recursive calls to themselves if the variables are declared global. To gain access to a
global variable within a function or the MATLAB workspace, the variable must be
declared global within each desired workspace. The MATLAB functions tic and toc
illustrate the use of global variables. The functions tic and toc form a simple stopwatch
for timing MATLAB operations. When tic is called, it declares the variable TICTOC
global, assigns the current time to it, and then terminates. Later when toc is called,
TICTOC is declared global in the toc workspace, there by providing access to its
contents, and the elapsed time is computed. It is important to note that the variable
TICTOC exists only in the workspaces of the functions tic and toc; it does not exist in
the MATLAB workspace unless global TICTOC is issued there.
2. In addition to sharing data through global variables, MATLAB provides the function
evalin, which allows one to reach into another workspace, evaluate an expression,
and return the result to the current workspace. The function evalin is similar to eval,
except that the string is evaluated in either the caller or base workspace. The caller
workspace is the workspace from which the current function was called. The base
workspace is the MATLAB workspace in the command window. For example,
A = evalin(‘caller’,’expression’) evaluates ‘expression’ in the caller workspace and
returns the results to the variable A in the current workspace. evalin also provides
error trapping with the syntax evalin(‘workspace’,’try’,’catch’), where ‘workspace’
is either ‘caller’ or ‘base’, ‘try’ is the first expression evaluated, and ‘catch’ is an
expression that is evaluated in the current workspace if the evaluation of ‘try’
produces an error.
3. one can evaluate an expression in another workspace, it makes sense that one can
also assign the results of some expression in the current workspace to a variable in
another workspace. The function assignin provides this capability.
assignin(‘workspace’,’vname’,X), where ‘workspace’ is either ‘caller’ or ‘base’,
assigns the contents of the variable X in the current workspace to a variable in the
‘caller’ or ‘base’ workspace named ‘vname’.
4. The function inputname provides a way to determine the variable names used when
a function is called. For example, suppose a function is called as
>> y = myfunction(xdot,time,sqrt(2))
29
issuing inputname(1) inside of myfunction returns the character string ‘xdot’,

inputname(2) returns ‘time’, and inputname (3) returns an empty array because
sqrt(2) is not a variable, but rather an expression that produces an unnamed
temporary result.
5. The name of the M-file being executed is available within a function in the variable
myfilename. For example, when the M-file myfunction.m is being executed, the
workspace of the function contains the variable myfilename, which contains the
character string ‘myfunction’. This variable also exists within script files, in which
case it contains the name of the script file being executed.
FUNCTION M-FILES AND THE MATLAB SEARCH PATH

Function M-files are one of the fundamental strengths of MATLAB. They allow one to
encapsulate sequences of useful commands and apply them over and over. Since M-files
exist as text files on disk, it is important that MATLAB maximize the speed at which the files
are found, opened, and executed. The techniques that MATLAB uses to maximize speed are
as follows:
1. The first time MATLAB executes a function M-file, it opens the corresponding text file
and compiles the commands into an internal pseudocode representation in memory
that speeds execution for all later calls to the function. If the function contains
references to other M-file functions and script M-files, they too are compiled into
memory.
2. The function inmem returns a cell array of strings containing a list of functions and
script files currently compiled into memory.
3. It is possible to store the compiled or P-Code version of a function M-file to disk using
the pcode command. When this is done, MATLAB loads the compiled function into
memory rather than the M-file. For most functions this step does not significantly
shorten the amount of time required to execute a function the first time. However, it
can speed up large M-files associated with complex graphical user interface functions.
P-Code files are created by issuing
>> pcode myfunction
where myfunction.m is the M-file name to be compiled. P-Code files are
platformindependent binary files that have the same name as the original M-file, but
end in .p rather than .m. P-Code files also provide a level of security, since they are
visually undecipherable and can be run without the corresponding M-file.
4. When MATLAB encounters a name that it does not recognize, it follows a set of rules
to determine what to do. Given the information presented here, the set of rules can be
updated as follows:
When you enter cow at the MATLAB prompt or if MATLAB encounters a reference to
cow in a script or function M-file,
(1) it checks to see if cow is a variable in the current workspace; if not,
(2) it checks to see if cow is a built-in function; if not,
(3) it checks to see if cow is a subfunction in the M-file in which cow
appears; if not,
(4) it checks to see if cow.p and then cow.m is a private function to the M-
file in which cow appears; if not,
(5) it checks to see if cow.p and then cow.m exists in the current
directory; if not,
30
(6) it checks to see cow.p and then cow.m exists in each directory
specified on the MATLAB search path, by searching in the order in
which the search path is specified.
MATLAB uses the first match it finds.

5. When MATLAB is started, it caches the name and location of all M-files stored within
the toolbox subdirectory and in all subdirectories of the toolbox directory. This allows
MATLAB to find and execute function M-files much faster. It also makes the command
lookfor work faster.
In the development of M-file functions, it is best to store them outside the toolbox
directory, perhaps in the MATLAB directory, until they are considered complete. When
they are complete, move them to a subdirectory inside the read only toolbox directory.
Finally, make sure the MATLAB search path is changed to recognize their existence.
NOTE: M-file functions that are cached are considered read-only. If they are executed and
then later altered, MATLAB will simply execute the function that was previously compiled into
memory, ignoring the changed M-files. Moreover, if new M-files are added within are added
within the toolbox directory after MATLAB is running, their presence will not be noted in the
cache, and thus they will be unavailable for use.
6. When new M-files are added to a cached location, MATLAB will find them only if the
cache is refreshed by issuing the command path(path). On the other hand, when
cached M-files are modified, MATLAB will recognize the changes only if a previously
compiled version is dumped from memory by issuing the clear command.
7. MATLAB keeps track of the modification date of M-files outside the toolbox directory.
As a result, when an M-file function is encountered that was previously compiled into
memory, MATLAB compares the modification dates of the compiled M-file with that of
the M-file on disk. If the dates are the same, MATLAB executes the compiled M-file.
On the other hand, if the M-file and compiles the newer, revised M-file for execution.
NOTE: You can also create your own toolboxes.
Solving ordinary differential equation:

We can solve a system of differential equations using MATLAB, the function names for
that are ode45, ode23, ode113 etc. Out of which we are going to concentrate on ode45 only,
and the syntax rule for that is:
>> [x , t]=ode45(‘filename’,tspan,x0)
Suppose we have to solve:

dx1/dt = -x1(t)-t2 x2(t) ;
dx2/dt = -t2x1(t)-x2(t)
x1(0)=1 x2(0)=1 on [0,1].
Here we have to create a new file suppose the file name is orddiff.m. In that file we have to
write the above system of differential equation, and for that we write a function:
function y = filename (t, x)
y = [system of differential equations]
31
i.e. we write :
function y = orddiff(t,x)
y = [-x(1)-t .^2*x(2); -t .^2*x(1)-x(2)]
After doing this go to command prompt. Here initial conditions are [1 1]’ so our x0=[1 1]’ and
we have to solve this ode on [0 1] so our tspan=[0 1], then
>> [x t] = ode45(‘orddiff’,tspan,x0)
will solve this system of differential equations.
Finding minimum of a function:

We can find minimum of a function in an interval using MATLAB, the function names for
that are fmin, fmins. Here we give example of fmin only, the syntax rule for that is:
>> X= fmin(‘filename’,x1,x2)
Suppose we have to find minimum of :

f(x) = x.^2 over the interval [2, 4]
Here we have to create a new file suppose the file name is rkgmin.m. In that file we have to
write the above function, and for that we write a function:
function y = filename (x)
y = function
i.e. we write :
function y = rkgmin(x)
y = x .^2;
After doing this go to command prompt. Here the interval on which we have to find the
minimum is [2, 4] so our x1 = 2 and x2 = 4. On command prompt now you type:
>>X = fmin(‘rkgmin’,x1,x2)
will solve this system of differential equations.
Communication Tool Box

The Communications Toolbox extends the MATLAB technical computing environment with
functions, plots, and a graphical user interface for exploring, designing, analyzing, and
simulating algorithms for the physical layer of communication systems. The toolbox helps you
create algorithms for commercial and defense wireless or wireline systems.
32
The key features of the toolbox are

• Functions for designing the physical layer of communications links, including source
coding, channel coding, interleaving, modulation, channel models, and equalization
• Plots such as eye diagrams and constellations for visualizing communications signals
• Graphical user interface for comparing the bit error rate of your system with a wide
variety of proven analytical results
In most media for communication, only a fixed range of frequencies is available for
transmission. One way to communicate a message signal whose frequency spectrum does
not fall within that fixed frequency range, or one that is otherwise unsuitable for the channel,
is to alter a transmittable signal according to the information in your message signal. This
alteration is called modulation, and it is the modulated signal that you transmit. The receiver
then recovers the original signal through a process called demodulation. The contents of this
tool box are as follows.
a) Modulation Features of the Toolbox--Overview of the modulation types and
modulation operations that the Communications Toolbox supports
b) Modulation Terminology--Definitions of terms, as well as inequalities that certain
modulation quantities must satisfy
c) Analog Modulation--Representing analog signals and performing analog modulation
d) Digital Modulation—Representing digital signals, representing signal constellations for
digital modulation, and performing digital modulation
This section describes how to represent analog signals using vectors or matrices. It provides
examples of using the analog modulation and demodulation functions. Representing Analog
Signals To modulate an analog signal using this toolbox, start with a real message signal and
a sampling rate Fs in hertz. Represent the signal using a vector x, the entries of which give
the signal's values in time increments of 1/Fs. Alternatively, you can use a matrix to represent
a multichannel signal, where each column of the matrix represents one channel..
Analog Modulation/Demodulation function lists

• amdemod -- Amplitude demodulation
• ammod -- Amplitude modulation
• fmdemod -- Frequency demodulation
• fmmod -- Frequency modulation
• pmdemod -- Phase demodulation
• pmmod -- Phase modulation
• ssbdemod -- Single sideband amplitude demodulation
• ssbmod -- Single sideband amplitude modulation
amdemod [Amplitude demodulation]
Syntax
z = amdemod(y,Fc,Fs)
z = amdemod(y,Fc,Fs,ini_phase)
z= amdemod(y,Fc,Fs,ini_phase,carramp)
z = amdemod(y,Fc,Fs,ini_phase,carramp,num,den)
33
Description:
z = amdemod(y,Fc,Fs)
demodulates the amplitude modulated signal y from a carrier signal with frequency Fc (Hz).
The carrier signal and y have sample frequency Fs (Hz). The modulated signal y has zero
initial phase and zero carrier amplitude, so it represents suppressed carrier modulation.
The demodulation process uses the lowpass filter specified by [num,den] =
butter(5,Fc*2/Fs).
Note: The Fc and Fs arguments must satisfy Fs > 2(Fc + BW) where BW is the bandwidth
of the original signal that was modulated.
z = amdemod(y,Fc,Fs,ini_phase)
specifies the initial phase of the modulated signal in radians.
z = amdemod(y,Fc,Fs,ini_phase,carramp)
demodulates a signal that was created via transmitted carrier modulation instead of
suppressed carrier modulation. carramp is the carrier amplitude of the modulated signal.
z = amdemod(y,Fc,Fs,ini_phase,carramp,num,den)
specifies the numerator and denominator of the lowpass filter used in the demodulation.
ammod [Amplitude modulation]

Syntax
y = ammod(x,Fc,Fs)
y = ammod(x,Fc,Fs,ini_phase)
y = ammod(x,Fc,Fs,ini_phase,carramp)
Description:
y = ammod(x,Fc,Fs)
uses the message signal x to modulate a carrier signal with frequency Fc (Hz) using
amplitude modulation. The carrier signal and x have sample frequency Fs (Hz). The
modulated signal has zero initial phase and zero carrier amplitude, so the result is
suppressed-carrier modulation.
Note The x, Fc, and Fs input arguments must satisfy Fs > 2(Fc + BW), where BW is the
bandwidth of the modulating signal x.
y = ammod(x,Fc,Fs,ini_phase)
specifies the initial phase in the modulated signal y in radians.
y = ammod(x,Fc,Fs,ini_phase,carramp)
performs transmitted-carrier modulation instead of suppressed-carrier modulation. The
carrier amplitude is carramp.
34
fmmod [Frequency modulation]

Syntax
y = fmmod(x,Fc,Fs,freqdev)
y = fmmod(x,Fc,Fs,freqdev,ini_phase)
Description:
y = fmmod(x,Fc,Fs,freqdev)
modulates the message signal x using frequency modulation. The carrier signal has
frequency Fc (Hz) and sampling rate Fs (Hz), where Fs must be at least 2*Fc. The freqdev
argument is the frequency deviation (Hz) of the modulated signal.
y = fmmod(x,Fc,Fs,freqdev,ini_phase)
specifies the initial phase of the modulated signal, in radians.
fmdemod[ Frequency demodulation]

Syntax
z = fmdemod(y,Fc,Fs,freqdev)
z = fmdemod(y,Fc,Fs,freqdev,ini_phase)
Description:
z = fmdemod(y,Fc,Fs,freqdev)
demodulates the modulating signal z from the carrier signal using frequency demodulation.
The carrier signal has frequency Fc (Hz) and sampling rate Fs (Hz), where Fs must be at
least 2*Fc. The freqdev argument is the frequency deviation (Hz) of the modulated signal
y.
z = fmdemod(y,Fc,Fs,freqdev,ini_phase)
pmmod [Phase modulation]

Syntax
y = pmmod(x,Fc,Fs,phasedev)
y = pmmod(x,Fc,Fs,phasedev,ini_phase)
Description
y = pmmod(x,Fc,Fs,phasedev)
modulates the message signal x using phase modulation. The carrier signal has frequency
Fc (Hz) and sampling rate Fs (Hz), where Fs must be at least 2*Fc. The phasedev argument
is the phase deviation of the modulated signal in radians.
y = pmmod(x,Fc,Fs,phasedev,ini_phase)
35
pmdemod [Phase demodulation]

Syntax:
z = pmmod(y,Fc,Fs,phasedev)
z = pmmod(y,Fc,Fs,phasedev,ini_phase)
Description:
z = pmmod(y,Fc,Fs,phasedev)
demodulates the phase-modulated signal y at the carrier frequency Fc (Hz). z and the
carrier signal have sampling rate Fs (Hz), where Fs must be at least 2*Fc. The phasedev
argument is the phase deviation of the modulated signal, in radians.
z = pmmod(y,Fc,Fs,phasedev,ini_phase)
ssbdemod [Single sideband amplitude demodulation]

Syntax :
z = ssbdemod(y,Fc,Fs)
z = ssbdemod(y,Fc,Fs,ini_phase)
z = ssbdemod(y,Fc,Fs,ini_phase,num,den)
Description:
For All Syntaxes
z = ssbdemod(y,Fc,Fs)
demodulates the single sideband amplitude modulated signal y from the carrier signal
having frequency Fc (Hz). The carrier signal and y have sampling rate Fs (Hz). The
modulated signal has zero initial phase, and can be an upper- or lower-sideband signal.
The demodulation process uses the lowpass filter specified by [num,den] =
butter(5,Fc*2/Fs).
Note The Fc and Fs arguments must satisfy Fs > 2(Fc + BW), where BW is the bandwidth
of the original signal that was modulated.
z = ssbdemod(y,Fc,Fs,ini_phase)
z = ssbdemod(y,Fc,Fs,ini_phase,num,den) specifies the numerator and
denominator of the
lowpass filter used in the demodulation.
ssbmod [Single sideband amplitude modulation]

Syntax
y = ssbmod(x,Fc,Fs)
y = ssbmod(x,Fc,Fs,ini_phase)
y = ssbmod(x,fc,fs,ini_phase,'upper')
36
Description:
y = ssbmod(x,Fc,Fs)
uses the message signal x to modulate a carrier signal with frequency Fc (Hz) using single
sideband amplitude modulation in which the lower sideband is the desired sideband. The
carrier signal and x have sample frequency Fs (Hz). The modulated signal has zero initial
phase.
y = ssbmod(x,Fc,Fs,ini_phase)
y = ssbmod(x,fc,fs,ini_phase,'upper')
uses the upper sideband as the desired sideband.
REFERENCES:
1. Getting started with MATLAB7 by Rudra Pratap (Oxford press)
2. Contemporary communication systems using MATLAB by Proakis, Salehi and
Bauch (Cenage learning)
4.0 QUESTIONS:
1. What are the application areas of MATLAB?
2. List out types of file in MATLAB.
3. How to generate x and y coordinates of 100 equidistant points on a unit circle?
4. How to do array operations?
5.0 LAB 1 REPORT INSTRUCTIONS

Check out the template in the course web site.
DUE: Before next lab schedule
37

Lab 1

Uploaded by

Copyright:

Available Formats

Lab 1

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lab 1

Uploaded by

Copyright:

Available Formats

LAB 1

INTRODUCTION TO COMMUNICATION SYSTEM USING

College of Engineering & Technology

MSU-Iligan Institute of Technology

1.1 To study MATLAB and communication tool box

2.0 Equipment / Apparatus

( b ) What is the advantage of MATLAB over FORTRAN or C?

( c ) Where can we use MATLAB?

2. MATLAB GETTING STARTED

Simple Math Calculations

>> 7*12 <ENTER>

>> 12-7 <ENTER>

>>b =12 <ENTER>

>>c= a*b <ENTER>

>>d = 12/7 <ENTER>

The basic arithmetic operations are given by:

Operation Symbol Example

Variables, Expressions & Statements:

MATLAB’s statements are of the form:

>> variables = expression or

( iv) To recall previous commands, MATLAB uses the cursor keys , , →,  on

>> format short e (short exponential format)

>>format long e (long exponential format)

>>format (default format)

( vi ) To suppress the display of output of a command on screen put semicolon

( vii ) To end a session, type quit or exit at the MATLAB prompt.

will restore the workspace to list former state.

( viii ) Complex numbers i or j stands for - 1 and pi gives the value of P .

Some functions deals with complex numbers are as follows:

Information about any command or operation is available by typing:

>> help command

and to get menu of help commands type

3. WORKING WITH MATRICES:

memory, you type the following in the MATLAB prompt.

The semicolon at the end of a command suppresses the output.

The following matrix operations are available in MATLAB

>> b1 = a-b (b is subtracted from a and stores in b1)

>> c = a*b (a is multiplied with b and stores in c)

The operations *, ^, \, / can be made to operate entry-wise by preceding them by a

>> [ 1 2 3 4] .* [1 2 3 4] (element-wise product)

>> [1 2 3 4] .^ 2 (element-wise power)

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

>> size(a) (gives size of the matrix a)

>> rank(a) (Displays rank of a)

>> clear (Clear’s All variables a, b, c, a1, b1, d)

>>clc (Clears Screen)

>> a = magic(4) (Produces Magic square of size 4)

>> b = rand(5) (Generates Random matrix of size 5)

is the Hilbert matrix, the king of ill-conditioned matrix of order 5.

>> ones(5) (generates square matrix of order 5 with all entries 1)

>> zeros(6) (generates matrix with all entries zero)

Matrix building functions

Submatrices and Colon Notation

Consider a matrix a given by

>> a = [1 2 3 4;5 6 7 1;2 3 4 5]

>>c = a(:,3) (Vector consisting of 3rd column of a)

>> d = a(1:2,:) (First two rows)

>> e = a(3,:) (Third row of a)