# Appendix F: Matlab

Under major construction

Matlab (short for matrix laboratory)
is a specialized numerical computing environment and programming language.
It has built-in support for manipulating matrices, complex numbers, and data visualization.
It is widely used by scientists and engineers in industry and academia.
Runs on most popular operating systems.
Can use as a powerful calculator and data visualization tool. More importantly,
you can *program* in Matlab. Can best exploit and appreciate Matlab
after you've take a course in linear algebra.
Here is an
online tutorial.

## Features.

Good for rapid prototyping and "programming in the small." Many modern programming features tacked on (cell arrays, structures, objects, nested functions, anonymous functions, function pointers, operator overloading), but esoteric and inconsistent notation. As a result many Matlab programmers never use them.## Availability.

It's proprietary commercial software distributed by The MathWorks. Many universities have a site license or laboratories where it is installed.## Hello World.

Matlab is not explicitly compiled. Interactive interpreter: enter commands in Command window (analogous to DrJava Interaction Pane) Save away a sequence of commands in a Script-M file (analogous to sequence of statements in main()).## Built-in types of data.

"Everything is an array". Matlab has 15 fundamental types: int8, uint8, int16, uint16, int32, uint32, int64, uint64, single, double, logical, char, cell, structure, and function handle. All of these are in the form of an array (from a minimum of 0-by-0 in size to d-dimensional array of any size). Can also access user defined types: user classes and Java classes. The default data type is a 2D array (or matrix) of doubles. Strings = char array (though to create an array of strings of different sizes, use a cell array).In Matlab, complex numbers are doubles with a real part and an imaginary part. (Behind the scenes Matlab, stores 2 parallel double vectors, one for the real part and one for the imaginary part.) Good idea to set i = sqrt(-1) before using (since you may have changed the value of i earlier).

Representation is same as for Java. Floating point numbers use IEEE 754; integers are two's complement.

*Scalar operators.*
+, -, *, / (floating point division), ^ (for exponentiation).

Note: use rem(17, 3) for integer remainder instead of %.

*Comparison operators.*
< <= > >= == ~= (instead of !=).
Returns a `logical`, which has the value `1` for true
and `0` for false.

*Boolean operators.*
&&, ||, ~ (instead of !)

*Math library.*
sqrt(), rand(), pi, abs()
The following
illustrates how to do basic arithmetic calculations.

% matlab format compact >> besselk(1, -3) ans = -0.0402 -12.4199i >> erf(0.9) ans = 0.7969

*Strings.*
String literal: 'hello' instead of "hello".
String concatenation: a = ['hello' 'world']

*Precedence order.*
Precedence order, parentheses, associativity.

*Statements.*
Statements end with a semicolon; if you omit the semicolon
you get an echo response.

*Variables.*
Case-sensitive.

radius = 25.3; area = pi * radius^2;

*Dynamically typed.*
Java is strongly typed and statically typed.
Every expression and variable has a type that
is known (and checked) and compile-time.
Matlab is dynamically typed. Variables declared without defining their types.
The type is determined at runtime.
Seems easier for programmer, but significantly more error-prone.
When Matlab encounters a new variable, it automatically
allocates the right amount of storage; when a variable changes, it re-allocates
memory if necessary.
Weakly typed (type of variable is not enforced, e.g., can concatenate
string "12" and the integer 3 to get "123", then treat it as
an integer, all without any explicit conversions).
Matlab is very weakly typed.

Disadvantage: errors not discovered until run-time. For example, the constant i is pre-defined as the square root of -1. However, you can redefine it to be an integer or an array. Or, if you name a variable the same name as a function, this will hide the function, making it impossible to call. Be careful!

a = 5; % 1-by-1 double a = [2 3 4]; % 1-by-3 double a = 10 < 17; % 1-by-1 logical a = a + a; % 1-by-1 double class(a)

min = 17; min(rand(100, 1)); % error class(a)

% awkward type checking is leap year if (round(year) ~= year)) error('Year must be an integer.') end

## Conditionals and loops.

Conditionals: if statements are similar to Java.Loops. While loop similar; for loop less expressive (can only iterate a variable over the elements of an array).

if (x < 0) x = -x; end if (x > y) max = x; else max = y; end if (income < 0) rate = .00; elseif (income < 47450) rate = .25; elseif (income < 174700) rate = .28; elseif (income < 311950) rate = .33; else rate = .35; end

