Java any ways to square root faster?

Question

Is there any know formula to square root faster in java, I use eclipse here's my normal code. I found a looping way that was inaccurate I'm using this for an elo calculater.

 Elo = Elo - (Math.sqrt(pointslot)/(elop-eloo)*2)

What isn't working about it? This is a pretty straight forward process and should be very fast. — zgc7009, May 10 '16 at 18:30
you could implement numerical algorithm to calculate the square root. The only gotcha is to make a good guess. This could speed up your algorithm. — mr.M, May 10 '16 at 18:32
Please provide a [complete example](http://stackoverflow.com/help/mcve). And in what way is the current approach too slow? How are you going to measure any processing increase? And what is that balance against code complexity? For example, there is [some discussion here](http://stackoverflow.com/questions/2637700/is-it-possible-to-roll-a-significantly-faster-version-of-sqrt), and a more [maths oriented one here](http://math.stackexchange.com/questions/296102/fastest-square-root-algorithm) — KevinO, May 10 '16 at 18:34
Not really relevant, but I stumbled across [link Quake 3 Arena's inverse square](https://en.wikipedia.org/wiki/Fast_inverse_square_root#Overview_of_the_code) root function, which is supposedly very fast. — Fjotten, May 10 '16 at 18:53
@Fjotten with comments like that in the original code, it'd definitely fail code review, even though it does work, simply because, if you obfuscate the function name, it becomes nigh-impossible to figure out what the function actually does. — Compass, May 10 '16 at 21:12
Ok its an Elo calculator meaning that the Elo is updated millions of time per second — MinecraftBoxGuy, May 12 '16 at 06:49

score 4 · Accepted Answer · answered May 10 '16 at 18:35

Here's the source for Java's Math.sqrt(). Optimize away. Looks pretty simple.

static const double one = 1.0, tiny=1.0e-300;

double z;
int sign = (int) 0x80000000; 
unsigned r, t1, s1, ix1, q1;
int ix0, s0, q, m, t, i;

ix0 = __HI(x); /* high word of x */
ix1 = __LO(x); /* low word of x */

/* take care of Inf and NaN */
if ((ix0 & 0x7ff00000) == 0x7ff00000) {            
    return x*x+x; /* sqrt(NaN) = NaN, 
                     sqrt(+inf) = +inf,
                     sqrt(-inf) = sNaN */
} 

/* take care of zero */
if (ix0 <= 0) {
    if (((ix0&(~sign)) | ix1) == 0) {
        return x; /* sqrt(+-0) = +-0 */
    } else if (ix0 < 0) {
        return (x-x) / (x-x); /* sqrt(-ve) = sNaN */
    }
}

/* normalize x */
m = (ix0 >> 20);
if (m == 0) { /* subnormal x */
    while (ix0==0) {
        m -= 21;
        ix0 |= (ix1 >> 11); ix1 <<= 21;
    }
    for (i=0; (ix0&0x00100000)==0; i++) {
        ix0 <<= 1;
    }
    m -= i-1;
    ix0 |= (ix1 >> (32-i));
    ix1 <<= i;
}

m -= 1023; /* unbias exponent */
ix0 = (ix0&0x000fffff)|0x00100000;
if (m&1) { /* odd m, double x to make it even */
    ix0 += ix0 + ((ix1&sign) >> 31);
    ix1 += ix1;
}

m >>= 1; /* m = [m/2] */

/* generate sqrt(x) bit by bit */
ix0 += ix0 + ((ix1 & sign)>>31);
ix1 += ix1;
q = q1 = s0 = s1 = 0; /* [q,q1] = sqrt(x) */
r = 0x00200000; /* r = moving bit from right to left */

while (r != 0) {
    t = s0 + r; 
    if (t <= ix0) { 
        s0 = t+r; 
        ix0 -= t; 
        q += r; 
    } 
    ix0 += ix0 + ((ix1&sign)>>31);
    ix1 += ix1;
    r>>=1;
}

r = sign;
while (r != 0) {
    t1 = s1+r; 
    t = s0;
    if ((t<ix0) || ((t == ix0) && (t1 <= ix1))) { 
        s1 = t1+r;
        if (((t1&sign) == sign) && (s1 & sign) == 0) {
            s0 += 1;
        }
        ix0 -= t;
        if (ix1 < t1) {
            ix0 -= 1;
        }
        ix1 -= t1;
        q1  += r;
    }
    ix0 += ix0 + ((ix1&sign) >> 31);
    ix1 += ix1;
    r >>= 1;
}

/* use floating add to find out rounding direction */
if((ix0 | ix1) != 0) {
    z = one - tiny; /* trigger inexact flag */
    if (z >= one) {
        z = one+tiny;
        if (q1 == (unsigned) 0xffffffff) { 
            q1=0; 
            q += 1;
        }
    } else if (z > one) {
        if (q1 == (unsigned) 0xfffffffe) {
            q+=1;
        }
        q1+=2; 
    } else
        q1 += (q1&1);
    }
}

ix0 = (q>>1) + 0x3fe00000;
ix1 =  q 1>> 1;
if ((q&1) == 1) ix1 |= sign;
ix0 += (m <<20);
__HI(z) = ix0;
__LO(z) = ix1;
return z;

Java any ways to square root faster?

1 Answers1