Chapter 3

Program Development

Programs are written to solve problems or perform tasks on a computer.

Programmers translate the solutions or tasks into a language the computer
can understand. As one writes programs, he/she must keep in mind that the
computer will only do what it is instructed to do. Junk in, junk out. Because
of this, the programmer must develop good problem-solving strategies.

One very big advantage of Matlab over other programming language is the
possibility of designing your own toolbox to be added to existing ones like
SIMULINK, the Symbolics toolbox, and the Controls toolbox. Matlab is a useful
environment to develop software tools to solve relatively complicated
mathematical problems.

In order for a program to be written to solve a particular problem, the

programmer should

1. Perfectly and thoroughly understand the problem to be solved

2. Develop or chose a solution method
3. Describe the logical solution method chosen, step-by-step.
4. Build and test an algorithm. An algorithm is the laid out procedure to
solve the problem. It eases the writing out of a program in a
programming language. Testing is popularly called debugging.
5. Validate the algorithm. This means checking if the procedure actually
solves the problem.

3.1 Matlab Program Design

The logical steps (blocks or modules) that are finally transcribed into the
MATLAB codes and saved as M-files in your work directory are the primary
and most useful goals of users of tools like MATLAB. More so, there are
numerous toolboxes available that can be purchased from MathWorks
(www.mathworks.com) or other sources to use with Matlab to solve a variety
of engineering and scientific problems.

A working directory mytools can be created and accessed by executing the

following commands:

>> mkdir mytools <Enter>

>> cd mytools <Enter>

The important goals of software tools design are that it works, and can easily
be read and understood. That way, it can be systematically modified when
required. For programs to work well they must satisfy the requirements
associated with the problem or class of problems it is intended to solve. The
detailed description of the problem to be solved, inputs, method of
1
processing, outputs and any other special requirements, must be known by
the designer. The program must work completely and correctly, i.e. all
options should be usable without error within the limitations of the
specifications. It must be readable and, hence, clearly understandable. Thus,
it is useful to decompose major tasks (or the main program) into subtasks (or
subprograms) that do specific parts of the main task. It is much easier to
read subprograms that have fewer lines, than one large main program that
doesnt segregate the subtasks effectively, particularly if the problem to be
solved is relatively complicated. Each subtask should be designed so that it
can be evaluated independently before it is incorporated into the larger main
program. A well-written code, when it works, is much more easily evaluated
in the testing phase of the design process. If changes are necessary to
correct sign mistakes and the like, they can be implemented easily. One
thing to keep in mind is adding information about the program. This is done
by comments. Ensure to add enough comments and references so that a
year the program is written, you will know exactly what was done and for
what purpose. Also note that the first few comment lines in a script are
displayed in the command window when you type help followed by the name
of your file, thus naming your files well, is also an art.

The procedures described above can be summarized in steps. Many

programmers plan their programs using these sequence of steps, referred to
as the program development cycle. This will enable you to use your time
efficiently to design error-free programs that produce the desired output.
Note that these steps are loosely defined. That is, for some situations, a
number of steps can be merged.

Step 1: Problem analysis: Problem must be well defined. Be sure you

