# Math 4073 (Numerical Analysis I) - Fall 1999 Home Page for Section 001

Instructor:

John Albert
Office: PHSC 1004, Ext. 5-3782.
Office hours: Mon and Thurs 10:30-11:30 PM; Wed 3:30-4:30 PM (or by appointment)
E-mail: jalbert@ou.edu

## Assignment 1 (Due Mon. Aug. 30)

• p. 99: #8
• p. 101: #1, 3 (the calculator gives a wrong answer to #3. Why?)

## Assignment 2 (Due Wed. Sept. 8)

• p. 113-117, #1, 13(a,c), 19 (explain your answer!), 23, 25, 35 (do the cases m = 2 and m = 3 only)
• p. 119-120, #5, 19 (as your example, solve the equation e^x - x - 1 = 0)

• p. 129 #5, 9
• p. 132 #11

## Assignment 4 (Due Fri. Oct. 1)

• p. 156-161 #1, 2, 3, 5, 9 (do by hand), 10 (do by hand), 26 (do either by hand or by calculator), 33 (hint: use the uniqueness theorem), 46

## Assignment 5 (Due Mon. Oct. 11)

• p. 169-170 #9, 13
• p. 170 (Computer Problems) #1, 2 (only use the second set of nodes).

## Assignment 6 (Due Wed. Oct. 27)

• p. 180-183 #1, 3, 7, 9, 18

## Assignment 7 (Due Fri. Nov. 5)

• p. 206-207 #2, 4, 7, 17b
• p. 209 (Computer Problems) #4 (compute with error less than 0.5E-5)
• p. 220 (Computer Problems) #3, 11

## Assignment 8 (Due Mon. Nov. 22)

• p. 227 #1, 2(a,b)
• p. 228 (Computer Problems) #1
• p. 237 #12, 14
• p. 238 (Computer Problems) #1, 2

## Assignment 9 (Due ???)

• p. 380 #1, 2, 3, 16
• (to be continued...)

## Programs for the TI-85

Below are links to the programs used in our class so far. Clicking on a link should bring up a screen with a text version of the program. You can then either (1) type the program into your calculator by hand, or (2) save the program as a file onto your computer, and then use the TI GRAPH-LINK software and cable (if you have them) to convert this file into a program on your calculator.

If you are typing the file into your calculator by hand, you will need to know how the text version you see on your computer translates into function keys on your calculator. For example, if the text version on your computer contains the symbols "\->\", then this is meant to stand for the "store" key on your calculator (right above the "on" key). For a full list of all the translations you'll need to know, click here .

• `bisc.asc     Bisection method for solving equations.  `
• `bisc2.asc    Similar to bisc.asc, but prints out all iterations. `
• `newt.asc     Newton's method for solving equations. `
• `seca.asc     Secant method for solving equations. `
• ```dvdf.asc     Computes coefficients of Newton interpolating polynomial using
divided differences. Requires XLIST and YLIST as input.
Coefficients are output in COEF. ```
• ```nval.asc     Evaluates Newton interpolating polynomial.  Requires
coefficients to have been computed and stored in COEF.
Requires xc as input (value of x).  Value of
interpolating polynomial is output as AA.  ```
• ```node.asc     Computes equally spaced nodes on a given interval, and
stores them in XLIST.  Then computes values of the function y1 for these nodes,
and stores the function values in YLIST. ```
• ```cheb.asc     Computes Chebyshev nodes on a given interval, and
stores them in XLIST.  Then computes values of the function y1 for these nodes,
and stores the function values in YLIST.```
• ```ngrf.asc     Given a function y1 and an interval [xMin,xMax], this
program will first graph the function on the interval and then graph the
interpolating polynomial for a given number of nodes in the interval.
The input variable N is one less than the number of nodes.
The input variable P determines how many points are plotted when graphing the
interpolating polynomial.  The choice of nodes is determined by whether the
program calls CHEB or NODE. ```
• ```erlist.asc   After you run DVDF or NGRF, you can use ERLIST to
compute the error of interpolation |p(x)-f(x)| at a given number of
equally spaced points in [xMin,xMax].  The input variable P is one less than
the number of points at which the errors are computed. ```
• ```trap.asc     Approximates the integral of f(x) from a to b using
the composite trapezoid rule.  The function f(x) should be defined as
y1 before running the program.  The program prompts for a and b, and for the
number N of subintervals into which the interval [a,b] is divided.  The result
is stored in val and displayed.

romb.asc     Approximates the integral of f(x) from a to b using
Romberg integration.  Again, f(x) should be defined as y1.  The program
prompts for a and b, and for the number M of columns to produce in the
Romberg array. The entries in the Romberg array are stored in the matrix RMAT.

simp.asc     Approximates the integral of f(x) from a to b using
the composite Simpson's rule.  Uses the same input and output variables as
TRAP.  Notice, however, that N must be an even number.

csmp.asc     Approximates the integral of f(x) from a to b using
the adaptive, recursive Simpson's scheme described in Section 5.4 of the text.
The program CSMP sets the problem up initially, prompting for a, b,
epsilon (the desired accuracy) and for the maximum number of levels of
recursion you want to allow (this prevents infinite recursion).
The result is displayed and stored in the variable smprs.
The actual recursive procedure is called ADSMP (see below).

adsmp.asc    This is the recursive procedure described in
the pseudocode on page 226 of the text.  The procedure had to be revised in
order to run correctly on the TI-85, since the TI-85 does not allow local
variables or parameter passing in subroutines.  Those of you using the
TI-92, which does allow these features, can program the code just as it
is on p. 226.  To use this procedure, run CSMP (see above).

euler.asc    Solves a first-order O.D.E. dx/dt = f(x,t)
using Euler's method.  Prompts for t0, the initial value of t; x0, the
initial value of x; tm, the value of t at which you want to compute x;
and N, the number of increments in t to take to reach tm.  Then prompts
for the formula defining the function f(x,t) on the right-hand side of
the equation.  The desired value of x is stored in the variable x when
the program stops.

heun.asc     Solves a first-order O.D.E. using Heun's
method.  The inputs and outputs are the same as for euler.asc.

rk.asc       Solves a first-order O.D.E. using the standard
Runge-Kutta 4th-order method.  Inputs and outputs are the same as for
euler.asc.

```