Question

what are the differences between using these two algorithms. I’ve always wondered how I should be optimising things.How do they differ memory and speed wise? Is one better than the other? Aside from code clarity I mean.

this is the first version I had:

bool Intersects(BoundingSphere boundingSphere)
{
    D3DXVECTOR3 vectorBetween = (centre - boundingSphere.centre);

    // works out the distance between the sphere centre's using pythag
    float distance = sqrt(
                         pow(vectorBetween.x, 2) 
                       + pow(vectorBetween.y, 2) 
                       + pow(vectorBetween.z, 2));

    // if two radius's add to more than the distance between the centres
    return (radius + boundingSphere.radius > distance);
}

This method is the same, but it doesn’t hold any values in variables, it just uses one long calculation

bool Intersects(BoundingSphere boundingSphere)
{
    return (radius + boundingSphere.radius >
            (sqrt(pow((centre - boundingSphere.centre).x, 2) +
                  pow((centre - boundingSphere.centre).y, 2) +
                  pow((centre - boundingSphere.centre).z, 2))));
}

Answer 1

The two algorithms will, under proper optimization options, compile down to exactly the same code. Since the first is far more readable, it is undoubtedly the better of the two.

The correct way to optimize this code is not to get rid of the variables (the compiler can do that for you), but to get rid of the sqrt operation: just compare squared distances.