understand what the program should do, that is, what the output should be. Have a
clear idea of what data (or input) are given and the relationship between the input
and the desired output.
Step 2: Problem statement: Develop a detailed statement of the
mathematical problem to be solved with a computer program.
Step 3: Processing scheme. Define the inputs required and the outputs to
be produced by the program.
Step 4: Algorithm/Design phase: Design the step-by-step procedure
using the top-down design process that decomposes the overall problem into
subordinate problems. The subtasks to solve the latter are refined by
designing an itemized list of steps to be programmed. This list of tasks is the
structure plan written using special tools like a flowchart, a pseudocode or a
hierarchical chart. The goal is to design a plan that is understandable and
easily translated into a computer language.
Step 5: Program algorithm/Coding: Translate or convert the algorithm
into a computer language (e.g. MATLAB) and debug the syntax errors until
the tool executes successfully.
Step 6: Evaluation: Test all of the options and conduct a validation study of
the computer program, e.g. compare results with other programs that do
similar tasks, compare with experimental data if appropriate, and compare
with theoretical predictions based on theoretical methodology related to the
2
problems to be solved by the computer program. The objective is to
determine that the subtasks and the overall program are correct and
accurate. The additional debugging in this step is to find and correct logical
errors, and run-time errors that may occur after the program successfully
Step 7: Application: Solve the problems the program was designed to
solve. If the program is well designed and useful it could be saved in your
work directory (i.e. in your user-developed toolbox) for future use.
Step 8: Complete the documentation: Organize all the material that
describes the program. Documentation is intended to allow another person,
or the yourself at a later date, to understand the program. Internal
documentation consists of statements in the program that are not executed,
but point out the purposes of various parts of the program. Documentation
might also consist of a detailed description of what the program does and
how to use the program (for instance, what type of input is expected). For
commercial programs, documentation includes an instruction manual. Other
types of documentation are the flowchart, pseudocode, and top-down chart
that were used to construct the program.

Although documentation is listed as the last step in the program

development cycle, it should take place as the program is being coded.

3.1.1 Projectile Motion Example

Step 1: Consider a projectile motion encountered in physics. In this example

we want to calculate the fight of a projectile (a golf ball for example)
launched at a prescribed speed and launch angle. We want to determine the
trajectory of the flight path and the horizontal distance the projectile travels
before it hits the ground. We assume zero air resistance and a constant
gravitational force. The launch angle, o, is defined as the angle measured
from the horizontal upward towards the vertical direction, i.e. 0 <</2. If g
=9.81 m/s2 is used as the acceleration of gravity, then the launch speed, V ,
must be entered in units of m/s. The time, t >0, is the time in seconds (s)
from the launch time of t =0, the distance traveled x (the horizontal
direction) and y (the vertical direction) are in meters (m). We want to
determine the time it takes from the commencement of motion to when it
hits the ground, the horizontal distance traveled and the shape of the
trajectory. In addition, we plot the speed of the projectile versus the direction
of this vector. We need, of course, the theory (or a mathematical expression)
that describes the solution to this problem in order to develop an algorithm
to obtain solutions to this zero-resistance projectile problem.

Step 2: The mathematical formulae that describe the solution to the

projectile problem described in Step 1 are provided in this step. Given the
launch angle and launch speed, the horizontal distance traveled from x =y
=0, which is the coordinate location of the launcher, is

3
The time txmax from launch for the projectile to reach xmax is given by

The maximum altitude the object can reach is

at

For this problem the horizontal distance traveled when the object reaches
the maximum altitude is xymax=xmax/2.

The trajectory (or flight path) is described by the following pair of coordinates
at any given instant of time is given by

We need to solve these equations over the range of time 0 <t <=tmax for
prescribed launch conditions V>0 and 0 <<=/2. Then the maximum value
of the altitude and the range are computed along with their respective
arrival times. Finally, we want to plot V versus , where

Step 3: The required inputs are g, Vo, , and a finite number of time steps
between t =0 and the time the object returns to the ground. The outputs are
the range and time of flight, the maximum altitude and the time it is
reached, and the shape of the trajectory in graphical form.

Steps 4&5: The structural plan developed to solve this problem is given as a
MATLAB program. This is because it is a realitively straightforward problem
and the translation to MATLAB codes is easily. The steps of the structure plan

4
are enumerated. This plan and the M-file, of course, is the final result
developed after trying a number of approaches during the design phase.

The M-file is as below

