3) The following code in bold is a Java program for Numerical Integration which allows for Midpoint, Trapezoid, and Simpson rules in Linear Algebra. A client with no technical experience wants to know what is going on in this code so that they can then explain it line-for-line for their superiors. Explain this code past the comments (be as specific as possible). What is going on within the loops? What are these cases? What is the scanner? Etc.

package NumInteg;

import java.util.Scanner; import java.text.DecimalFormat;

public class Integration { public static DecimalFormat fmt = new DecimalFormat("0.################"); public static DecimalFormat fmt2 = new DecimalFormat("0.########"); public static Scanner scan = new Scanner (System.in);

// Give the user a menu of options until he // she wants to stop.

public static void main (String[] args) { String choice = "X"; int whichFunction = 1;

System.out.println (); System.out.println ("Numerical Integration"); System.out.println ("----------------------"); System.out.println ();

while (!choice.equals("Q")) { choice = menu(); if (choice.equals("C")) whichFunction = chooseFunction(); else if (choice.equals("I")) integrate(whichFunction); else if (!choice.equals("Q")) System.out.println ("Not a valid choice - try again!"); } }

// Print a menu of options; read and return the user's // choice as a String. public static String menu () { System.out.println(" Main Menu"); System.out.println ("Choose a function - C"); System.out.println ("Integrate a function using composite rules - I"); System.out.println ("Quit - Q"); System.out.print (" Enter your choice (C, I, or Q): "); String choice = scan.next(); return choice.toUpperCase(); }

// Print a menu of function choices; read and return the // user's choice as an integer. public static int chooseFunction() { int whichOne = 0; int n = 7; // number of functions to choose from

while (whichOne <= 0 || whichOne > n) { System.out.println (" Function Choices:"); System.out.println ("1. f(x) = 4 / (1 + x^2)"); System.out.println ("2. f(x) = Math.sqrt(x) * Math.log(x)"); System.out.println ("3. f(x) = cos(x)"); System.out.println ("4. f(x) = 1 / (1 + 100x^2)"); System.out.println ("5. f(x) = Math.sqrt(Math.abs(x))"); System.out.println ("6. f(x) = 100/x^2 * Math.sin(10/x)"); System.out.println ("7. f(x) = x^16 * cos(x^16)"); System.out.print (" Enter the number for the function: "); whichOne = scan.nextInt(); if (whichOne <= 0 || whichOne > n) System.out.println ("Invalid choice - try again."); } return whichOne; }

// Perform numerical integration using the three rules (Midpoint, Trapezoid, and Simpson) on the function whose // number is sent as a parameter. The endpoints of the interval // and the number of subdivisions of the interval are read in; the // results are printed out.

public static void integrate(int fcnNum) { System.out.print (" Enter the interval endpoints a and b: "); double a = scan.nextDouble(); double b = scan.nextDouble(); System.out.print ("Enter the number of subintervals n: "); int n = scan.nextInt(); double simp = Simpson (a, b, n, fcnNum); double trap = Trapezoid (a, b, n, fcnNum); double mid = MidPoint (a, b, n, fcnNum); System.out.println (" Integral Using Composite Rules... "); System.out.println ("Interval: [" + a + ", " + b + "]"); System.out.println ("Number of subdivisions: " + n); System.out.println ("Step size h: " + (b-a)/n); System.out.println (); System.out.println("Rule\t\tApproximation\t\t\tError"); System.out.println ("Midpoint\t" + fmt.format(mid) + "\t\t" + fmt.format(Error(mid,fcnNum))); System.out.println ("Trapezoid\t" + fmt.format(trap) + "\t\t" + fmt.format(Error(trap,fcnNum))); System.out.println ("Simpson\t\t" + fmt.format(simp) + "\t\t" + fmt.format(Error(simp,fcnNum))); }

// Compute the numerical approximation of the integral of the given // function (determined by the parameter fcnNum) on the interval // [a,b] using the composite Midpoint rule

public static double MidPoint(double a, double b, int n, int fcnNum) { double h = (b - a) / n; // step size double x = 0; // area double initVal = a; double sum ; for (int i = 1; i <= n; i++) { double tpp = ((initVal + h)+initVal/2); x += f(tpp,fcnNum); initVal += h; } return x*h; }

// Compute the numerical approximation of the integral of the given // function (determined by the parameter fcnNum) on the interval // [a,b] using the composite Trapezoid rule

public static double Trapezoid (double a, double b, int n, int fcnNum) { double h = (b - a)/n; double x = a; double sum = 0;

for (int i = 1; i < n; i++) { x = a + i * h; sum += f(x, fcnNum); }

sum = 2 * sum + (f(a, fcnNum) + f(b, fcnNum));

return sum * h / 2; }

// Compute the numerical approximation of the integral of the given // function (determined by the parameter fcnNum) on the interval // [a,b] using the composite Simpson rule

public static double Simpson (double a, double b, int n, int fcnNum) { double h = (b - a)/n; double x = a; double mid = x + h/2; double sum = f(x, fcnNum); int i = 0;

while (i < n - 1) { i++; x = a + i * h; sum = sum + 4 * f(mid, fcnNum) + 2 * f(x, fcnNum); mid = x + h/2; }

sum = sum + 4 * f(mid, fcnNum) + f(b, fcnNum); return sum * h / 6; }

// Compute and return f(x) for a given x and a function f determined // by the parameter fcnNum.

public static double f(double x, int fcnNum) { double value; // f(x)

switch (fcnNum) { case 1: value = 4 / (1 + x*x); break; case 2: value = Math.sqrt(x) * Math.log(x); break; case 3: value = Math.cos(x); break; case 4: value = 1 / (1 + 100*x*x); break; case 5: value = Math.sqrt(Math.abs(x)); break; case 6: value = 100/(x*x) * Math.sin(10/x); break; case 7: double x16 = Math.pow(x, 16); value = x16 * Math.cos(x16); break; default: value = 0; } return value; }

// Compute and return the absolute value of the error in approximating // the integral of the given function public static double Error (double approx, int fcnNum) { double actual; // correct value of the integral

switch (fcnNum) { case 1: actual = Math.PI; break; case 2: actual = -4./9; break; case 3: actual = 2 * Math.sin(1); break; case 4: actual = 0.2 * Math.atan(10); break; case 5: actual = 4./3; break; case 6: actual = -1.426024763463; break; case 7: actual = 0.0491217; break; default: actual = 0; } return (Math.abs(actual - approx)); } }