Question

A recent homework assignment I have received asks us to take expressions which could create a loss of precision when performed in the computer, and alter them so that this loss is avoided.

Unfortunately, the directions for doing this haven’t been made very clear. From watching various examples being performed, I know that there are certain methods of doing this: using Taylor series, using conjugates if square roots are involved, or finding a common denominator when two fractions are being subtracted.

However, I’m having some trouble noticing exactly when loss of precision is going to occur. So far the only thing I know for certain is that when you subtract two numbers that are close to being the same, loss of precision occurs since high order digits are significant, and you lose those from round off.

My question is what are some other common situations I should be looking for, and what are considered ‘good’ methods of approaching them?

For example, here is one problem:

f(x) = tan(x) − sin(x)  when x ~ 0 

What is the best and worst algorithm for evaluating this out of these three choices:

(a) (1/ cos(x) − 1) sin(x), (b) (x^3)/2 (c) tan(x)*(sin(x)^2)/(cos(x) + 1). 

I understand that when x is close to zero, tan(x) and sin(x) are nearly the same. I don’t understand how or why any of these algorithms are better or worse for solving the problem.

Answer 1

Another rule of thumb usually used is this: When adding a long series of numbers, start adding from numbers closest to zero and end with the biggest numbers.

Explaining why this is good is abit tricky. when you’re adding small numbers to a large numbers, there is a chance they will be completely discarded because they are smaller than then lowest digit in the current mantissa of a large number. take for instance this situation:

a = 1,000,000; do 100,000,000 time:    a += 0.01; 

if 0.01 is smaller than the lowest mantissa digit, then the loop does nothing and the end result is a == 1,000,000 but if you do this like this:

a = 0; do 100,000,000 time:    a += 0.01; a += 1,000,000; 

Than the low number slowly grow and you’re more likely to end up with something close to a == 2,000,000 which is the right answer.
This is ofcourse an extreme example but I hope you get the idea.