The document describes functions and exercises for basic simulation and matrix manipulation in MATLAB. It covers creating vectors and matrices, arithmetic operations, matrix manipulations like concatenation and indexing, sorting, shifting, reshaping and flipping matrices. It also discusses generating random sequences, plotting functions, solving differential equations, and creating and accessing structures and arrays of structures. The key topics are functions for vector/matrix creation and manipulation, common mathematical operations, plotting and solving differential equations in MATLAB.

1. CSE222: Basic Simulation lab Functions (MatLab)
Module 1: Creating a One-Dimensional Array (Row / Column Vector) Exercise – Creating a vector of even
whole numbers between 31 and 75; Creating a Two-Dimensional Array (Matrix of given size) and (A).
Performing Arithmetic Operations - Addition, Subtraction, Multiplication and Exponentiation. (B). Obtaining
Modified Matrix - Inverse, Transpose, with Appended and Deleted Elements;
Module 2: Performing Matrix Manipulations - Concatenating, Indexing, Sorting, Shifting, Reshaping, Resizing
and Flipping about a Vertical Axis/Horizontal Axis; Creating Arrays X & Y of given size (1 x N) and Performing
(A) Relational Operations - >, <, ==, <=, >=, ~=
(B) Logical Operations - ~, &, |, XOR
Functions:
1. Concatenation
C = [A B] horizontally concatenates matrices A and B
C = [A; B] vertically concatenates matrices A and B
For building a matrix horizontally, each component matrix must have the same number
of rows. When building vertically, each component must have the same number of columns.
C = cat(dim, A, B) concatenates the arrays A and B along array dimension dim.
C = cat(dim, A1, A2, A3, A4, ...) concatenates all the input arrays (A1, A2, A3, A4, and so on)
along array dimension dim.
C = horzcat(A1, A2, ...) horizontally concatenates matrices A1, A2, and so on
C = vertcat(A1, A2, ...) vertically concatenates matrices A1, A2, and so on
2. Indexing
A(m, :) give the all values of mth
row
A(:, n) give the all values of nth
column
3. Sorting
sort(matrix, dimension) Dimension argument 1 sorts matrix columns. Dimension argument 2 sorts
matrix rows.
B = sort(A) sorts the elements along different dimensions of an array, and arranges those
elements in ascending order.
B = sort(A, dim) sorts the elements along the dimension of A specified by a scalar dim.
B = sort(...,mode) sorts the elements in the specified direction, depending on the value of
mode.
'ascend' Ascending order (default)
'descend' Descending order
4. Shifting
B = circshift(A, shiftsize) circularly shifts the values in the array, A, by shiftsize elements
5. Reshaping and Resizing
B = reshape(A,m,n) returns the m-by-n matrix B whose elements are taken column-wise from
A. An error results if A does not have m*n elements.
B = reshape(A,m,n,p,...) or B= reshape(A,[m n p ...]) returns an n-dimensional array with the
same elements as A but reshaped to have the size m-by-n-by-p-by-.... The product of the specified
dimensions, m*n*p*..., must be the same as prod(size(A)).
B = rot90(A) rotates matrix A counterclockwise by 90 degrees.
B = rot90(A,k) rotates matrix A counterclockwise by k*90 degrees, where k is an integer.
6. Flipping
B = fliplr(A) returns A with columns flipped in the left-right direction, that is, about a vertical
axis.

