Lesson 1: Introduction to MATLAB

by

Akos Ledeczi and Mike Fitzpatrick

 Lead instructor: Mike Fitzpatrick
 Supported by: Akos Ledeczi and Robert Tairas
 Vanderbilt University School of Engineering
 Purpose
◦ To teach computer programming to people who have little
or no experience with programming
 Level
◦ Introductory college course
 Length:
◦ 8 weeks of video lectures
◦ Extra week for final homework submission
 First high-level language: FORTRAN (1954)
◦ To make programming easier, especially to solve
numerical problems
 Today’s languages: 1970s-
◦ For commercial, “shrink-wrapped”, large, complex
programs: C, C++, Java, C#, etc.
◦ To make programming easier and to solve numerical
problems: MATLAB
 Invented by Prof. Cleve Moler to make
programming easy for his students
◦ Late 1970s
◦ University of New Mexico
 The MathWorks, Inc. was formed in1984
◦ By Moler and Jack Little
◦ One product: MATLAB
 Today
◦ 100 products
◦ Over 1,000,000 users
◦ Taught in 5,000 universities
 In 2012 the IEEE gave Cleve Moler its annual
Computer Pioneer Award
◦ “For Improving the quality of mathematical software,
making it more accessible, and creating MATLAB”
 This course is our effort to add to the impact
of Moler’s creation by using it to make
computer programming more accessible to
you.
 We approach MATLAB programming as part
of computer science.
 We use the concepts and vocabulary of
computer science to introduce computer
programming.
 This approach gives an idea of how computer
scientists think...
 and makes it easier to learn MATLAB!
 www.mathworks.com
 Paying for MATLAB
◦ Student: $50
◦ MATLAB instructor: Free!
◦ Companies: $100s per user
 Trying MATLAB for free
◦ For everybody: 30 days
◦ For students in this course: free for12 weeks!
 How to get it? Visit class website for info.
 eBook
 Title and authors:
same as the course!
 Recommended, but not
required.
 Current version used at
Vanderbilt since 2013
 Previous versions used at
Vanderbilt since 2000
J. Michael Fitzpatrick
and Ákos Lédeczi
 Both Apple (iBook for
iPad and Mac) and PDF
versions are available for
$9.99 at
◦ cs103.net
 Three main chapters
◦ Chapters 1 and 2 are covered
in this course
◦ The more advanced concepts
in Chapter 3 can be learned
on your own from the book
after completion of this
course J. Michael Fitzpatrick
and Ákos Lédeczi
Lesson 2: Matrices and Operators

by

Akos Ledeczi and Mike Fitzpatrick

 Array
◦ Any set of numbers arranged in a rectangular
pattern.
10 14 48 25

Example—
A page with six rows
24 34 17 35

of four numbers each

is a two-dimensional 22 33 29 44

array
32 8 11 48

35 6 37 27

37 25 13 7
 Array
◦ Any set of numbers arranged in a rectangular
pattern.
10 14 48 25
27 1 9 23
8 46 18 38
Three-dimensional
24 34 17 35
39 17 30 5
Example— 13 18 41
22
37
33 29 44
A stack of such 46 8 13 12
pages 42 10 29
32
19
8 11 48
7 39 33 45
13 13 27 28
35 6 37 27
28 16 34 8
40 31 45 4
37 25 13 7
24 26 37 41
12 24 15 3
 Higher dimensions are uncommon
 The most common have special names:
◦ 2D array = “matrix” (plural is “matrices”)
◦ 1D array = “vector”
 Most ingenious part of Cleve Moler’s
invention of MATLAB was the way he set it up
to deal with matrices.
 MATLAB stands for “Matrix Laboratory”!
>> X = [1:4; 5:8; 9:12];

1: 1 2 3 4
2: 5 6 7 8 rows
3: 9 10 11 12
>> X = [1:4; 5:8; 9:12];

1: 2: 3: 4:

1 2 3 4
5 6 7 8
9 10 11 12
columns
>> X = [1:4; 5:8; 9:12];
>> X(2,3)
3:

1 2 3 4
2: 5 6 7 8
9 10 11 12

>> ans =
7
 Z = X + Y means
◦ Z(m,n) = X(m,n) + Y(m,n) for all valid m and n
 Different from Array Multiplication!
 Z = X * Y means that for all valid m and n

 Not always legal:

◦ Inner dimensions of X and Y must be the same
 Z = X./Y
◦ means that for each m and n, Z(m,n) = X(m,n)/Y(m,n)
 Z = X.\Y
◦ means that for each m and n, Z(m,n) = Y(m,n)/X(m,n)
 Try these out in MATLAB on your own!
 Matrix division is a complicated concept in
linear algebra, so we are not covering it here
◦ But you can check out the advanced concepts of the
textbook for detailed explanation
 x = a + b + c
◦ order does not matter with addition
 y = c + a * b is not the same as
 y = (c + a) * b
 Multiplication has priority over addition
◦ In programming, this is called precedence

Precedence Table
 x = a + b + c
 x = a * b * c
◦ order does not matter with addition or multiplication
 y = a ^(b ^ c) is not the same as
 y = (a ^ b)^ c
 In programming, the order in which operators
of the same precedence are executed is called
associativity
 In MATLAB, it is left to right
 y = a ^ b ^ c is the same as
 y = (a ^ b) ^ c
Lesson 3: Functions

by

Akos Ledeczi and Mike Fitzpatrick

 function [out_arg1, out_arg2, ...] =
function_name (in_arg1, in_arg2, ...)
 Examples
◦ function func
◦ function func(in1)
◦ function func(in1, in2)
◦ function out1 = func
◦ function out1 = func(in1)
◦ function [out1, out2] = func
◦ function [out1, out2] = func(in1, in2)
◦ …
 Use meaningful names that tell you
something about what your function does
 Do not use existing names, e.g., plot, sum,
sqrt, sin, etc.
◦ MATLAB already has these
◦ It would get really confusing really fast
◦ To check whether a name is already in use, try the
built-in exist function. To see how it works, try

>> help exist

 Functions allow you to break down large,
complex problems to smaller, more
maneagable pieces
 Functional decomposition
 Reusability
 Generality
◦ A function can solve a set of related problems not just
a specific one by accepting input arguments.
◦ For example, the built-in function plot can draw a
wide range of figures based on its input
Lesson 4: Programmer’s Toolbox

by

Akos Ledeczi and Mike Fitzpatrick

 Polymorphic: having multiple forms
 If a function can handle calls when the same
input argument has different types:
polymorphic function
 If a function can handle a variable number of
input arguments: polymorphic also
 Many MATLAB functions return an output that
has the same shape as the input provided
(e.g., sqrt)
 Polymorphism is very powerful
 When we start MATLAB and call rand, it
always returns the same exact number:
0.8147 (As an exercise, try it at home!)
 Pseudo random number generator: initialized
at startup and it generates the exact same
sequence of numbers every time
 Repeatability for testing the program: good!
 What if we want “truly” random numbers?
 Initialize the MATLAB pseudo random number
generator with rng!
 It is easy to make mistakes!
 Syntax errors:
◦ MATLAB catches these
 Semantic errors
◦ Some may cause errors that MATLAB can catch
◦ Some may cause the wrong result every time
◦ Some may only cause problems occasionally (e.g.,
with a certain combination of inputs):
 Hard to notice and find the cause of
 MATLAB has built-in debugger
◦ Tool to help find errors (bugs)
Lesson 5: Selection

by

Akos Ledeczi and Mike Fitzpatrick

 Sequential control
◦ Sequence of commands executed one after the other
 MATLAB interpreter
◦ Part of the MATLAB program that interprets and
executes the various commands
◦ Sequential control: default
 Control construct
◦ A method by which the interpreter selects the next
command to execute
◦ Sequential control: default
◦ Selection or Branching
 Most common selection construct: if-statement
 Example:
function guess_my_number(x)
if x == 2
fprintf('Congrats! You guessed my number.\n');
end
 Begins with control statement
◦ if keyword followed by a condition
 Ends with statement: end
 In between: statements to be executed if and
only if condition is true
control
control
statement
statement

x == 2

block
control
statement
control
statement

x == 2

block
control
statement
control
statement

x == 2

block
 Executing a different set of statements based
on the condition:

function guess_my_number(x)
if x == 2
fprintf('Congrats! You guessed my number!\n');
else
fprintf('Not right, but a good guess.\n');
end
 control
statement

x == 2

block2

block1
 control
statement

x == 2

block2

block1
 control
statement

x == 2

block2

block1
 if-statement:

if conditional
block
end
 Produces a result that depends on the
