Question

I know this sounds like a homework assignment, but it isn’t. Lately I’ve been interested in algorithms used to perform certain mathematical operations, such as sine, square root, etc. At the moment, I’m trying to write the Babylonian method of computing square roots in C#.

So far, I have this:

public static double SquareRoot(double x) {
    if (x == 0) return 0;

    double r = x / 2; // this is inefficient, but I can't find a better way
                      // to get a close estimate for the starting value of r
    double last = 0;
    int maxIters = 100;

    for (int i = 0; i < maxIters; i++) {
        r = (r + x / r) / 2;
        if (r == last)
            break;
        last = r;
    }

    return r;
}

It works just fine and produces the exact same answer as the .NET Framework’s Math.Sqrt() method every time. As you can probably guess, though, it’s slower than the native method (by around 800 ticks). I know this particular method will never be faster than the native method, but I’m just wondering if there are any optimizations I can make.

The only optimization I saw immediately was the fact that the calculation would run 100 times, even after the answer had already been determined (at which point, r would always be the same value). So, I added a quick check to see if the newly calculated value is the same as the previously calculated value and break out of the loop. Unfortunately, it didn’t make much of a difference in speed, but just seemed like the right thing to do.

And before you say “Why not just use Math.Sqrt() instead?”… I’m doing this as a learning exercise and do not intend to actually use this method in any production code.

Answer 1

First, instead of checking for equality (r == last), you should be checking for convergence, wherein r is close to last, where close is defined by an arbitrary epsilon:

eps = 1e-10  // pick any small number
if (Math.Abs(r-last) < eps) break;

As the wikipedia article you linked to mentions – you don’t efficiently calculate square roots with Newton’s method – instead, you use logarithms.