%
% The proctile problem with zero air resistance
% in a gravitational field with constant g.
%
% Written by D. T. Valentine ........ september 2006
% An eight-step structure plan applied in MATLAB:
%
% 1. Definition of the input variables.
%
g = 9.81; % Gravity in m/s/s.
vo = input(What is the launch speed in m/s?)
tho = input(What is the launch angle in degrees?)
tho = pi*tho/180; % Conversion of degrees to radians.
%
% 2. Calculate the range and duration of the flight.
%
txmax = (2*vo/g) * sin(tho);
xmax = txmax * vo * cos(tho);
%
% 3. Calculate the sequence of time steps to compute trajectory.
%
dt = txmax/100;
t = 0:dt:txmax;
%
% 4. Compute the trajectory.
%
x = (vo * cos(tho)) .* t;
y = (vo * sin(tho)) .* t - (g/2) .* t.2;
%
% 5. Compute the speed and angular direction of the
projectile.
% Note that vx = dx/dt, vy = dy/dt.
%
vx = vo * cos(tho);
vy = vo * sin(tho)-g.*t;
v = sqrt(vx.*vx + vy.*vy);
th = (180/pi) .* atan2(vy,vx);
%
% 6. Compute the time, horizontal distance at maximum altitude.
%
tymax = (vo/g) * sin(tho);
xymax = xmax/2;
ymax = (vo/2) * tymax * sin(tho);
%
5
% 7. Display ouput.
%
disp([Range in m = ,num2str(xmax), Duration ins=,
num2str(txmax)])
disp( )
disp([Maximum altitude in m = ,num2str(ymax), Arrival
ins=,num2str(tymax)])
plot(x,y,k,xmax,y(size(t)),o,xmax/2,ymax,o)
title([Projectile flight path, vo =,num2str(vo),
th =, num2str(180*th/pi)])
xlabel(x), ylabel(y) % Plot of Figure 1.
figure % Creates a new figure.
plot(v,th,r)
title(Projectile speed vs. angle)
xlabel(V), ylabel(\theta) % Plot of Figure 2.
%
% 8. Stop.
%

Steps 6&7: The program was evaluated by executing a number of values of

the launch angle and launch speed within the required specifications. The
angle of 45 degrees was checked to determine that the maximum range
occurred at this angle for all specified launch speeds. This is well known for
the zero air resistance case in a constant g force field. Executing this
computer code for Vo =10 m/s and =45 degrees, the trajectory and the plot
of orientation versus speed in Figures 3.1 and 3.2, respectively, were
produced.

6
The example just seen is a Matlab program which receives input data from a
user, performs simple arithmetic operations on the data, and displays the
results of the computation in a comprehensible form. However, more
interesting problems in science and engineering are likely to involve special
mathematical functions like sines, cosines, logarithms, etc. These will be
seen later

Engineers often say to themselves that we dont have to reinvent the

wheel. There are lots and lots of Matlab codes available in the Internet that
has been written to solve diversed Engineering problems. Like with
everything on the Internet, the correctness of these codes and their
relevance to the problems to be solved rest with the writers of such.
Nevertheless, the Internet is a good place to start when looking for solutions
to an Engineering problem. It is the responsibility of the Engineer to validate
such solutions and customize them to his/her particular situation.

7
 Chapter 4

Functions

Functions are said to return with calculated values or perform some

operation on data, e.g. plot, sines, cosines, logarithms, etc. MATLAB comes
with a large collection of such functions. A short list of some of the more
common ones is presented here. Use helpwin at the command line to see a
list of categories of functions, with links to descriptions of the functions.
Alternatively, go to the Contents listing in the Help Navigator (the left pane in
the Help browser), and expand successively MATLAB, Reference, MATLAB
Function Reference where you can choose either Functions by
Category, or Alphabetical List of Functions.

4.1 Common Functions

If the argument of a function is an array, the function is applied element by

element to all the values in the array, e.g.

>> Sqrt ([1 2 3 4])

ans =

1.0000 1.4142 1.7321 2.0000

abs(x): absolute value of x.