relation between its two operands
 It can appear outside if-statements!
 Logical values:
◦ Non-zero: true
◦ Zero: false
◦ MATLAB returns 1 for true
 How to combine logical values?
 Logical operators:
 not:
◦ flips the value of its (single) operand
 and:
◦ true if and only if both of its operands are true
 or:
◦ false if and only if both of its operands are false

false false
false true
true false
true true
 not:
◦ flips the value of its (single) operand
 and:
◦ true if and only if both of its operands are true
 or:
◦ false if and only if both of its operands are false
>> help precedence
1. transpose (.'), power (.^), complex conjugate
transpose ('), matrix power (^)
2. unary plus (+), unary minus (-), logical negation (~)
3. multiplication (.*), right division (./), left
division (.\), matrix multiplication (*), matrix right
division (/), matrix left division (\)
4. addition (+), subtraction (-)
5. colon operator (:)
6. less than (<), less than or equal to (<=),
greater than(>), greater than or equal to (>=),
equal to (==), not equal to (~=)
7. element-wise logical AND (&)
8. element-wise logical OR (|)
9. short-circuit logical AND (&&)
10. short-circuit logical OR (||)
 if-statements can contain other if-statements
 Consider the example with a single if-elseif-
else statement:

function ultimate_question(x)
if x == 42
fprintf('Wow! You answered the question.\n');
elseif x < 42
fprintf('Too small. Try again.\n');
else
fprintf('Too big. Try again.\n');
end
 Here is a version with nesting:

function ultimate_question_nested(x)
if x == 42
fprintf('Wow! You answered the question.\n');
else
if x < 42
fprintf('Too small. Try again.\n');
else
fprintf('Too big. Try again.\n');
end
end
 Here is another version with nesting:

function ultimate_question_nested2(x)
if x <= 42
if x == 42
fprintf('Wow! You answered the question.\n');
else
fprintf('Too small. Try again.\n');
end
else
fprintf('Too big. Try again.\n');
end
 Functions that behave differently based on
◦ Number of input or output arguments
◦ Type of input or output arguments
 Many built-in functions are polymorphic
(sqrt, max, size, plot, etc.)
 How do we make our functions
polymorphic?
 Two built-in functions:
◦ nargin: returns the number of actual input
arguments that the function was called with
◦ nargout: returns the number of output arguments
that the function caller requested
 function [table summa] = multable(n, m)

 The function multable returns an n-by-m

multiplication table in the output argument table
 Optionally, it can return the sum of all elements
in the output argument summa
 If m is not provided, it returns and n-by-n matrix
function [table summa] = multable(n, m)

if nargin < 2
m = n;
end

table = (1:n)' * (1:m);

if nargout == 2
summa = sum(table(:));
end
 A function declaration specifies:
◦ Name of the function,
◦ Number of input arguments, and
◦ Number of output arguments
 Function code and documentation specify:
◦ What the function does, and
◦ The type of the arguments
◦ What the arguments represent
 Robustness
◦ A function is robust if it handles erroneous input and
output arguments, and
◦ Provides a meaningful error message
function [table summa] = multable(n, m)

if nargin < 1
error('must have at least one input argument');
end
if nargin < 2
m = n;
elseif ~isscalar(m) || m < 1 || m ~= fix(m)
error('m needs to be a positive integer');
end
if ~isscalar(n) || n < 1 || n ~= fix(n)
error('n needs to be a positive integer');
end

table = (1:n)' * (1:m);

if nargout == 2
summa = sum(table(:));
end
 Extra text that is not part of the code
 MATLAB disregards it
 Anything after a % is a comment until the end
of the line
 Purpose:
◦ Extra information for human reader
◦ Explain important or complicated parts of the program
◦ Provide documentation of your functions
 Comments right after the function declaration
are used by the built-in help function
function [table summa] = multable(n, m)

%MULTABLE multiplication table.

% T = MULTABLE(N) returns an N-by-N matrix
% containing the multiplication table for
% the integers 1 through N.
% MULTABLE(N,M) returns an N-by-M matrix.
% Both input arguments must be positive
% integers.
% [T SM] = MULTABLE(...) returns the matrix
% containing the multiplication table in T
% and the sum of all its elements in SM.

if nargin < 1
error('must have at least one input argument');
end
…
>> help multable
 Variables:
◦ Local
◦ Global
◦ Persistent
 Persistent variable:
◦ It’s a local variable, but its value persists from one
call of the function to the next.
◦ Relatively rarely used
◦ None of the bad side effects of global variables.
 Lesson 6: Loops

by

Akos Ledeczi and Mike Fitzpatrick

 The loop is a new control construct that makes it
possible to repeat a block of statements a
number of times.
 We have already used loops without knowing it:
>> n = 1:5;
>> total = sum(n);
 MATLAB uses loops internally both to compute
the result of the colon operator and to compute
the sum of the elements of the vector n above.
 Implicit loop
 Let’s compute the sum of 1 trough 5 without using
the built-in sum function!
 Use a loop:
Set total to 0

Repeat for n = 1 to 5

Add n to total

Print total
 Set total to 0
 Set n to 1
 Execute Add n to total (total equals 1)
Set total to 0
 Set n to 2
 Execute Add n to total (total equals 3)
 Set n to 3 Repeat for n = 1 to 5
 Execute Add n to total (total equals 6)
Add n to total
 Set n to 4
 Execute Add n to total (total equals 10)
 Set n to 5
Print total
 Execute Add n to total (total equals 15)
 Print total
 MATLAB implementation using a for-loop:

total = 0;
for n = 1:5
total = total + n;
end
fprintf('total equals %d\n',total);
 total = 0;
for n = 1:5 control statement
loop total = total + n; body
end
fprintf('total equals %d\n',total);
 Here is another example:
list = rand(1,5); % assigns a row vector of random numbers
for x = list
if x > 0.5
fprintf('Random number %f is large.\n',x)
else
fprintf('Random number %f is small.\n',x)
end
end

Random number 0.141890 is small.

Random number 0.421760 is small.
Random number 0.915740 is large.
Random number 0.792210 is large.
Random number 0.959490 is large.
 Notice that we do not need the list variable at all:

for x = rand(1,5)
if x > 0.5
fprintf('Random number %f is large.\n',x)
else
fprintf('Random number %f is small.\n',x)
end
end
 The values assigned to the loop index do not
have to be
◦ integers,
◦ regularly spaced, or
◦ assigned in increasing order,
 In fact, they do not have to be scalars either:
◦ The loop index will be assigned the columns of the array
 Any other control construct can be used in the
body of the for-loop
◦ if-statements
◦ other loops
◦ etc.
 for-loops work well when we know the
number of necessary iterations before
entering the loop
 Consider this problem:
◦ Starting from 1, how many consecutive positive
integers do we need to add together to exceed 50?
◦ The only way to solve this with a for-loop is to guess
a large enough number for the number of iterations
and then use a break statement.
◦ There is a better solution: a while-loop!
function [n total] = possum(limit)
total = 0;
n = 0;
while total <= limit
n = n + 1;
total = total + n;
end
fprintf('sum: %d count: %d\n', total, n);
function [n total] = possum(limit)
total = 0;
n = 0;
while total <= limit
n = n + 1;
total = total + n;
end
fprintf('sum: %d count: %d\n', total, n);

>> possum(50)
sum: 55 count: 10

ans =

10
 function [n total] = possum(limit)
total = 0;
n = 0;
while total <= limit control statement
n = n + 1;
loop body
total = total + n;
end
fprintf('sum: %d count: %d\n', total, n);
while conditional
block
end

if conditional
block
end

 Difference:
 while condition is evaluated repeatedly
 block is executed repeatedly as long as condition is true
 Problem: given a vector, v, of scalars, create a
second vector, w, that contains only the non-
negative elements of v
 Traditional solution:
w = [];
jj = 0;
for ii = 1:length(v)
if v(ii) >= 0
jj = jj + 1;
w(jj) = v(ii);
end
end
 MATLAB provides a more elegant solution:

w = [];
for ii = 1:length(v)
if v(ii) >= 0
w = [w v(ii)];
end
end
 The ultimate solution needs only a single line:

w = v(v >= 0);

 This is an example of logical indexing.

 To understand why and how this works, we
need to introduce logical arrays
Lesson 7: Data Types

by

Akos Ledeczi and Mike Fitzpatrick

 Real numbers in mathematics:
◦ Can be infinitely large
◦ Have infinitely fine resolution
 Computers: Finite memory
◦ Upper limit on the largest number that can be
represented
◦ Lower limit on the absolute value of any non-zero
number
 The set of values that can be represented by
a MATLAB variable is finite.
 MATLAB: many different data types
 A data type is defined by:
◦ Set of values
◦ Set of operations that can be performed on those values
 MATLAB:
◦ All elements of a given array must be of the same type
◦ Elementary type
 Type of a MATLAB array is defined by
◦ Number of dimensions
◦ Size in each dimension
◦ Elementary type
 double
◦ Default type in MATLAB
◦ Floating point representation
-2
 Example: 12.34 = 1234 * 10
 Mantissa and exponent
◦ 64 bits (8 bytes)
 single
◦ 32-bit floating point
 Integer types
◦ Signed, unsigned
◦ 8-, 16-, 32-, 64-bit long
Inf:
“Infinity”
NaN:
“Not-a-number”
 Type check:
◦ class
◦ isa
>> isa(x,’double’)
 Range check:
◦ intmax, intmin
◦ realmax, realmin
>> intmax(’uint32’)
 Conversion:
◦ Name of function = name of desired data type
◦ int8(x), uint32(x), double(x), etc.
 Arithmetic operators
◦ Operands of the same data type: No problem
◦ Different data types:
 “mixed-mode arithmetic”
 Many rules and restrictions
 Relational operators
◦ Different data types are always allowed
◦ Result is always of logical type
 Text: string
 We have used them already:
◦ Argument to fprintf and other functions
 String: vector of char-s
 Numerical type
◦ Uses an encoding scheme
◦ Each character is represented by a number
◦ ASCII scheme
 American Standard Code
for Information
Interchange
 Developed in the1960’s
 7 bits, 128 characters:
◦ Latin alphabet
◦ Digits
◦ Punctuation
◦ Special characters
 Newer schemes with far
more characters
 ASCII is a subset of them
 Print out the visible characters of the ASCII
table:

function char_codes
for ii = 33:126
fprintf('%s',char(ii));
end
fprintf('\n');
 An array must be homogeneous:
◦ It cannot contain elements of multiple types.
 A struct can be heterogeneous:
◦ It can contain multiple types.
 A struct is different from an array:
◦ fields, not elements
◦ field names, not indices
◦ Fields in the same struct can have different types.
 Versatility inside:
◦ A field of a struct can contain another struct.
>> r.ssn = 12345678
r =
ssn: 12345678
>> class(r)
ans =
struct
>> class(r.ssn)
ans =
double
>> r.name = 'Homer Simpson'
r =
ssn: 12345678
name: 'Homer Simpson‘
>> r.address.street = '742 Evergreen Terrace'
r =
ssn: 12345678
name: 'Homer Simpson'
address: [1x1 struct]
 An array must be homogeneous:
◦ It cannot contain elements of multiple types.
 A struct can be heterogeneous:
◦ It can contain multiple types.
 A struct is different from an array:
◦ fields, not elements
◦ field names, not indices
◦ Fields in the same struct can have different types.
 Versatility inside:
◦ A field of a struct can contain another struct.
◦ Structs can hold arrays, and arrays can hold structs.
 How to store a page of text?
◦ Each line should be a separate string
◦ Cannot use an array of chars:
 Each line would have to have the same length
◦ A vector of objects with each referring to one line
 Pointer
◦ Each variable (scalar, vector, array, etc.) is stored in
the computer memory.
◦ Each memory location has a unique address.
◦ A pointer is a variable that stores an address.
◦ MATLAB calls a pointer a “cell”.
 MATLAB has a restrictive pointer model
◦ Strict rules on what can be done with cells
◦ Harder to make mistakes
 But it is a powerful way to store
heterogeneous data
◦ Cell arrays
◦ Used more frequently than structs
 New syntax:
◦ To access the data a cell points to, use: { }
>> p = cell(2,3)
p =
[] [] [] p
[] [] []
>>

[]
>> p = cell(2,3)
p =
[] [] [] p
[] [] []
>> p{2,1} = pi
p =
[] [] []
[3.14] [] []
>> 3.14

[]
>> p = cell(2,3)
p =
[] [] [] p
[] [] []
>> p{2,1} = pi -17
p =
[] [] []
[3.14] [] []
>> p{1,1} = int8(-17) 3.14
p =
[-17] [] []
[]
[3.14] [] []
>>
>> p = cell(2,3)
p =
[] [] [] p
[] [] []
>> p{2,1} = pi -17
p =
[] [] []
[3.14] [] []
>> p{1,1} = -17 3.14
p =
[-17] [] []
[]
[3.14] [] []
>> p{2,2} = 'Awesome'
P =
[-17] [] []
[3.14] 'Awesome'[] ‘A’ ‘w’ ‘e’ ‘s’ ‘o’ ‘m’ ‘e’
>> p{2,3} = [2 4; 6 8; 10 12]
P =
[-17] [] []
[3.14] ‘Awesome’[3x2 double] p
>> -17

2 4

3.14
6 8

[] 10 12

‘A’ ‘w’ ‘e’ ‘s’ ‘o’ ‘m’ ‘e’

>> p{2,3} = [2 4; 6 8; 10 12]
P =
[-17] [] []
[3.14] ‘Awesome’[3x2 double] p
18 24

>> p{1,3} = sum(p{2,3}); -17

>>
2 4

3.14
6 8

[] 10 12

‘A’ ‘w’ ‘e’ ‘s’ ‘o’ ‘m’ ‘e’

>> p{2,3} = [2 4; 6 8; 10 12]
P = Inf
[-17] [] []
[3.14] ‘Awesome’[3x2 double] p
18 24

>> p{1,3} = sum(p{2,3}); -17

>> P{1,2} = 1/0;
>> 2 4

3.14
6 8

[] 10 12

‘A’ ‘w’ ‘e’ ‘s’ ‘o’ ‘m’ ‘e’

>> p{2,3} = [2 4; 6 8; 10 12]
P = Inf
[-17] [] []
[3.14] ‘Awesome’[3x2 double] p
18 24

>> p{1,3} = sum(p{2,3}); -17

>> P{1,2} = 1/0;
>> class(p) 2 4
ans =
cell 3.14
>> 6 8

[] 10 12

‘A’ ‘w’ ‘e’ ‘s’ ‘o’ ‘m’ ‘e’

>> p{2,3} = [2 4; 6 8; 10 12]
P = Inf
[-17] [] []
[3.14] ‘Awesome’[3x2 double] p
18 24

>> p{1,3} = sum(p{2,3}); -17

>> P{1,2} = 1/0;
>> class(p) 2 4
ans =
cell 3.14
>> class(p{1,2}) 6 8
ans =
double [] 10 12
>>

‘A’ ‘w’ ‘e’ ‘s’ ‘o’ ‘m’ ‘e’

>> p{2,3} = [2 4; 6 8; 10 12]
P = Inf
[-17] [] []
[3.14] ‘Awesome’[3x2 double] p
18 24

>> p{1,3} = sum(p{2,3}); -17

>> P{1,2} = 1/0;
>> class(p) 2 4
ans =
cell 3.14
>> class(p{1,2}) 6 8
ans =
double [] 10 12
>> class(p(1,2))
ans =
cell
>>
‘A’ ‘w’ ‘e’ ‘s’ ‘o’ ‘m’ ‘e’
>> p{2,3}(3,2)
ans = Inf

>>
12
p
18 24

-17

2 4

3.14
6 8

[] 10 12

‘A’ ‘w’ ‘e’ ‘s’ ‘o’ ‘m’ ‘e’

Lesson 8: File Input/Output

by

Akos Ledeczi and Mike Fitzpatrick

 File:
◦ Area in permanent storage (disk drive)
◦ Stores information
◦ Managed by the operating system
◦ Can be copied or moved
◦ Can be accessed by programs
 File Input/Output (I/O)
◦ Data exchange between programs and computers
◦ Data exchange between the physical world and computers
◦ Saving your work so you can continue with it later
 MATLAB can handle
◦ Mat-files and M-files AND text, binary, and Excel files
 Microsoft Excel® is a widely used data-analysis tool
 Many other programs support reading and writing
Excel files
 MATLAB does too with two built-in functions
◦ xlsread
◦ xlswrite
>> [num,txt,raw] = xlsread('Nashville_climate.xlsx');
>> num
num =
46 28 3.98
51 31 3.7
61 39 4.88
70 47 3.94
78 57 5.08
85 65 4.09
NaN NaN NaN
NaN NaN NaN
89 69 3.78
88 68 3.27
82 61 3.58
71 49 2.87
59 40 4.45
49 31 4.53
>> num
num =
46 28 3.98
51 31 3.7
61 39 4.88
70 47 3.94
78 57 5.08
85 65 4.09
NaN NaN NaN
NaN NaN NaN
89 69 3.78
88 68 3.27
14
82 61 3.58
71 49 2.87
59 40 4.45
49 31 4.53 3
>> num
num =
46 28 3.98
51 31 3.7
61 39 4.88
70 47 3.94
78 57 5.08
85 65 4.09
NaN NaN NaN
NaN NaN NaN
89 69 3.78
88 68 3.27
14
82 61 3.58
71 49 2.87
59 40 4.45
49 31 4.53 3
>> txt =
txt =
[1x30 char] '' '' '' ''
[1x40 char] '' '' '' ''
'' '' '' '' ''
'' '' 'High temp (F)' 'Low temp (F)' 'Precip (in)'
'' 'Jan' '' '' ''
'' 'Feb' '' '' ''
'' 'March' '' '' ''
'' 'April' '' '' ''
'' 'May' '' '' ''
'' 'June' '' '' ''
'' '' '' '' ''
'' '' 'High temp (F)' 'Low temp (F)' 'Precip (in)'
'' 'July‘ '' '' ''
'' 'Aug' '' '' ''
'' 'Sep' '' '' ''
'' 'Oct' '' '' ''
'' 'Nov' '' '' ''
'' 'Dec' '' '' ''
>> raw
raw =
[1x30 char] [ NaN] [ NaN] [ NaN] [ NaN]
[1x40 char] [ NaN] [ NaN] [ NaN] [ NaN]
[ NaN] [ NaN] [ NaN] [ NaN] [ NaN]
[ NaN] [ NaN] 'High temp (F)' 'Low temp (F)' 'Precip (in)'
[ NaN] 'Jan' [ 46] [ 28] [ 3.98]
[ NaN] 'Feb' [ 51] [ 31] [ 3.7]
[ NaN] 'March' [ 61] [ 39] [ 4.88]
[ NaN] 'April' [ 70] [ 47] [ 3.94]
[ NaN] 'May' [ 78] [ 57] [ 5.08]
[ NaN] 'June‘ [ 85] [ 65] [ 4.09]
[ NaN] [ NaN] [ NaN] [ NaN] [ NaN]
[ NaN] [ NaN] 'High temp (F)' 'Low temp (F)' 'Precip (in)'
[ NaN] 'July‘ [ 89] [ 69] [ 3.78]
[ NaN] 'Aug' [ 88] [ 68] [ 3.27]
[ NaN] 'Sep' [ 82] [ 61] [ 3.58]
[ NaN] 'Oct' [ 71] [ 49] [ 2.87]
[ NaN] 'Nov' [ 59] [ 40] [ 4.45]
[ NaN] 'Dec' [ 49] [ 31] [ 4.53]
 Text files contain characters
 They use an encoding scheme:
◦ ASCII or
◦ Any one of many other schemes
◦ MATLAB takes care of encoding and decoding
 Before using a text file, we need to open it
 Once done with the file, we need to close it
 Opening: fid = fopen(filename, permission)
 Closing: fclose(fid)
 fid: Unique file identifier for accessing file
 Permission: what we want to do with the file—
◦ read, write, overwrite, append, etc.
 One line at a time
 type prints a text file in the command window
 Let’s re-implement it:
function view_text_file(filename)
fid = fopen(filename,'rt');
if fid < 0
error('error opening file %s\n\n', filename);
end

% Read file as a set of strings, one string per line:

oneline = fgets(fid);
while ischar(oneline)
fprintf('%s',oneline) % display one line
oneline = fgets(fid);
end
fprintf('\n');
fclose(fid);
 Reading lines into string variables is easy
 Parsing these strings to get numerical data is
much harder
 Not covered
 Binary files are more suited for numerical data
 Binary file = “not a text file”
 Many different ways to represent numbers
 All we need to know are their types.
 Binary files need to be
◦ Opened with fopen
◦ Closed with fclose
 Data type is important
 Example: write a double array into a binary file

function write_array_bin(A,filename)
fid = fopen(filename,'w+');
if fid < 0
error('error opening file %s\n‘, filename);
end

fwrite(fid,A,'double');

fclose(fid);
 Example: read a double array from a binary file

function A = read_bin_file(filename,data_type)
fid = fopen(filename,'r');
if fid < 0
error('error opening file %s\n',filename);
end

A = fread(fid,inf,data_type);

fclose(fid);