Problems with square root approximations with loops program

Question

i'm having some trouble with this program, this loop stuff is confusing me and i know i'm not doing this correctly at all. the expected values in the tester are not matching up with the output. i have tried many variations of the loop in this code even modifying the i parameter in the loop which i guess is considered bad form. nothing seems to work...
here is what i have for my solution class:
/** A class that takes the inputted number by the tester and squares it, and
*  loops guesses when the nextGuess() method is called. The epsilon value is
*  also inputted by the user, and when the most recent guess returns a value
*  <= epsilon, then the hasMoreGuesses() method should return false.
public class RootApproximator
   /** Takes the inputted values from the tester to construct a RootApproximator.
    * @param val the value of the number to be squared and guessed.
    * @param eps the gap in which the approximation is considered acceptable.
     public RootApproximator(double val, double eps)
          value = val;
          square = Math.sqrt(val);
          epsilon = eps;
   /** Uses the algorithm where 1 is the first initial guess of the
    *  square root of the inputted value. The algorithm is defined by
    *  "If X is a guess for a square root of a number, then the average
    *  of X and value/X is a closer approximation.
    *  @return increasingly closer guesses as the method is continually used.
   public double nextGuess()
         final int TRIES = 10000;
         double guess = 1;
          for (double i = 1; i < TRIES; i++)
               double temp = value / guess;
               guess = (guess + temp) / 2.0;
          return guess;
   /** Determines if there are more guesses left if the difference
    *  of the square and current guess are not equal to or less than
    *  epsilon.
    *  @return the value of the condition.
   public boolean hasMoreGuesses()
          return (square - guess <= epsilon);
   private double square;
   private double value;
   private double epsilon;
   private double guess;
here is the tester:
public class RootApproximatorTester
   public static void main(String[] args)
      double a = 100;
      double epsilon = 1;
      RootApproximator approx = new RootApproximator(a, epsilon);
      System.out.println(approx.nextGuess());
      System.out.println("Expected: 1");
      System.out.println(approx.nextGuess());
      System.out.println("Expected: 50.5");
      while (approx.hasMoreGuesses())
         approx.nextGuess();
      System.out.println(Math.abs(approx.nextGuess() - 10) < epsilon);
      System.out.println("Expected: true");
and here is the output:
10.0
Expected: 1 // not sure why this should be 1, perhaps because it is the first guess.
10.0
Expected: 50.5 // (100 + 1) / 2, average of the inputted value and the first guess.
true
Expected: true
i'm new to java this is my first java course and this stuff is frustrating. i'm really clueless as to what to do next, if anyone could please give me some helpful advice i would really appreciate it. thank you all.

Answer 1

i'm new to java this is my first java course and this
stuff is frustrating. i'm really clueless as to what
to do nextMaybe it's because you don't have a strategy for what the program is supposed to do? To me it looks like a numerical scheme for finding the squareroot of a number.
Say the number you want to squarerroot is called value and that you have an approximation called guess. How do you determine whether guess is good enought?
Well in hasMoreGuesses you check whether,
(abs(value-guess*guess) < epsilon)
The above decides if guess is within epsilon of being the squareroot of value.
When you calculate the next guess in nextGuess why do you loop so many times? Aren't you supposed to make just one new guess like,
guess = (guess + value/guess)/2.0
The above generates a new guess based on the fact that guess and value/guess must be on each side of value so that the average of them must be closer too value.
Now you can put the two together to a complete algoritm like,
while (hasMoreGuesses()) {
   nextGuess();
}In each iteration of the loop a new "guess" of the squareroot is generated and this continues until the guess is a sufficiently close approximation of the squareroot.