1. MATLAB^* interactive numerical computational (matrix) system;
   AND
2. Maple interactive symbolic/numeric computational system;

Test your code using three test function examples given below, but your programs should be fairly general and NOT tailored to these examples.

^*A programming language system (like C or Fortran or their variants) may be substituted for the MATLAB system if preferred.

1. If MATLAB system, a MATLAB M-File program, and Command Window output for the three test examples, well-documented
   (if substitute C/Fortran system, a single program with six procedures, two each for the three sets of test functions and derivatives, with output well-documented source code and output);

2. If Maple system, a Maple worksheet of code for the three test examples and output, well-documented;

1. If MATLAB programming, set "format long", implement Newton's method and compare the answer to MATLAB's "[x_zero,f_zero] := fzero(f,x0);" if "f" is an inline defined function else use the function handle version "@f" if a m-file defined function "f" or else use the expression for the function enclosed in single quotes in place of the "f" argument of "fzero", where "x0" is the x-value argument of the "min(f(a),f(b))", while plotting each of the three functions on the initial interval "[a,b]".
   (If C/F programming substitute, use double precision (64 bits = 8 bytes, double in C or real*8 in Fortran) for Newton's and the comparison method. You may use C (CC or C++), Fortran (F77 or F90+) for this problem (else, see Prof. Hanson). Compare your Newton results to the Method of Bisection algorithm (also presented in class) using the number of iterations and the difference in final zero position answers and the approximate value of the function at that point.)

2. If Maple programming, set "Digits = 16;", implement Newton's method and compare the answer to Maple's "x_zero := fsolve(f(x)=0,x=a..b);" and the value "f_zero := f(x_zero);", while plotting each of the three functions on the initial interval "[a,b]".

abs(xnew-xold) + abs(fnew) < tolabs + tolrel*(abs(xold)+abs(fold))

with absolute tolerance tolabs = 0.5e - 7 for all subroutines and tolrel = 10*deps where deps is the double precision machine epsilon (found for Computer Problem#1) for the relative tolerance scale. Iteration limit is kmax = 80 (i.e., abort current function case with message if k > kmax) and the Tolerance Lower Limit for Derivative, |f'(x)| > told, Divide Check is told = 0.5E - 10.

1. f1(x) = exp(-7.627*x) - x*exp(-4.759); on [0.2, 1.2];

2. f2(x) = exp(4.947) - x*exp(4.854) + exp(2.252*x); on [0.0,2.0];

3. f3(x) = 80.18*exp(-75.88*(x-0.5714)^2) - 77.09*exp(-75.97*(x-0.4903)^2); on [0.1,1.1].

1. Name of Your Computer System, Processor, MATLAB version (or substitute Compiler, and Compile Command Line) and Maple version;

2. For each test example and Newton's method print a nicely labeled table of
   kfeval,     xold,     xnew,     abs(xnew-xold),     f(xnew),     f'(xold),    

   for all iterates displaying 5 significant digits. The item (f'(xold)) is only used for the Newton's method. Give the starting value for both xnew and f(xnew) for the appropriate comparison method. Here, kfeval is total number of function evaluations for current test function. The abs(xnew-xold) and f(xnew) items of the table should be printed in e-notation, because errors should almost always be in e-notation.

1. Help on MATLAB:

   • Prof. Hanson's Help for MATLAB,

2. Help on Maple Worksheets:

   • Beginner's Introduction to MapleV Release 5, or for more information see

   • Prof. Hanson's Help for Maple Symbolic Tools Archive

3. Substitute C Caution: Do NOT forget to include math.h headers, and add the compiler option -lm to the gcc (or any other cc variant) option list if needed (i.e., to remove errors because the compiler can not find some math functions). Also, C needs the pow math function, since it lacks an exponentiation symbol like "^".

4. Substitute Fortran Caution: Do NOT forget that EXTERNAL statements are needed in Fortran, in all subprograms in which other subprograms are called with FUNCTION arguments; the syntax is like EXTERNAL f1, f2, ..., fN and must come before any executable statements. Also, Fortran uses "**" for exponentiation instead of "^".