% print largest power of two less than or equal to N v = 1; while (v <= N/2) v = 2 * v end v % compute a finite product N! = 1 * 2 * ... * N product = 1; for i = 1:N product = product * i; end product % or more simply product = prod(1:N)

## Arrays.

Vectors and matrices.*Creating vectors and matrices.*
(linspace, colon, ones, zeros, rand).

A = [ 1 2 3; 4 5 6 ]; % 2-by-3 matrix B = [ 1 2; 3 4; 5 6 ]; % 3-by-2 matrix x = [ 1 2 3 ]; % row vector y = [ 1; 2; 3 ]; % column vector A = rand(3, 4); % random 3-by-4 matrix y = zeros(1, 10); % length 10 row vector of all zeros x = 1:10; % length 10 vector of 1, 2, ..., 10 z = linspace(0, 10, 100); % length 100 vector of values evenly between 0 and 10

*Matrix and vector operations.*
Indexing: use a(i) to access ith element.
Java is 0-based; Matlab is 1-based indexing.
Subarray and submatrices using colon notation.

Vector operations: most functions work with vector arguments.
Also `mean()`, `min()`, `max()`,
`std()`, `median()`.

% plot sinc function = sin x / x, from pi/100 to 10pi x = pi/100 : pi/100 : 10*pi; % x = linspace(pi/100, 10*pi, 1000); y = sin(x) ./ x; plot(x, y)

Matrix scaling, addition, multiplication, transpose, element-by-element arithmetic.

*Vectorization.*
Prior to Matlab 6.5, very costly to perform loops.
JIT-Accelerator improved performance by orders
of magnitude. Must pre-allocate memory before loop.
x = linspace(0, 2*pi, N);
y = sin(x);
vs.
x = 0;
y = zeros(1, N);
for i = 1:N
y(i) = sin(2 * pi * (i-1) / N);
end

## Input and output.

printf printing System.out.println("Hello") disp('Hello') formatted printing System.out.printf("%8.4f\n", x) fprintf('%8.4f\n', x)

x = input('Enter a value\n');Enter a value3.14

## Functions.

Matlab provides many built-in functions. As in Java, Matlab cannot include ever function that you might need. Accordingly, you can implement your own functions using*M-file functions*. Function has same name as the M-file.

Like Java, M-file functions can have any number of input arguments. Unlike Java, they can also have any number of output arguments.

Can return multiple values from a function.

% keyword, output argument, function name, input arguments function c = hypotenuse(a, b) c = sqrt(a*a + b*b);

Overloading. Annoying to support two functions with the same name, but different signatures. Here's a hack.

function [c, d] = f(a, b) % multiple output arguments function g(a, b) % no output arguments

(Matlab does have class directories where you put different overloaded functions by putting in separate subdirectories named

function y = phi(x, mu, sigma) if nargin == 1 y = exp(-x.^2 / 2) / sqrt(2 * pi); else y = exp(-((x-mu)/sigma).^2 / 2) / sqrt(2 * pi * sigma); end

`\@int32`and

`\@double`.)

Sound waves. Matlab especially suited to signal processing.

Then, to play a note:

function a = note(pitch, duration) hz = 440 * 2^(pitch / 12); mid = tone(1.0*hz, duration); hi = tone(2.0*hz, duration); lo = tone(0.5*hz, duration); a = .5*mid + .25*hi + .25*lo; end function a = tone(hz, duration) SAMPLES_PER_SECOND = 44100; N = floor(SAMPLES_PER_SECOND * duration); i = 0:N; a = sin (2 * pi * i * hz / SAMPLES_PER_SECOND); end

plot(note(0, .005)); sound(note(0, 1), 44100);

*Pass by value.*
When you call a function (or make an assignment) the arguments
get copied. If you modify the argument within the function,
you are modifying a copy of the argument local to the function.
To modify variables from wtihin a function you need to
return the result when finished.

Matlab uses a scheme called

x = f(x);