acos(x): arc cosine (inverse cosine)
acosh(x): inverse hyperbolic cosine of x
asin(x): arc sine (inverse sine) of x
asinh(x): inverse hyperbolic sine of x
atan(x): arc tangent of x
atan2(y, x): arc tangent of y/x
atanh(x): inverse hyperbolic tangent of x
. ceil(x): smallest integer which exceeds x
8
Clock: time and date in a six-element vector
cos(x): cosine of x.
cosh(x): hyperbolic cosine of x
cot(x): cotangent of x.
csc(x): cosecant of x.
cumsum(x): cumulative sum of the elements of x

>> cumsum(1:4)
ans=
[1 3 6 10].

date: date in a string in dd-mmm-yyyy format

exp(x): value of the exponential function ex
fix(x): rounds to the nearest integer towards zero
floor(x): largest integer not exceeding x
length(x): number of elements of vector x.
log(x): natural logarithm of x.
log10(x): base 10 logarithm of x.
max(x): maximum element of vector x.
mean(x): mean value of elements of vector x.
min(x): minimum element of vector x.
pow2(x): 2x
prod(x): product of the elements of x.
rand: pseudo-random number in the interval [0, 1).
Realmax: largest positive floating point number on your computer.
Realmin: smallest positive floating point number on your computer.
rem(x, y): remainder when x is divided by y,

9
Considering examples with the arc-cosine, the arc-sine and the arctangent
functions, i.e. acos(x), asin(x) and atan(x), respectively. If we specify x
between -1 and 1, what quadrant of the circle are the output angles
selected? The following M-file is proposed.

%
% Script to compare the acos(x), asin(x), and atan(x)
% functions over the range -1<x<1.Thevalues are
% converted to angles in degrees. The results are
% compared graphically.
% Script prepared by D. T. Valentine - September 2006.
% The question raised is: What range of angles, i.e.
% which of the four quadrants of the circle from 0 to
% 2*pi are the angular outputs of each of the functions?
%
% Determine the values of x to be examined:
%
x = -1:0.001:1;
% Compute the arc-functions:
%
y1 = acos(x);
y2 = asin(x);
y3 = atan(x);
%
% Convert the angles from radians to degrees:
%
y1 = 180*y1/pi;
y2 = 180*y2/pi;
y3 = 180*y3/pi;
%
% Plot the results:
%
plot(y1,x,y2,x,y3,x),grid,legend(asin(x), acos(x),
atan(x))
xlabel(\theta in degrees),ylabel(x, the argument of
the function)
% REMARKS: Note the following:
% (1) The acos(x) varies from 0 to 90 to 180 degrees.
% (2) The asin(x) varies from -90 to 0 to 90 degrees.
% (3) The atan(x) varies from -45 to 0 to 45 degrees.
%
% Stop

10
4.2 Importing and Exporting Data

In programming there is often need to store data on a disk. The process of

moving data between MATLAB and disk files is called importing (from disk
files) and exporting (to disk files). Data are saved in disk files in one of two
formats: text or binary. In text format, data values are ASCII codes, and can
be viewed in any text editor. In binary format, data values are not ASCII
codes and cannot be viewed in a text editor. Binary format is more efficient
in terms of storage space required. There are many different ways to export
and import data from matlab. You can import and export data from and to
matlab binary formats (MAT files), text files, Excel spreadsheet (works only
on Windows), XML, several special purpose formats, and a lot of image,
audio, and video file formats.

Text formats are very useful, because they very portable and can be read
and written by many different applications. They will be introduces here.

4.2.1 The load and save commands

The save and load commands are probably the best commands to use in
saving data between MATLAB sessions.

4.2.2 Exporting text (ASCII) data

To export (save) the array

A=
1 2 3
4 5 6

in delimited ASCII format in the file myData.txt (creating it) use the
command
11
 >> save ascii myData.txt A

If you view myData.txt in a text editor (or type it in the Command Window) it
looks like this:

1.0000000e+000 2.0000000e+000 3.0000000e+000

4.0000000e+000 5.0000000e+000 6.0000000e+000

