Chapter 6: MATLAB Programs
Exercises
1) Write a function that will receive as an input argument a temperature in degrees
Fahrenheit, and will return the temperature in both degrees Celsius and Kelvin. The
conversion factors are: C = (F – 32) * 5/9 and K = C + 273.15.
conv_f_to_kc.m
function [ctemp ktemp] = conv_f_to_kc(ftemp)
% Converts a temperature in degrees F to
% both degrees C and K
% Format of call: conv_f_to_kc(Fahrenheit temp)
% Returns degrees C then degrees K
ctemp = (ftemp - 32) * 5/9;
ktemp = ctemp + 273.15;
end
2) Write a function that will receive as an input argument a number of kilometers
(K). The function will convert the kilometers to miles and to U.S. nautical miles, and
return both results. The conversions are: 1K = 0.621 miles and 1 US nautical mile =
1.852 K.
kToMilesNaut.m
function [miles nautmiles] = kToMilesNaut(kms)
% Converts a distance in kilometers to miles and U.S. nautical miles
% Format kToMilesNaut(kilometers)
% Returns miles and then nautical miles
miles = kms .* 0.621;
nautmiles = kms ./ 1.852;
end
3) A vector can be represented by its rectangular coordinates x and y or by its polar
coordinates r and θ. For positive values of x and y, the conversions from rectangular
to polar coordinates in the range from 0 to 2 are r = x 2 y 2 and θ =
arctan(y/x). The function for arctan is atan. Write a function recpol to receive as
input arguments the rectangular coordinates and return the corresponding polar
coordinates.
recpol.m
function [r theta] = recpol(x,y)
% Converts vector coordinates from
% rectangular coordinates x and y to polar
% Format of call: recpol(x,y)
% Returns polar coordinates r then theta
r = sqrt(x^2 + y^2);
theta = atan(y/x);
end
4) A vector can be represented by its rectangular coordinates x and y or by its polar
coordinates r and θ. For positive values of x and y, the conversions from rectangular
to polar coordinates in the range from 0 to 2 are r = x 2 y 2 and θ =
arctan(y/x). Write a function to receive as input arguments the rectangular
coordinates and return the corresponding polar coordinates.
Just kidding!
Instead, convert from polar to rectangular; the conversions from polar to
rectangular are x = r cos(θ) and y = r sin(θ).
polar_to_rect.m
function [x y] = polar_to_rect(r, theta)
% Converts from polar to rectangular coordinates
% Format of call: polar_to_rect(r, theta)
% Returns x then y
x = r*cos(theta);
y = r*sin(theta);
end
5) Write a function to calculate the volume and surface area of a hollow cylinder. It
receives as input arguments the radius of the cylinder base and the height of the
cylinder. The volume is given by r2 h, and the surface area is 2 r h.
vol_surfarea.m
function [vol surfarea] = vol_surfarea(rad, ht)
% Calculates the volume and surface area of a
% hollow cylinder, given the radius and height
% Format of call: vol_surfarea(radius, height)
% Returns volume then surface area
vol = pi * rad^2 * ht;
surfarea = 2 * pi * rad * ht;
end
6) Write a function that will receive the radius of a circle and will print both the
radius and diameter of the circle in a sentence format. This function will not return
any value; it simply prints.
printCircleInfo.m
function printCircleInfo(rad)
% Prints the radius and diameter of a circle
% Format: printCircleInfo(radius)
% Does not return any values
fprintf('A circle with a radius of %.2f\n', rad)
fprintf(' has a diameter of %.2f\n', rad*2)
end
7) Write a function that will receive as an input argument a length in inches, and will
print in a sentence format the length in both inches and centimeters (1 inch = 2.54
cm). Note that this function will not return any value.
printLengths.m
function printLengths(inch)
% Receives a length in inches and prints
% the length in inches and centimeters
% Format of call: printLengths(lenght in inches)
% Does not return any values
fprintf('A length of %.1f inches is\n', inch)
fprintf(' equivalent to %.1f cm.\n', inch*2.54)
end
8) Write a function that will receive an integer n and a character as input arguments,
and will print the character n times.
printNChars.m
function printNChars(n, ch)
% Receives n and a character and prints
% the character n times
% Format of call: printNChars(n, character)
% Does not return any values
for i = 1:n
fprintf('%c', ch)
end
fprintf('\n')
end
9) Convert the printstars script from Chapter 4 to a function that receives as inputs
the number of rows and columns, and prints a box of asterisks with the specified
number of rows and columns.
printStarsFn.m
function printStarsFn(rows, columns)
% Prints a box of stars
% size to print specified by 2 input arguments
% Format of cal: printStarsFn(# rows, # columns)
% Does not return any values
% loop over the rows
for i=1:rows
% for every row loop to print *'s and then one \n
for j=1:columns
fprintf('*')
end
fprintf('\n')
end
end
10) Convert the multtable function from Chapter 4 to a function that receives as
input arguments the number of rows and columns and prints a multiplication table
(rather than returning the matrix).
prtMulttable.m
function prtMulttable(rows, columns)
% Prints a multiplication table with rows
% from 1 to r and columns from 1 to c
% Format of call: prtMulttable(r,c)
% Does not return any values
for i = 1:rows
for j = 1:columns
fprintf('%4d', i * j);
end
fprintf('\n')
end
end
11) Write a function that will receive a matrix as an input argument, and prints it in
a table format.
printMat.m
function printMat(mat)
% Prints a matrix in a table format
% Assumes a fairly small matrix of ints
% Format of call: printMat(matrix)
% Does not return any values
[r c] = size(mat);
for i = 1:r
for j = 1:c
fprintf('%6d', mat(i,j))
end
fprintf('\n')
end
end
12) Write a function that receives a matrix as an input argument, and prints a
random row from the matrix.
printRanRow.m
function printRanRow(mat)
% Prints a random row from a matrix
% Assumes a fairly small matrix of ints
% Format of call: printRanRow(matrix)
% Does not return any values
[r c] = size(mat);
ranrow = randi([1,r]);
fprintf('%d ', mat(ranrow,:))
fprintf('\n')
end
13) Write a function that receives a count as an input argument, and prints the value
of the count in a sentence that would read “It happened 1 time.” if the value of the
count is 1, or “It happened xx times.” if the value of count (xx) is greater than 1.
printCount.m
function printCount(count)
% Prints a count in a correct sentence
% with an 's' for plural or not
% Format of call: printCount(count)
% Does not return any value
fprintf('It happened %d time', count)
if count > 1
fprintf('s')
end
fprintf('.\n')
end
14) Write a function that will print an explanation of temperature conversions. The
function does not receive any input arguments; it simply prints.
printTempConvInfo.m
function printTempConvInfo
% Prints some info on temperature conversions
% Format of call: printTempConvInfo
% or printTempConvInfo()
% Does not return any values
fprintf('There are different temperature scales.\n')
fprintf('Given a temperature in one system, it is\n')
fprintf(' easy to convert to another.\n')
fprintf('For example, given a temperature in Fahrenheit,\n ')
fprintf('the conversion to Celsius is C = (F - 32)*5/9\n')
fprintf(' and to Kelvin is K = C + 273.15\n')
end
15) Write a function that receives an x vector, a minimum value, and a maximum
value, and plots sin(x) from the specified minimum to the specified maximum.
plotXMinMax.m
function plotXMinMax(x, xmin, xmax)
% Plots sin(x) from the minimum value of x
% specified to the maximum
% Format of call: plotXMinMax(x, x minimum, x maximum)
% Does not return any values
x = linspace(xmin,xmax);
plot(x,sin(x),'*')
xlabel('x')
ylabel('sin(x)')
end
16) Write a function that prompts the user for a value of an integer n, and returns
the value of n. No input arguments are passed to this function.
promptForN.m
function outn = promptForN
% This function prompts the user for n
% It error-checks to make sure n is an integer
% Format of call: promptForN or promptForN()
% Returns an integer entered by the user
inputnum = input('Enter an integer for n: ');
num2 = int32(inputnum);
while num2 ~= inputnum
inputnum = input('Invalid! Enter an integer: ');
num2 = int32(inputnum);
end
outn = inputnum;
end
17) Write a function that prompts the user for a value of an integer n, and returns a
vector of values from 1 to n. The function should error‐check to make sure that the
user enters an integer. No input arguments are passed to this function.
promptNVec.m
function outvec = promptNVec
% This function prompts the user for n
% It error-checks to make sure n is a positive integer
% It returns a vector from 1 to n
% Format of call: promptNVec or promptNVec()
% Returns a vector 1:n
inputnum = input('Enter a positive integer for n: ');
num2 = int32(inputnum);
while num2 ~= inputnum || num2 < 0
inputnum = input('Invalid! Enter a positive integer: ');
num2 = int32(inputnum);
end
outvec = 1:inputnum;
end
18) Write a script that will:
Call a function to prompt the user for an angle in degrees
Call a function to calculate and return the angle in radians . (Note: radians =
180)
Call a function to print the result
Write all of the functions, also. Note that the solution to this problem involves four
M‐files: one which acts as a main program (the script), and three for the functions.
Ch6Ex18.m
% Script calls functions to:
% prompt for an angle in degrees
% convert to radians
% print both
deg = promptAng;
rad = degRad(deg);
prtDegRad(deg,rad)
promptAng.m
function deg = promptAng
% Prompts for an angle in degrees
% Format of call: promptAng or promptAng()
% Returns an angle in degrees
deg = input('Enter an angle in degrees: ');
end
degRad.m
function rad = degRad(deg)
% Converts an angle from degrees to radians
% Format of call degRad(degrees)
% Returns the angle in radians
rad = deg * pi / 180;
end
prtDegRad.m
function prtDegRad(deg, rad)
% Prints an angle in degrees and radians
% Format of call: prtDegRad(degrees, radians)
% Does not return any values
fprintf('The angle %.1f degrees is \n', deg)
fprintf('equivalent to %.1f radians\n', rad)
end
19) Modify the above program in Exercise 18 so that the function to calculate the
angle is a subfunction to the function that prints.
Ch6Ex19.m
% Script calls functions to:
% prompt for an angle in degrees
% print degrees and radians, calling a
% subfunction to convert to radians
deg = promptAng;
prtDegRadii(deg)
promptAng.m
function deg = promptAng
% Prompts for an angle in degrees
% Format of call: promptAng or promptAng()
% Returns an angle in degrees
deg = input('Enter an angle in degrees: ');
end
prtDegRadii.m
function prtDegRadii(deg)
% Prints an angle in degrees and radians
% Calls a subfunction to convert to radians
% Format of call: prtDegRadii(degrees)
% Does not return any values
rad = degRadii(deg);
fprintf('The angle %.1f degrees is \n', deg)
fprintf('equivalent to %.1f radians\n', rad)
end
function rad = degRadii(deg)
% Converts an angle from degrees to radians
% Format of call degRadii(degrees)
% Returns the angle in radians
rad = deg * pi / 180;
end
20) Write a program to calculate and print the area and circumference of a circle.
There should be one script and three functions to accomplish this (one that prompts
for the radius, one that calculates the area and circumference, and one that prints).
Ch6Ex20.m
% This script calls functions to:
% prompt the user for the radius of a circle
% calculate and return the area & circumference
% print the results
% Ignore units and error-checking for simplicity
radius = readRadius;
[area circ] = areaCirc(radius);
printAreaCirc(radius, area, circ)
readRadius.m
function radius = readRadius
% This function prompts the user and reads the radius
% Format of call: readRadius or readRadius()
% Does not return any values
disp('When prompted, please enter the radius in inches.')
radius = input('Enter the radius: ');
end
areaCirc.m
function [area, circum] = areaCirc(rad)
% This function calculates the area and
% the circumference of a circle
% Format of call: areaCirc(radius)
% Returns the area then circumference
area = pi * rad .* rad;
circum = 2 * pi * rad;
end
printAreaCirc.m
function printAreaCirc(rad,area,circ)
% Prints the radius, area, and circumference
% of a circle
% Format of call: printAreaCirc(radius,area,circumference)
% Does not return any values
fprintf('For a circle with a radius of %.1f,\n', rad)
fprintf(' the area is %.1f and the circumference is %.1f\n',...
area, circ)
end
21) The lump sum S to be paid when interest on a loan is compounded annually is
given by S = P(1 + i)n where P is the principal invested, i is the interest rate, and n is
the number of years. Write a program that will plot the amount S as it increases
through the years from 1 to n. The main script will call a function to prompt the
user for the number of years (and error‐check to make sure that the user enters a
positive integer). The script will then call a function that will plot S for years 1
through n. It will use .05 for the interest rate and $10,000 for P.
Ch6Ex21.m
% Plots the amount of money in an account
% after n years at interest rate i with a
% principal p invested
% Call a function to prompt for n
n = promptYear;
% Call a function to plot
plotS(n, .05, 10000)
promptYear.m
function outn = promptYear
% This function prompts the user for # of years n
% It error-checks to make sure n is a positive integer
% Format of call: promptYear or promptYear()
% Returns the integer # of years
inputnum = input('Enter a positive integer for n: ');
num2 = int32(inputnum);
while num2 ~= inputnum || num2 < 0
inputnum = input('Invalid! Enter a positive integer: ');
num2 = int32(inputnum);
end
outn = inputnum;
end
plotS.m
function plotS(n, i, p)
% Plots the lump sum S for years 1:n
% Format of call: plotS(n,i,p)
% Does not return any values
vec = 1:n;
s = p * (1+i).^ vec;
plot(vec,s,'k*')
xlabel('n (years)')
ylabel('S')
end
22) The following script prtftlens loops to:
call a function to prompt the user for a length in feet
call a function to convert the length to inches
call a function to print both
prtftlens.m
for i = 1:3
lenf = lenprompt();
leni = convertFtToIn(lenf);
printLens(lenf, leni)
end
Write all of the functions.
lenprompt.m
function ft = lenprompt
% Prompts the user for a length in feet
% Format of call: lenprompt or lenprompt()
% Returns the lenght in feet
ft = input('Enter a length in feet: ');
while ft <= 0
ft = input('Error! Enter a length in feet: ');
end
end
convertFtToIn.m
function inches = convertFtToIn(feet)
% Convert a length in feet to inches
% Format of call: convertFtToIN(feet)
% Returns a length in inches
inches = feet .* 12;
end
printLens.m
function printLens(feet, inches)
% Prints a length in feet and inches
% Format of call: printLens(feet, inches)
% Does not return any values
fprintf('A length of %.1f feet is equivalent', feet)
fprintf(' to %.1f inches\n', inches)
end
23) Write a program to write a length conversion chart to a file. It will print lengths
in feet, from 1 to an integer specified by the user, in one column and the
corresponding length in meters ( 1 foot = 0.3048 m) in a second column. The main
script will call one function that prompts the user for the maximum length in feet;
this function must error‐check to make sure that the user enters a valid positive
integer. The script then calls a function to write the lengths to a file.
Ch6Ex23.m
% Write a length conversion chart to a file
% Call a function to get the max length in feet
maxl = promptMaxL;
% Call a function to write the chart to a file
lengthChart(maxl)
promptMaxL.m
function maxl = promptMaxL
% This function prompts the user for a max length in feet
% It error-checks to make sure it is a positive integer
% Format of call: promptmaxl or promptmaxl()
% Returns the integer maximum length in feet
inputnum = input('Enter the maximum length: ');
num2 = int32(inputnum);
while num2 ~= inputnum | num2 < 0
inputnum = input('Invalid! Enter a positive integer: ');
num2 = int32(inputnum);
end
maxl = inputnum;
end
lengthChart.m
function lengthChart(maxl)
% Creates a chart of converting feet to
% meters and writes it to a file
% Format of call: lengthChart(maximum length)
% Does not return any values
ft = 1:maxl;
meters = ft * .3048;
chart = [ft;meters]';
save ftmetchart.dat chart -ascii
end
24) For a prism that has as its base an n‐sided polygon and height h, the volume V
and surface area A are given by:
n n 2
V = hS 2 cot A = S cot nSh
4 n 2 n
where S is the length of the sides of the polygons. Write a script that calls a function
getprism that prompts the user for the number of sides n, the height h, and the
length of the sides S and returns these three values. It then calls a function calc_v_a
that calculates and returns the volume and surface area, and then finally a function
printv_a that prints the results. The built‐in function in MATLAB for cotangent is
cot.
Ch6Ex24.m
% Calulates the volume and surface area of a prism
% with an n-sided polygon as base and height h
% Call a function to get inputs, a function to
% calculate volume and surface area, and another
% function to print the results
[n, h, s] = getprism;
[v, sa] = calc_v_a(n,h,s);
printv_a(n,h,s,v,sa)
getprism.m
function [n,h,s] = getprism
% Prompts the user for the number of sides n,
% the height h and the length of sides s for a
% prism with an n-sided base
% Format of call: getprism or getprism()
% Returns n, h, and s in that order
% Even better: error-check all of these
n = input('Enter the number of sides: ');
h = input('Enter the height: ');
s = input('Enter the length of the sides: ');
end
calc_v_a.m
function [v sa] = calc_v_a(n,h,s)
% Calculates the volume and surface area for a prism
% Format: calc_v_a(# sides, height, side length)
% Returns the volume and then surface area
v = n/4*h*s^2*cot(pi/n);
sa = n/2*s^2*cot(pi/n) + n*s*h;
end
printv_a.m
function printv_a(n,h,s,v,sa)
% Prints the volume and surface area for
% a prism with an n-sided base with length
% of sides s and height h
% Format of call: printv_a(n,h,s,v,sa)
% Does not return any values
fprintf('\nFor a prism with a height %.1f\n',h)
fprintf('and a %d-sided base with side\n', n)
fprintf('lengths %.1f, the volume is %.1f\n',s,v)
fprintf('and the surface area is %.1f\n',sa)
end
E
25) The resistance R in ohms of a conductor is given by R = where E is the
I
potential in volts and I is the current in amperes. Write a script that will:
Call a function to prompt the user for the potential and the current
Call a function that will print the resistance; this will call a subfunction to
calculate and return the resistance
Write the functions as well.
Ch6Ex25.m
% Read in the potential and current and print the resistance
% Call a function to prompt for the potential and current
[e i] = promptEI;
% Call a function to print the resistance
printResis(e,i)
promptEI.m
function [e, i] = promptEI
% Prompts the user for potential e
% and current i
% Format of call: promptEI or promptEI()
% Returns the potential E and then current I
% ignores error-checking for simplicity
e = input('Enter the potential e: ');
i = input('Enter the current I: ');
end
printResis.m
function printResis(e,i)
% This function prints the resistance
% Format of call: printResis(potential, current)
% Does not return any values
% Call a subfunction to calculate the resistance
r = calcResis(e,i);
fprintf('For a conductor with a potential %.2f\n', e)
fprintf(' and a current %.2f\n', i)
fprintf(' the resistance is %.2f\n', r)
end
function r = calcResis(e,i)
% This function calculates the resistance
% Format of call: calcResis(potential, current)
% Returns the resistance
r = e/i;
end
26) The power in watts is given by P = EI. Modify the program in Exercise 25 to
calculate and print both the resistance and the power. Modify the subfunction so
that it calculates and returns both values.
Ch6Ex26.m
% Read in the potential and current and print
% both the resistance and the power
% Call a function to prompt for the potential and current
[e i] = promptEI;
% Call a function to print the resistance and power
printResisPow(e,i)
promptEI.m
function [e, i] = promptEI
% Prompts the user for potential e
% and current i
% Format of call: promptEI or promptEI()
% Returns the potential E and then current I
% ignores error-checking for simplicity
e = input('Enter the potential e: ');
i = input('Enter the current I: ');
end
printResisPow.m
function printResisPow(e,i)
% This function prints the resistance and power
% Format of call: printResis(potential, current)
% Does not return any values
% Call a subfunction to calculate resistance & power
[r p] = calcResisPow(e,i);
fprintf('For a conductor with a potential %.2f', e)
fprintf(' and a current %.2f\n', i)
fprintf(' the resistance is %.2f', r)
fprintf(' and the power is %.2f\n',p)
end
function [r p] = calcResisPow(e,i)
% This function calculates the resistance
% Format of call: calcResis(potential, current)
% Returns the resistance
r = e/i;
p = e*i;
end
27) The distance between any two points (x1,y1) and (x2,y2) is given by:
distance = ( x1 x 2 ) 2 ( y1 y 2 ) 2
The area of a triangle is:
area = s * ( s a ) * ( s b) * ( s c)
where a, b, and c are the lengths of the sides of the triangle, and s is equal to half the
sum of the lengths of the three sides of the triangle. Write a script that will prompt
the user to enter the coordinates of three points that determine a triangle (e.g. the x
and y coordinates of each point). The script will then calculate and print the area of
the triangle. It will call one function to calculate the area of the triangle. This
function will call a subfunction that calculates the length of the side formed by any
two points (the distance between them).
Ch6Ex27.m
% Calculate the area of a triangle given the
% coordinates of the 3 points that determine it
% Prompt the user for the coordinates of the points
x1 = input('Enter the x coordinate of point 1: ');
y1 = input('Enter the y coordinate of point 1: ');
x2 = input('Enter the x coordinate of point 2: ');
y2 = input('Enter the y coordinate of point 2: ');
x3 = input('Enter the x coordinate of point 3: ');
y3 = input('Enter the y coordinate of point 3: ');
% Call a function to calculate the area, then print it
area = triarea(x1,y1,x2,y2,x3,y3);
fprintf('The area of the triangle is %.2f\n', area)
triarea.m
function outarea = triarea(x1,y1,x2,y2,x3,y3)
% Calculates the area of the triangle
% Format of call: triarea(x1,y1,x2,y2,x3,y3)
% Returns the area of the triangle
a = dist(x1,y1,x2,y2);
b = dist(x2,y2,x3,y3);
c = dist(x3,y3,x1,y1);
s = 0.5*(a+b+c);
outarea = sqrt(s*(s-a)*(s-b)*(s-c));
end
function outd = dist(x1,y1,x2,y2)
% Calculates the distance between any two points
% Format of call: dist(x1,y1,x2,y2)
% Returns the distance between the two points
outd = sqrt((x1-x2)^2 + (y1-y2)^2);
end
Satellite navigation systems have become ubiquitous. Navigation systems based in
space such as the Global Positioning System (GPS) can send data to handheld personal
devices. The coordinate systems that are used to represent locations present this data
in several formats.
28) The geographic coordinate system is used to represent any location on Earth as
a combination of altitude and longitude values. These values are angles that can be
written in the decimal degrees (DD) form or the degrees, minutes, seconds (DMS)
form just like time. For example, 24.5° is equivalent to 24°30’0”. Write a script that
will prompt the user for an angle in DD form and will print in sentence format the
same angle in DMS form. The script should error‐check for invalid user input. The
angle conversion is to be done by calling a separate function in the script. Here is an
example of running the script:
>> DMSscript
Enter an angle in decimal degrees form: 24.5588
24.56 degrees is equivalent to 24 degrees, 33 minutes,
31.68 seconds
DMSscript.m
% Prompts the user for an angle in decimal degrees (DD) form,
% calls a function to converto to degrees, minutes, seconds (DMS)
% and prints the result
angles = input('Enter an angle in decimal degrees form: ');
while angles <= 0
angles = input('Invalid! Enter an angle in decimal degrees form: ');
end
[d m s] = DMS(angles);
fprintf('%.2f degrees is equivalent to %d deg, %d minutes,\n', ...
angles, d, m)
fprintf('%.2f seconds\n', s)
DMS.m
function [degree minutes seconds] = DMS(angles)
% converts angle in DD form to DMS form
% Format of call: DMS(DD angle)
% Returns degrees, minutes, seconds
degree = floor(angles);
minutes = floor((angles - degree)*60);
seconds = ((angles - degree)*60 - minutes)*60;
end
29) Write a program to write a temperature conversion chart to a file. The main
script will:
call a function that explains what the program will do
call a function to prompt the user for the minimum and maximum
temperatures in degrees Fahrenheit, and return both values. This function
checks to make sure that the minimum is less than the maximum, and calls a
subfunction to swap the values if not.
call a function to write temperatures to a file: the temperature in degrees F
from the minimum to the maximum in one column, and the corresponding
temperature in degrees Celsius in another column. The conversion is C = (F –
32) * 5/9.
Ch6Ex29.m
% Writes a temperature conversion chart to a file
% Explain the program
explainTemp
% Prompt the user for min and max F temps
[tmin, tmax] = tempMinMax;
% Write the F temps and corresponding C temps to file
fandCTemps(tmin, tmax)
explainTemp.m
function explainTemp
% Explains that the program will write a temperature
% conversion chart from F to C to a file
fprintf('This program writes a temperature conversion')
fprintf(' chart to a file fcchart.dat.\n')
fprintf('\nIt prompts the user for a minimum and maximum')
fprintf(' temp in degrees F\n')
fprintf('It writes the F temps from min to max in one')
fprintf(' column\n and correspoding C temps in another\n')
end
tempMinMax.m
function [tmin, tmax] = tempMinMax
% Prompts the user for min and max F temps
% and makes sure min < max
% Format of call: tempMinMax or tempMinMax()
% Returns min and max temperatures in F
tmin = input('Enter the minimum F temp: ');
tmax = input('Enter the maximum F temp: ');
if tmin > tmax
[tmin tmax] = swap(tmin, tmax);
end
end
function [outa outb] = swap(ina, inb)
% swaps the values of arguments
% Format of call: swap(a,b)
% Returns b then a
outa = inb;
outb = ina;
end
fandCTemps.m
function fandCTemps(tmin, tmax)
% Writes the F and C temps to a file
% Format of call: fandCTemps(min temp, max temp)
% Does not return any values
f = tmin:tmax;
c = (f-32)*5/9;
mat = [f;c]';
save fcchart.dat mat -ascii
end
30) A bar is a unit of pressure. Polyethylene water pipes are manufactured in
pressure grades, which indicate the amount of pressure in bars that the pipe can
support for water at a standard temperature. The following script printpressures
prints some common pressure grades, as well as the equivalent pressure in atm
(atmospheres) and psi (pounds per square inch). The conversions are:
1 bar = 0.9869atm = 14.504 psi
The script calls a function to convert from bars to atm and psi, and calls another
function to print the results. You may assume that the bar values are integers.
printpressures.m
% prints common water pipe pressure grades
commonbar = [4 6 10];
for bar = commonbar
[atm, psi] = convertbar(bar);
print_press(bar,atm,psi)
end
convertbar.m
function [atm, psi] = convertbar(bar)
% Converts common pressure grades for polyethylene water pipes
% from bars to atm and psi
% Format of call: convertbar(bar)
% Returns pressure in atm and then psi
atm = bar .* 0.9869;
psi = bar .* 14.504;
end
print_press.m
function print_press(bar, atm, psi)
% Prints pressure grades in bars and in
% equivalent atm and psi
fprintf('For a pressure of %d bars,', bar)
fprintf(' the equivalent is %.1f psi\n', psi)
fprintf('and %.1f atm\n\n', atm)
end
31) The following script (called circscript) loops n times to prompt the user for the
circumference of a circle (where n is a random integer). Error‐checking is ignored
to focus on functions in this program. For each, it calls one function to calculate the
radius and area of that circle, and then calls another function to print these values.
The formulas are r = c/(2Π) and a = Π r2 where r is the radius, c is the
circumference, and a is the area. Write the two functions.
circscript.m
n = round(rand*4)+1;
for i = 1:n
circ = input('Enter the circumference of the circle: ');
[rad area] = radarea(circ);
dispra(rad,area)
end
radarea.m
function [radius area] = radarea(circ)
% Calculates the radius and area of a circle,
% given the circumference
% Format of call: radarea(circumference)
% Returns the radius then area
radius = circ/(2*pi);
area = pi * radius ^2;
end
dispra.m
function dispra(radius, area)
% Prints the radius and area of a circle
% Format of call: dispra(radius, area)
% Does not return any values
fprintf('The radius of the circle is %.2f\n', radius)
fprintf('The area of the circle is %.2f\n', area)
end
32) Write a script that will ask the user to choose his or her favorite science class,
and print a message regarding that course. It will call a function to display a menu
of choices (using the menu function); this function will error‐check to make sure
that the user pushes one of the buttons. The function will return the number
corresponding to the user’s choice. The script will then print a message.
Ch6Ex32.m
% Displays a menu and asks the user for his/her
% favorite science class, and prints a message
% based on that choice
% Call a function to display the menu
choice = scioption;
switch choice
case 1
disp('Biology, huh?')
case 2
disp('Chemistry rocks')
case 3
disp('Physics indeed')
end
scioption.m
function choice = scioption
% Print the menu of science course options and
% error-check until the user pushes one of the buttons
% Format of call: scioption or scioption()
% Returns the integer of the user's choice, from 1-3
choice = menu('Choose a science class', 'Biology', ...
'Chemistry', 'Physics');
% If the user closes the menu box rather than
% pushing one of the buttons, choice will be 0
while choice == 0
disp('Error - please choose one of the options.')
choice = menu('Choose a science class', 'Biology', ...
'Chemistry', 'Physics');
end
end
33) Write a menu‐driven program to convert a time in seconds to other units
(minutes, hours, and so on). The main script will loop to continue until the user
chooses to exit. Each time in the loop, the script will generate a random time in
seconds, call a function to present a menu of options, and print the converted time.
The conversions must be made by individual functions (e.g. one to convert from
seconds to minutes). All user‐entries must be error‐checked.
Ch6Ex33.m
% Menu-driven program to convert a time from seconds
% to other units specified by the user
% Generate a random time in seconds
rantime = randi([1 10000]);
% Call a function to display a menu and get a choice
choice = timeoption;
% Choice 3 is to exit the program
while choice ~= 3
switch choice
case 1
fprintf('%d seconds is %.1f minutes\n',...
rantime, secsToMins(rantime));
case 2
fprintf('%d seconds is %.2f hours\n',...
rantime, secsToHours(rantime));
end
% Generate a random time in seconds
rantime = randi([1 10000]);
% Display menu again and get user's choice
choice = timeoption;
end
timeoption.m
function choice = timeoption
% Print the menu of options and error-check
% until the user pushes one of the buttons
% Format of call: timeoption or timeoption()
% Returns the integer value of the choice, 1-3
choice = menu('Choose a unit', 'Minutes', ...
'Hours', 'Exit');
% If the user closes the menu box rather than
% pushing one of the buttons, choice will be 0
while choice == 0
disp('Error - please choose one of the options.')
choice = menu('Choose a unit', 'Minutes', ...
'Hours', 'Exit');
end
end
secsToMins.m
function mins = secsToMins(seconds)
% Converts a time from seconds to minutes
% Format secsToMins(seconds)
% Returns the time in minutes
mins = seconds / 60;
end
secsToHours.m
function hours = secsToHours(seconds)
% Converts a time from seconds to hours
% Format secsToHours(seconds)
% Returns the time in hours
hours = seconds / 3600;
end
34) Write a menu‐driven program to investigate the constant . Model it after the
program that explores the constant e. Pi () is the ratio of a circle’s circumference to
its diameter. Many mathematicians have found ways to approximate . For
example, Machin’s formula is:
1 1
= 4 arctan ‐ arctan
4 5 239
Leibniz found that can be approximated by:
4 4 4 4 4 4
= ‐ + ‐ + ‐ + …
1 3 5 7 9 11
This is called a sum of a series. There are six terms shown in this series. The first
term is 4, the second term is –4/3, the third term is 4/5, and so forth. For example,
the menu‐driven program might have the following options:
Print the result from Machin’s formula.
Print the approximation using Leibniz’ formula, allowing the user to specify how
many terms to use.
Print the approximation using Leibniz’ formula, looping until a “good”
approximation is found.
Exit the program.
Ch6Ex34.m
% This script explores pi
% Call a function to display a menu and get a choice
choice = pioption;
% Choice 4 is to exit the program
while choice ~= 4
switch choice
case 1
% Print result from Machin's formula
pimachin
case 2
% Approximate pi using Leibniz,
% allowing user to specify # of terms
pileibnizn
case 3
% Approximate pi using Leibniz,
% until a "good" approximation is found
pileibnizgood
end
% Display menu again and get user's choice
choice = pioption;
end
pioption.m
function choice = pioption
% Print the menu of options and error-check
% until the user pushes one of the buttons
% Format of call: pioption or pioption()
% Returns integer of user's choice, 1-4
choice = menu('Choose a pi option', 'Machin', ...
'Leibniz w/ n', 'Leibniz good', 'Exit Program');
% If the user closes the menu box rather than
% pushing one of the buttons, choice will be 0
while choice == 0
disp('Error - please choose one of the options.')
choice = menu('Choose a pi option', 'Machin', ...
'Leibniz w/ n', 'Leibniz good', 'Exit Program');
end
end
pimachin.m
function pimachin
% Approximates pi using Machin's formula and prints it
% Format of call: pimachin or pimachin()
% Does not return any values
machinform = 4 * atan(1/5) - atan(1/239);
fprintf('Using the MATLAB constant, pi = %.6f\n', pi)
fprintf('Using Machin''s formula, pi = %.6f\n',4*machinform)
end
function pileibnizn
% Approximates and prints pi using Leibniz' formula
% Prompt user for number of terms n
% Format of call: pileibnizn or pileibnizn()
% Does not return any values
fprintf('Approximate pi using Leibiz'' formula\n')
% Call a subfunction to prompt user for n
n = askforn;
approxpi = 0;
denom = -1;
termsign = -1;
for i = 1:n
denom = denom + 2;
termsign = -termsign;
approxpi = approxpi + termsign * (4/denom);
end
fprintf('An approximation of pi with n = %d is %.2f\n', ...
n, approxpi)
end
function outn = askforn
% This function prompts the user for n
% It error-checks to make sure n is a positive integer
% Format of call: askforn or askforn()
% Returns positive integer n
inputnum = input('Enter a positive integer for n: ');
num2 = int32(inputnum);
while num2 ~= inputnum | num2 < 0
inputnum = input('Invalid! Enter a positive integer: ');
num2 = int32(inputnum);
end
outn = inputnum;
end
35) Modify the function func2 from Section 6.4.1 that has a persistent variable
count. Instead of having the function print the value of count, the value should be
returned.
func2ii.m
function outc = func2ii
% Returns the value of a persistent variable
% that counts the # of times the function is called
% Format of call: func2ii or func2ii()
% Returns the value of the persistent count
persistent count
if isempty(count)
count = 0;
end
count = count + 1;
outc = count;
end
36) Write a function per2 that receives one number as an input argument. The
function has a persistent variable that sums the values passed to it. Here are the
first two times the function is called:
>> per2(4)
ans =
4
>> per2(6)
ans =
10
per2.m
function outstat = per2(num)
% Persistent variable sums the numbers
% passed to this function
% Format of call: per2(input number)
% Returns the persistent sum of input arguments
persistent mysum
if isempty(mysum)
mysum = 0;
end
mysum = mysum + num;
outstat = mysum;
end
37) What would be the output from the following program? Think about it, write
down your answer, and then type it in to verify.
testscope.m
answer = 5;
fprintf('Answer is %d\n',answer)
pracfn
pracfn
fprintf('Answer is %d\n',answer)
printstuff
fprintf('Answer is %d\n',answer)
pracfn.m
function pracfn
persistent count
if isempty(count)
count = 0;
end
count = count + 1;
fprintf('This function has been called %d times.\n',count)
end
printstuff.m
function printstuff
answer = 33;
fprintf('Answer is %d\n',answer)
pracfn
fprintf('Answer is %d\n',answer)
end
>> testscope
Answer is 5
This function has been called 1 times.
This function has been called 2 times.
Answer is 5
Answer is 33
This function has been called 3 times.
Answer is 33
Answer is 5
>>
38) Assume a matrix variable mat, as in the following example:
mat =
4 2 4 3 2
1 3 1 0 5
2 4 4 0 2
The following for loop
[r c] = size(mat);
for i = 1:r
sumprint(mat(i,:))
end
prints this result:
The sum is now 15
The sum is now 25
The sum is now 37
Write the function sumprint.
sumprint.m
function sumprint(vec)
% Prints the result of a persistent sum
% of the values in vectors that are passed
% Format of call: sumprint(vector)
% Returns the persistent sum of all input vectors
persistent mysum
if isempty(mysum)
mysum = 0;
end
mysum = mysum + sum(vec);
fprintf('The sum is now %d\n', mysum)
end