2. B = flipud(A) returns A with rows flipped in the up-down direction, that is, about a horizontal
axis.
B = flipdim(A,dim) returns A with dimension dim flipped. When the value of dim is 1, the
array is flipped row-wise down. When dim is 2, the array is flipped columnwise left to right.
flipdim(A,1) is the same as flipud(A), and flipdim(A,2) is the same as fliplr(A).
7. Relational Operations
A < B A > B A <= B A >= B A == B A ~= B
The relational operators are <, >, <=, >=, ==, and ~=. Relational operators perform element-
by-element comparisons between two arrays. They 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 operators <, >, <=, and >= use only the real part of their operands for the
comparison. The operators == and ~= test real and imaginary parts.
8. Logical Operations
A & B A| B ~A
The symbols &, |, and ~ are the logical array operators AND, OR, and NOT. These operators
are commonly used in conditional statements, such as if and while, to determine whether or not
to execute a particular block of code. Logical operations return a logical array with elements set to
1 (true) or 0 (false), as appropriate.
xor(A,B) represents the logical exclusive disjunction. xor(A,B) is true when either A or B are
true. If both A and B are true or false, xor(A,B) is false.
Module 3: Generating a set of Commands on a given Vector (Example: X = [1 8 3 9 0 1]) to
(A) Add up the values of the elements (Check with sum)
(B) Compute the Running Sum (Check with sum), where Running Sum for element j = the sum of the
elements from 1 to j, inclusive.
(C) Compute the Sine of the given X-values (should be a vector).
Also, Generating a Random Sequence using rand() / randn() functions and plotting them.
Functions:
1. Sum
B = sum(A) returns sums along different dimensions of an array. If A is floating point, that is
double or single, B is accumulated natively, that is in the same class as A, and B has the same class as
A.
If A is not floating point, B is accumulated in double and B has class double.
If A is a vector, sum(A) returns the sum of the elements.
If A is a matrix, sum(A) treats the columns of A as vectors, returning a row vector of the sums of each
column.
If A is a multidimensional array, sum(A) treats the values along the first non-singleton dimension as
vectors, returning an array of row vectors.
B = sum(A,dim) sums along the dimension of A specified by scalar dim. The dim input is an integer
value from 1 to N, where N is the number of dimensions in A. Set dim to 1 to compute the sum of
each column, 2 to sum rows, etc.
B = cumsum(A) returns the cumulative sum along different dimensions of an array.
If A is a vector, cumsum(A) returns a vector containing the cumulative sum of the elements of A.
If A is a matrix, cumsum(A) returns a matrix the same size as A containing the cumulative sums for
each column of A.
If A is a multidimensional array, cumsum(A) works on the first nonsingleton dimension.
B = cumsum(A,dim) returns the cumulative sum of the elements along the dimension of A specified by
scalar dim. For example, cumsum(A,1) works along the first dimension (the columns); cumsum(A,2)
works along the second dimension (the rows).

3. 2. Sine function
Y = sin(X) returns the circular sine of the elements of X. The sin function operates element-
wise on arrays. The function's domains and ranges include complex values. All angles are in radians.
3. rand()
r = rand(n) returns an n-by-n matrix containing pseudorandom values drawn from the
standard uniform distribution on the open interval (0,1).
r = rand(m,n) or r = rand([m,n]) returns an m-by-n matrix.
r = rand(m,n,p,...) or r = rand([m,n,p,...]) returns an m-by-n-by-p-by-... array.
r = rand returns a scalar.
r = rand(size(A)) returns an array the same size as A.
4. randn()
r = randn(n) returns an n-by-n matrix containing pseudorandom values drawn from the
standard normal distribution.
r = randn(m,n) or r = randn([m,n]) returns an m-by-n matrix.
r = randn(m,n,p,...) or r = randn([m,n,p,...]) returns an m-by-n-by-p-by-... array.
r = randn returns a scalar.
r = randn(size(A)) returns an array the same size as A.
5. plot()
plot(Y) plots the columns of Y versus the index of each value when Y is a real number. For
complex Y, plot(Y) is equivalent to plot(real(Y),imag(Y))
Module 4: Evaluating a given expression and rounding it to the nearest integer value using Round,
Floor, Ceil and Fix functions; Also, generating and Plots of (A) Trigonometric Functions - sin(t), cos(t), tan(t),
sec(t), cosec(t) and cot(t) for a given duration ‘t’. (B) Logarithmic and other Functions – log(A), log10(A), Square root
of A, Real nth
root of A.
Functions:
1. Round
Y = round(X) rounds the elements of X to the nearest integers. Positive elements with a fractional
part of 0.5 round up to the nearest positive integer. Negative elements with a fractional part of -0.5
round down to the nearest negative integer. For complex X, the imaginary and real parts are rounded
independently.
2. Floor
B = floor(A) rounds the elements of A to the nearest integers less than or equal to A. For complex
A, the imaginary and real parts are rounded independently.
3. Ceil
B = ceil(A) rounds the elements of A to the nearest integers greater than or equal to A. For complex
A, the imaginary and real parts are rounded independently.
4. Fix
B = fix(A) rounds the elements of A toward zero, resulting in an array of integers. For complex
A, the imaginary and real parts are rounded independently.
Example:-
a = [-1.9, -0.2, 3.4, 5.6, 7.0, 2.4+3.6i]
a = -1.9000 -0.2000 3.4000 5.6000 7.0000 2.4000 + 3.6000i
>> round(a)
ans = -2.0000 0 3.0000 6.0000 7.0000 2.0000 + 4.0000i
>> floor(a)
ans = -2.0000 -1.0000 3.0000 5.0000 7.0000 2.0000 + 3.0000i
>> ceil(a)
ans = -1.0000 0 4.0000 6.0000 7.0000 3.0000 + 4.0000i
>> fix(a)

