Square root of an interval using Newton's method

Question

Hello!
I am trying to create a method that calculates the square root of an interval, and I am having trouble with both the actual calculation part, as well as the base case for the recursion. I implemented a simple counter for the recursion, but was not seeing any kind of pattern for the values. (I am pretty sure the "better" values should converge to 0).
I was wondering if anybody wanted to take a swing at it and help me out. :)
Here is the code for my program, followed by the code for Newton's method for calculating square roots of doubles. I am supposed to use it as a reference.
I made the simple arithmetic methods with the help of http://en.wikipedia.org/wiki/Interval_arithmetic . They seem to work fine, so I am having issues with troubleshooting!
Thanks!
public class Interval {
     double x1;
     double x2;
     public Interval(double newx1, double newx2){
          x1 = newx1;
          x2 = newx2;
     public String toString(){
          return "[" + this.x1 + ", " + this.x2 + "]";
     //Add an interval to the current one.
     public Interval add(Interval j){
          double tempx1 = this.x1 + j.x1;
          double tempx2 = this.x2 + j.x2;
          Interval tempInterval = new Interval(tempx1, tempx2);
          return tempInterval;
     //Subtract an interval from the current one.
     public Interval sub(Interval j){
          double tempx1 = this.x1 - j.x2;
          double tempx2 = this.x2 - j.x1;
          Interval tempInterval = new Interval(tempx1, tempx2);
          return tempInterval;
     //Multiply an interval with the current one.
     public Interval mul(Interval j){
               double minx1 = Math.min(this.x1*j.x1, this.x2*j.x2);
               double minx2 = Math.min(this.x1*j.x2, this.x2*j.x1);
               double maxx1 = Math.max(this.x1*j.x1, this.x2*j.x2);
               double maxx2 = Math.max(this.x1*j.x2, this.x2*j.x1);
               double tempx1 = Math.min(minx1, minx2);
               double tempx2 = Math.max(maxx1, maxx2);
               Interval tempInterval = new Interval(tempx1, tempx2);
               return tempInterval;
     //Divide the current interval by a new one.
     public Interval div(Interval j){
               double minx1 = Math.min(this.x1/j.x1, this.x2/j.x2);
               double minx2 = Math.min(this.x1/j.x2, this.x2/j.x1);
               double maxx1 = Math.max(this.x1/j.x1, this.x2/j.x2);
               double maxx2 = Math.max(this.x1/j.x2, this.x2/j.x1);
               double tempx1 = Math.min(minx1, minx2);
               double tempx2 = Math.max(maxx1, maxx2);
               Interval tempInterval = new Interval(tempx1, tempx2);
               return tempInterval;
     static Interval step(Interval x, Interval y) {
          // Compute a "better" guess than x for the square root of y:
          // Code for doubles: Interval better = x - (x*x - y)/(2*x);
          Interval two = new Interval(2.0, 2.0);
          Interval better = x.sub( ( (x.mul(x)).sub(y) ).div(two.mul(x)) );
          // For doubles:
          if ( Math.abs(better.x2 - better.x1) < 0.001 ) { // base case
               System.out.println(better.toString());
               return better;
          else {
               return step(better, y); // try to get even better...
     static Interval sqrt(Interval y) {
          return step(y, y); //: start guessing at the square root
     public static void main(String args[]){
          Interval i = new Interval(4.0, 8.0);
          Interval j = new Interval(4.0, 8.0);
          Interval addij = i.add(j);
          Interval subij = i.sub(j);
          Interval mulij = i.mul(j);
          Interval divij = i.div(j);
          Interval sqrtj = i.sqrt(j);
          System.out.println("Intervals:");
          System.out.println(i.toString());
          System.out.println(j.toString());
          System.out.println("Add: " + addij.toString());
          System.out.println("Sub: " + subij.toString());
          System.out.println("Mul: " + mulij.toString());
          System.out.println("Div: " + divij.toString());
          System.out.println("Sqrt: " + sqrtj.toString());
}and newton's root finder for doubles:
public class SquareRoot {
     static final double ALLOWED_ERROR = 0.001;
      * Newton's method for finding square roots.
     static double step(double x, double y) {
          // Compute a "better" guess than x for the square root of y:
          double better = x - (x*x - y)/(2*x);
          // Are we close enough?
          if ( Math.abs(x - better) < ALLOWED_ERROR ) { // => stop: base case
               return better;
          else {
               return step(better, y); // try to get even better...
     static double sqrt(double y) {
          return step(y, y); //: start guessing at the square root
     public static void main(String[] args) {
          System.out.println(Math.sqrt(1234));
          System.out.println(sqrt(1234));
          // NOTE: you may need to adjust the error bound for these two to agree
}

Answer 1

Nathron wrote:
Here is the code for my program, followed by the code for Newton's method for calculating square roots of doubles. I am supposed to use it as a reference.The only thing I can see that looks suspicious is the call to step(better, y) in your reference code.
Are you sure it shouldn't be step(y, better) or step(better, x))? Newton-Rhapson is supposed to be a progressive method, but as far as I can see the value of y can never change with the way you've got it. And if you've copied that to your new code, it might explain the problem.
Winston