What is the risk of numerical instabilities when predividing denominators?

Question

Supposing I want to divide one number into many.

a /= x;
b /= x;
c /= x;
...

Since multiplication is faster, the temptation is to do this

tmp = 1.0f / x;
a *= tmp;
b *= tmp;
c *= tmp;
...

1) Is this guaranteed to produce identical answers? I suspect not but some confirmation would be nice.

2) If x is extremely large or extremely small I expect this could cause a significant loss of accuracy. Is there a formula which will tell me how much accuracy I will sacrifice?

3) Perhaps there's no convenient formula, but can we at least state a rule of thumb for when numerical instabilities will be an issue? Is it to do with the magnitudes of the operands, or the difference between the magnitudes of the operands perhaps?

Answer 1

1) No, not guaranteed to produce identical answers. Even with IEEE, subtle rounding effects may result in a different of a 1 or 2 ULP by using a/x or a*(1/x).

2) If x is extremely small (that is a bit smaller than DBL_MIN (minimum normalized positive floating-point number) as in the case of sub-normals), 1/x is INF with total loss of precision. Potentially significant loss of precision occurs also with x very large like when the FP model does not support sub-normals.
By testing |x| against the largest finite number <= 1/DBL_MIN and the smallest non-zero >= 1/DBL_MAX, code can determine when significant loss of accuracy begins. A formula would likely depend on the FP model used and the exponent of the x as well as the model's limits. In this range of binary64, the difference in the binary exponent of x and Emin (or Emax) would be the first order estmiate of bits lost.

3) Significant numerical instabilities occur in the ranges discussed above.