4. ans = -1.0000 0 3.0000 5.0000 7.0000 2.0000 + 3.0000i
5. Square root
B = sqrt(X) returns the square root of each element of the array X. For the elements of X that are
negative or complex, sqrt(X) produces complex results.
6. Real nth
root
y = nthroot(X, n) returns the real nth root of the elements of X. Both X and n must be real and n
must be a scalar. If X has negative entries, n must be an odd integer.
Module 5: Creating a vector X with elements, Xn = (-1)n+1
/(2n-1) and Adding up 100 elements of the
vector, X; And, plotting the functions, x, x3
, ex
and exp(x2
) over the interval 0 < x < 4 (by choosing appropriate
mesh values for x to obtain smooth curves), on (A). A Rectangular Plot (B). A Semi log Plot (C). A log-log Plot
Module 6: Generating a Sinusoidal Signal of a given frequency (say, 100Hz) and Plotting with Graphical
Enhancements - Titling, Labelling, Adding Text, Adding Legends, Adding New Plots to Existing Plot, Printing
Text in Greek Letters, Plotting as Multiple and Subplots; Also, Making Non-Choppy and Smooth Plot of
the functions, f(x) = sin(1/x) for 0.01< x < 0.1 and g(x) = (sin x) /x.
Module 7: Creating a Structure, an Array of Structures and Writing Commands to Access Elements of the
created Structure and Array of Structures; Also, Solving First Order Ordinary Differential Equation using Built-
in Functions; And, Creating an M x N Array of Random Numbers using rand and setting any value that
is < 0.2 to ‘0’ and any value that is ≥ 0.2 to ‘1’ by moving through the Array, Element by Element.
Functions:
1. s = struct creates a scalar (1-by-1) structure with no fields.
2. s = struct(field,value) creates a structure array with the specified field and values.
Example:
Create a nonscalar structure with one field, f.
field = 'f';
value = {'some text';
[10, 20, 30];
magic(5)};
s = struct(field,value)
s =
3x1 struct array with fields:
f
View the contents each element.
s.f
ans =
some text
ans =
10 20 30
ans =
17 24 1 8 15
23 5 7 14 16

5. 4 6 13 20 22
10 12 19 21 3
11 18 25 2 9
When you access a field of a nonscalar structure, such as s.f, MATLAB returns a comma-separated
list. In this case, s.f is equivalent to s(1).f, s(2).f, s(3).f.
3. s = struct(field1,value1,...,fieldN,valueN) creates a structure array
Example
Create a nonscalar structure with several fields.
field1 = 'f1'; value1 = zeros(1,10);
field2 = 'f2'; value2 = {'a', 'b'};
field3 = 'f3'; value3 = {pi, pi.^2};
field4 = 'f4'; value4 = {'fourth'};
s = struct(field1,value1,field2,value2,field3,value3,field4,value4)
s =
1x2 struct array with fields:
f1
f2
f3
f4
The cell arrays for value2 and value3 are 1-by-2, so s is also 1-by-2. Because value1 is a numeric array and not a
cell array, both s(1).f1 and s(2).f1 have the same contents. Similarly, because the cell array for value4 has a single
element, s(1).f4 and s(2).f4 have the same contents.
s(1)
ans =
f1: [0 0 0 0 0 0 0 0 0 0]
f2: 'a'
f3: 3.1416
f4: 'fourth's(2)ans =
f1: [0 0 0 0 0 0 0 0 0 0]
f2: 'b'
f3: 9.8696
f4: 'fourth'
4. s = struct([ ]) creates an empty (0-by-0) structure with no fields.
Module 8: Generating normal and integer random numbers (1-D & 2-D) and plotting them; Also,
Writing a Script (which keeps running until no number is provided to convert) that asks for Temperature
in degrees Fahrenheit and Computes the Equivalent Temperature in degrees Celsius. [Hint: Function is empty is
useful]
Module 9: Writing brief Scripts starting each Script with a request for input (using input) to Evaluate the
function h(T) using if-else statement, where
h(T) = (T – 10) for 0 < T < 100
= (0.45 T + 900) for T > 100.
Exercise: Testing the Scripts written using (A). T = 5, h = -5 and (B). T = 110, h = 949.5
Also, Creating a Graphical User Interface (GUI); And, Curve Fitting using (A) Straight line Fit (B). Least Squares
Fit.

