Apparently this isn't a good idea, because the processor's caching is separate for ints and floats, and whenever you reinterpret one, it has to wait ages flushing its cache.

For floats, 'fabs' is probably implemented in the FPU and pretty fast. For ints, I tend to do this:

//int y=abs(x);
int y=(x^((signed int)x>>31))+((unsigned int)x>>31);

In two's complement arithmetic, you negate a number by twiddling all the bits and then adding one. In the above code, the XOR will twiddle all the bits if the top bit is set, and then add one if the top bit is set. It does rely on a few implementation-specific aspects of C though.

However, after all that, circle collision detection is probably going to be cheaper!

Please cut down on the attitude a little. Just screaming that you're ignorant doesn't make it any likelier someone will really help you. I also recommend you read this.

OK, so if you know the pythagorean theorem, that's a start. You can use it to calculate the shortest distance between two points when given their carthesian coordinates (a.k.a. "x" and "y"): just think of c as the distance, and a and b as the x and y coordinates respectively. Solving for radius, this gives you:
sqrt(x ^ 2 + y ^ 2) = r
...which is, BTW, an equation for a circle about the origin.
Now to use this for sphere <-> sphere collision detection, you'd simply check whether the sum of their radii is larger than the distance between their centers:
sqrt( (x2-x1) ^ 2 + (y2-y1) ^ 2 ) < (r1 + r2)
Since squaring is cheaper than square-rooting, it is a good idea to use take the square of both sides of the equation (which is OK since we're not interested in negative results):
(x2-x1) ^ 2 + (y2-y1) ^ 2 < r1 + r2
Since C doesn't come with a square operator, we need to use a function for that:

sqr(x2-x1) + sqr(y2-y1) < r1 + r2

Only problem is that C doesn't define a sqr() function either, but you can easily do that yourself. I already gave you the code.
The rectangle part is just about using bounding-box checks (basically, a series of 4 simple comparisons) BEFORE the above sphere test, to filter out the obvious non-collisions in a cheap way, avoiding most of the sphere tests (which involve expensive squaring).
In my example, I have used a C++ template for the sqr() function, so that it works with all data types that have a * operator.

Just a little correction (which was mentioned several times in this thread already, so it must've slipped Tobias this time): If you decide to compare the squares, you have to square the entire thing, which means also the right side of the inequation

(x2-x1) ^ 2 + (y2-y1) ^ 2 < (r1 + r2) ^ 2