Delimiters are the characters used to separate the data values in the file .i.e.
spaces by default. You can use tabs instead of spaces by specifying the tabs
qualifier instead of -ascii. If you save character arrays (strings) in this way,
the ASCII codes of the characters are written to the file.

B=
4 5 6
7 8 9
>> save -tabs mytext.txt B

Viewing mytext.txt will look like

__________IM____,___xc``_b6
3_13_3___R____
(Quite incomprehensible huh!)

4.2.3 Importing text (ASCII) data

The load command is the reverse of save, but has a curious twist in the
syntax. If the array A has been saved in myData.txt as in the above
command, then

load myData.txt

creates a variable in the workspace with the same name as the file, minus
the extension, i.e. myData. If you dont want the filename as the variable
name use the functional form of the command, e.g.

>> A = load(myData.txt)

A=
1 2 3
4 5 6

Data imported in this way doesnt have to be created by MATLAB. You can
create it in a text editor, or it could be created by any other program that
exports data in ASCII format.

4.2.4 Exporting binary data

12
The command

save x y z

saves the variables x, y and z in the file filename.mat in MATLAB proprietary

binary format, i.e. such a MAT-file can only be used by MATLAB.

>> ekepata = [3 2 1;4 8 7];

>> save ekepata

ekepata will be seen in a Matlab folder as a matlab file with extension .mat

Note:
If no variables are listed the entire workspace is saved.
The extension .mat is the default extension but you can specify a
different extension.

4.2.5 Importing binary data

The command

load filename

loads all the variables from filename.mat into the workspace.

>> load ekepata

4.2.6 The Import Wizard

The MATLAB Import Wizard is the easiest way of importing data into the
workspace during an interactive session.

Importing ASCII data

Use the Import Wizard to import ASCII data as follows:

Start the Import Wizard by selecting Import Data on the MATLAB File
menu. You can also use uiimport on the command line to start it. A list
of files appears in a dialogue box. Open the file you want to import.
Select the delimiter used in the text file (if necessary). Click Next.
Select the variables you want to import. By default the Import Wizard
puts all the numeric data in one variable and all the text data in other
variables, but you can choose other options.
Click Finish to import the data into the selected variables.

Importing binary data

13
To import binary data with the Import Wizard, start it in the same way as
when importing text data. When the file opens the Import Wizard attempts to
process its contents and creates variables depending on the type of data in
the file. Check the variables you want to import and click Finish to create the
selected variables. You can, for example, import data from an Excel
spreadsheet in this way. If the data are numeric with row and column
headers, the Import Wizard imports the numeric data into a numeric array
and the headers into a cell array.

4.2.7 Low-level le I/O functions

MATLAB has a set of low-level file I/O (input/output) functions based on the
I/O functions of the ANSI Standard C Library. Low-level file I/O functions allow
the most direct control over reading or writing data to a file. However, these
functions require that you specify more detailed information about your file.
You would typically use these functions to access binary data written by C or
Java programs, for example, or to access a database which is too large to be
loaded into the workspace in its entirety.

Files can be accessed with these functions in text or binary mode. In binary
mode you can think of the file as a long continuous stream of bytes, which
are your responsibility to interpret correctly. Files opened in binary mode can
be accessed randomly, i.e. you can specify at which particular byte you
want to start reading or writing.

fscanf: reads formatted data in a text or ASCII file; that is, a file you can view
in a text editor.
fgetl and fgets: reads one line of a file at a time, where a newline character
separates each line.
fread : reads a stream of data at the byte or bit level
fopen: opens a file
fclose:closes a file

Other import/export functions, with differing degrees of flexibility and ease of

use, include csvread, csvwrite, dlmread, dlmwrite, fgets, fprintf (which has
an optional argument to specify a file), fscanf, textread, xlsread. You know
where to look for the details!

Finally, the diary command can also be used to export small arrays as text
data, although you will need to edit out extraneous text.

14