6. Functions:
1. p = polyfit(x,y,n) finds the coefficients of a polynomial p(x) of degree n that fits the data, p(x(i)) to
y(i), in a least squares sense. The result p is a row vector of length n+1 containing the polynomial
coefficients in descending powers:
2. y = polyval(p,x) returns the value of a polynomial of degree n evaluated at x. The input argument p
is a vector of length n+1 whose elements are the coefficients in descending powers of the polynomial
to be evaluated.
y = p1xn
+ p2xn–1
+ …+ pnx + pn+1
x can be a matrix or a vector. In either case, polyval evaluates p at each element of x.
Module 10: Interpolation based on following Schemes (A). Linear (B). Cubic (C). Spline Also, Generating
the first Ten Fibonacci numbers according to the relation Fn = Fn-1 + Fn-2 with F0 = F1 = 1, and Computing the
ratio Fn / Fn-1 for the first 50 Fibonacci numbers.
[Exercise: Verifying that the computed ratio approaches the value of the golden mean (1 + sqrt(5)) / 2 ]; Also
Generating Equivalent Square Wave from a Sine Wave of given Amplitude and Frequency; And,. Obtaining
the Covariance & Correlation Coefficient Matrices for a given Data Matrix.
Functions:
1. yi = interp1(x,Y,xi) interpolates to find yi, the values of the underlying function Y at the points in the
vector or array xi. x must be a vector. Y can be a scalar, a vector, or an array of any dimension, subject
to the following conditions:
a. If Y is a vector, it must have the same length as x. A scalar value for Y is expanded to have
the same length as x. xi can be a scalar, a vector, or a multidimensional array, and yi has the
same size as xi.
b. If Y is an array that is not a vector, the size of Y must have the form [n,d1,d2,...,dk], where n
is the length of x. The interpolation is performed for each d1-by-d2-by-...-dk value in Y. The
sizes of xi and yi are related as follows:
i. If xi is a scalar or vector, size(yi) equals [length(xi), d1, d2, ..., dk].
ii. If xi is an array of size [m1,m2,...,mj], yi has size [m1,m2,...,mj,d1,d2,...,dk].
Example:
Generate a coarse sine curve and interpolate over a finer abscissa.
x = 0:10;
y = sin(x);
xi = 0:.25:10;
yi = interp1(x,y,xi);
plot(x,y,'o',xi,yi)
2. yy = spline(x,Y,xx) uses a cubic spline interpolation to find yy, the values of the underlying function
Y at the values of the interpolant xx. For the interpolation, the independent variable is assumed to be
the final dimension of Y with the breakpoints defined by x. The sizes of xx and yy are related as
follows:
a. If Y is a scalar or vector, yy has the same size as xx.
b. If Y is an array that is not a vector,
i. If xx is a scalar or vector, size(yy) equals [d1, d2, ..., dk, length(xx)].
ii. If xx is an array of size [m1,m2,...,mj], size(yy) equals [d1,d2,...,dk,m1,m2,...,mj].
Example:
This generates a sine curve, then samples the spline over a finer mesh. x = 0:10;
y = sin(x);
xx = 0:.25:10;
yy = spline(x,y,xx);
plot(x,y,'o',xx,yy)