magic function

[Andy]

c++:

float foo (float x) {    float xhalf = 0.5f*x;    int i = *(int*)&x;    i = 0x5f3759df - (i>>1);    x = *(float*)&i;    x = x*(1.5f - xhalf*x*x);    return x; }

without cheatin, can anyone figure out what this code does?

for those who giveup, goto

here and here

[Tony]

so it's a 10 year old piece of (amazing!) code, and an equivallently long article attempting to hunt down for the code's author.

Quote:

took a long time to figure out how and why this works, and I can't
remember the details anymore.

And it still doesn't explain the magic 0x5f3759df constant

[Andy]

the first "here" does explain it

[wtd]

It's demonstrating the hole in C++'s type system.

[Andy]

hahaa, i see it as a feature :p

[ericfourfour]

Isn't a

wtd wrote:

hole

used

Andy wrote:

as a feature

an exploit?

[Andy]

yeah it's a hack, only works on 32bit systems.

apparently that piece of code is rumored to be written by Gary Tarolli, from NVidia.. I'm going to email him and ask him about it.

[OneOffDriveByPoster]

wtd wrote:

It's demonstrating the hole in C++'s type system. ;)

Well, the code does this: undefined behaviour. Not much of a hole...

[wtd]

The hole being that ultimately values in C and C++ are untyped.

[Clayton]

what exactly does the function do? I read through both articles, and, I'll admit, I'm confused.

[Andy]

did you really? because the title of the first article clearly states the usage of the function

[md]

Yay for reposting things from slashdot

(or possibly finding and posting from digg... or before both; but it's old news either way)

[Clayton]

Yes I get the "Fast Inverse Square Root" title, but what exactly does that mean?

[zylum]

the square root function can be slow. the function presented finds the inverse square root very efficiently in (as you can see) an unconventional way. as you may know, the square root funtion is useful for finding the distance between 2 points among other useful calculations.

[md]

It calculates the inverse of the floating point number passed of course! Not only that, but it does it rather quickly using the particularities of the 32bit x86 processor, C and some math. Alas modern GPUs can do the same amazingly fast (much faster...) and it's not very portable.