*copy on write*to optimize when you pass a big array to a function, it only copies it if you modify one of the variables. Thus, you can freely pass large arrays to functions without worrying about overhead (provided you don't change them).

But watch out if you pass large arrays and then modify the variables. Swap function very ineffcient. The following function takes time and space proportional to the length of the vector x. Matlab is consistently pass-by-value, so if a function modifies an array, it must return the result via output parameters.

function x = swap(x, i, j) %SWAP Swap elements i and j in vector x % x = swap(x, i, j) swap elements i and j in array x x([i j]) = x([j i]); end

function x = shuffle(x) %SHUFFLE Shuffle an array of values. % x = shuffle(x) shuffles the vector x in random order. % Since this function changes the vector x, % it creates a copy of it. n = length(x); disp n for index = 1:n % a random number between i and n r = index + floor((n-index+1) * rand()); % swap elements index and r x([index r]) = x([r index]); end

*Subfunctions.*
Can include a helper function in the same M-file
as the primary function. In Matlab, these are called
*subfunctions*. They cannot be called directly
from outside the M-file, e.g., private.
Only the first function defined in a file is public.

Caveat: y = f(x) can be either a function call or an array access, depending on context.

## Recursion.

Recursion is fully supported.

function d = mygcd(x, y) %MYGCD Return the gcd of two integers. % d = gcd(x, y) returns the greatest common divisor % of x and y. % awkward type checking if (round(x) ~=x) || (round(y) ~=y) error('Requires integer input arguments.') end % Euclid's algorithm if y == 0 d = x; else d = mygcd(y, rem(x, y)); end

- local vs $global$ variables (scope) - $error$, $warning$ - nested functions

## Libraries.

A key feature of Matlab is its extensive numerical libraries. Image processing, optimization, ....Rich libraries for scientific computing: besselj(), gcd(),

Each M-function file can only have one
function visible to the outside world.
Results in a surfeit of files.
Matlab programmers can organize a bunch of related M-files into
a *toolbox*, which basically amounts to storing lots
of files in the same directory.

## Linear algebra.

In Matlab, the primary data type is a complex matrix. A scalar is a 1-by-1 matrix; a vector is a 1-by-N or N-by-1 matrix. The following illustrates how to solve systems of linear equations with the \ operator. When the system is over-determined, the result is a least squares solution. (See section xyz.)

>> A = [0, 1, 1; 2, 4, -2; 0, 3, 15] A = 0 1 1 2 4 -2 0 3 15 >> b = [4; 2; 36] b = 4 2 36 >> x = A \ b x = -1 2 2 >> A * x ans = 4.0000 2.0000 36.0000

One of the most powerful features of Matlab is its extensive numerical linear algebra library.

>> cond(A) ans = 58.8670 >> eig(A) ans = 13.5765 -0.6419 2.0654 >> [Q R] = qr(A) Q = -0.1078 0.5683 -0.8157 -0.6470 -0.6631 -0.3765 -0.7548 0.4872 0.4392 R = -9.2736 -9.4893 -7.7640 0 1.7186 5.4264 0 0 1.1294 >> svd(A) ans = 15.8836 4.2000 0.2698

## Matlab Libraries.

Matlab also has numerous libraries geared toward scientific and commercial applications including: solving systems of ODEs, signal processing, wavelets, equation solving, linear and nonlinear optimization, neural networks, image processing, interpolation, polynomials, data analysis, Fourier transforms, elementary and special mathematical functions, and digital audio. Matlab tutorial Also string libraries including regular expressions.**Programming in Matlab.**
Loops, conditionals, functions, building re-usable libraries, function handles,
data types (8, 16, 32- bit integers, multi-dimensional arrays, strings, struct).
MATLAB includes OOP features, including
classes
and objects, operator overloading, inheritance, although it is fairly well hidden.
It is even possible to
call
Java from Matlab.
However, Matalb does not support passing arguments by reference (pointers).

All objects are immutable - to "change" an object, you need to pass the object as
an input argument and return a new object with the data changed.
Private helper methods are implemented by putting the methods in a subdirectory
named `private`.
Matlab supports operator overloading. use `display` method as analog of
`toString()`.
Use `subsref` to overload subscripted reference, `plus`, `minus`,
`mtimes`, for addition, subtraction, and multiplication.

## Objects.

Awkward and rarely used in practice.
Function functions. Functions handles *are* data types
in Matlab.
Can pass functions to other functions (feval, eval, fzero, ezplot).

## Data structures.

No support for references or pointers. Difficult to implement linked structures.## Integration with Java.

Matlab is tightly integrated with Java - the Matlab interpreter is written in Java. Can directly call Java code.

s = java.lang.String('hello, world') s = s.replaceAll('l', 'abc')

Concept Java Matlab --------------------------------------------------------------------- Comments (single line) // single-line commment % single line comment Comment (multi-line) /* multi-line comment */ %{ multi-line comment %} regular expressions indexOf(), replaceAll() regexp() array of strings String[] need to use cell array (unless strings are of same length) + strings - characters as ASCII codes - converting - num2str, str2num - comparing strings - concatenating strings - $double$, $char$