**This program is in JAVA, compiled in the Eclipse IDE.

Question: This is a program that compares naive and fast algorithms. The code compiles without error for me, but I am noticing an output error on the output line "Using Fast Algorithm" (pictured below, above code). For some reason, instead of performing the calculation, it just spits out the base input. Could you please review the code below and tell me where my mistake might be so I can fix this?

import java.math.BigInteger; import java.util.Random; import java.util.Scanner;

/** * Purpose: A program that compares naive and fast algorithms * @author caseycampbell, BRIKISH(online tutor) * @since 01/27/1997 * @references powertimes.xlsx, https://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html * proj00s19StarterCodeJava, https://moodle3.lsu.edu/pluginfile.php/2069923/mod_resource/content/52/csc3102proj00js19.pdf, * https://moodle3.lsu.edu/pluginfile.php/2069924/mod_resource/content/22/ProgrammingTipsJava01.txt */

// Check line 109 // Add decimal method to condense to four spots // Condense files // Check outputs, format outputs

public class powerAnalyzer { public static void main(String args[]) { Scanner sc = new Scanner(System.in); //Prompts user to enter the base of a power System.out.print("Enter the base of the power: "); BigInteger base = BigInteger.valueOf(sc.nextLong()); // Prompts user to enter exponent of a power System.out.print("Enter the exponent of the power: "); int exponent = sc.nextInt(); //Compute the powers using fast and naive algorithms // Calls for method naivePow of class BigMath BigInteger result = BigMath.naivePow(base,exponent);

// Prints the result System.out.println("Using Naive Algorithm: " + base + "^" + exponent + " = " + result);

// Calls for method fastPow of class BigMath result = BigMath.fastPow1(base, exponent);

// Prints the result System.out.println("Using Fast Algorithm: " + base + "^" + exponent + " = " + result);

// Using randomly generated numbers, defines the Random generator Random rand = new Random();

//Generate four digit positive integer for the bases int rBase = rand.nextInt(10000) + 1000; // Converts the generated number to BigInteger BigInteger rBigBase = BigInteger.valueOf(rBase);

// 5. Randomly generate a two digit positive integer int rExponent = rand.nextInt(100) + 10;

// 6. Compute the powers and display the results System.out.println(""); System.out.println("Using a random 4-digit base and a random 2-digit exponent: "); System.out.println( "Using Naive Algorithm: " + rBigBase + "^" + rExponent + " = " + BigMath.naivePow(rBigBase, rExponent)); System.out.println( "Using Fast Algorithm: " + rBigBase + "^" + rExponent + " = " + BigMath.fastPow1(rBigBase, rExponent));

// 7. Prompt the user for a positive integer to be used as the base System.out.print("Enter the base of the powers for the table -> "); BigInteger tBase = BigInteger.valueOf(sc.nextInt());

// 8. Define the array n, for exponents int n[] = { 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192 };

// Calculate and print the time consumed in the form of table System.out.println("b = " + tBase); System.out.println("=================================================="); System.out.println("n b^n: Fast Power(ns) b^n: Naive Power (ns)");

// Loop through each value of n for (int i = 0; i

// Calculate the time consumed for naive algorithm startTime = System.nanoTime(); BigMath.naivePow(tBase, n[i]); endTime = System.nanoTime(); long timeNaive = endTime - startTime;

// Print the results System.out.println(n[i] + " " + timeFast + " " + timeNaive); } } public static class BigMath{ public static BigInteger naivePow(BigInteger base, int n) throws IllegalArgumentException { BigInteger result = BigInteger.ONE; //Loops through till the values of n are reached for (int i = 0; i

public static BigInteger fastPow1(BigInteger base, int exponent) { return base; } public static BigInteger fastPow(BigInteger base, int n) throws IllegalArgumentException { // Recursive call for calculating power using fast algorithm if (n == 1) return base;

if (n == 2) return base.multiply(base);

if (n % 2 == 0) return fastPow1(fastPow1(base, n / 2), 2);

else return base.multiply(fastPow1(fastPow1(base, (n - 1) / 2), 2)); } } }

powerAnalyzer [Java Application] /Library/Java/JavaVirtualMachines/jdk1.8.0_121.jdk/Contents/H Enter the base of the power: 10 Enter the exponent of the power: 2 Using Naive Algorithm: 102 - 100 Using Fast Algorithm: 10*2 - 10 Using a random 4-digit base and a random 2-digit exponent: Using Naive Algorithm: 10021~16- 103413442173462441209916084005579146746268437648 Using Fast Algorithm: 10021116-10021 Enter the base of the powers for the table -10 b-10 n b^n: Fast Power(ns) b*n: Naive Power (ns) 16 719 32643 32 409 34503 64 242 231510 128 489 227523 256 311 640403 512 367 1108223 1024 418 3149464 2048 524 2878788 4096 452 7754657 8192 376 21383990