卡汉求和

Question

Has anyone used Kahan summation in an application? When would the extra precision be useful?

I hear that on some platforms double operations are quicker than float operations. How can I test this on my machine?

Answer 1

Kahan summation works well when you are summing numbers and you need to minimize the worse-case floating point error. Without this technique, you may have significant loss of precision in add operations if you have two numbers that differ in magnitude by the significant digits available (eg 1 + 1e-12). Kahan summation compensates for this.

And an excellent resource for floating point issues is here, "What every computer scientist should know about floating-point arithmetic": http://www.validlab.com/goldberg/paper.pdf

On single vs double precision performance: yes, single precision can be significantly faster, but it depends on the particular machine. See: https://www.hpcwire.com/2006/06/16/less_is_more_exploiting_single_precision_math_in_hpc-1/

The best way to test is to write a short example that tests the operations you care about, using both single (float) and double precision, and measure the runtimes.

Answer 2

I've use Kahan summation for Monte-Carlo integration. You have a scalar valued function f which you believe is rather expensive to evaluate; a reasonable estimate is 65ns/dimension. Then you accumulate those values into an average-updating an average takes about 4ns. So if you update the average using Kahan summation (4x as many flops, ~16ns) then you're really not adding that much compute to the total. Now, often it is said that the error of Monte-Carlo integration is σ/√ N , but this is incorrect. The real error bound (in finite precision arithmetic) is

σ/√ N + cond( I _n )ε N

Where cond( I _n ) is the condition number of summation and ε is twice the unit roundoff. So the algorithm diverges faster than it converges . For 32 bit arithmetic, getting ε N ~ 1 is simple: 10^7 evaluations can be done exceedingly quickly, and after this your Monte-Carlo integration goes on a random walk. The situation is even worse when the condition number is large.

If you use Kahan summation, the expression for the error changes to

σ/√ N + cond( I _n )ε ² N,

Which, admittedly still diverges faster than it converges, but ε ² N cannot be made large on a reasonable timescale on modern hardware.

Answer 3

I've used Kahan summation to compensate for an accumulated error when computing running averages. It does make quite a difference and it's easy to test. I eliminated rather large errors after only a 100 summations.

I would definitely use the Kahan summation algorithm to compensate for the error in any running totals.

However, I've noticed quite large ( 1e-3 ) errors when doing inverse matrix multiplication. Basically, A*x = y , then inv(A)*y ~= x I'm not getting the original values back exactly. Which is fine but I thought maybe Kahan summation would help (there's a lot of addition) especially with larger matrices >3-by-3. I tried with a 4-by-4 matrix and it did not improve the situation at all.

Answer 4

When would the extra precision be useful?

Very roughly:

Case 1

When you are

• Summing up a lot of data
• in a non-sequential fashion, ie computing sums, then summing up the sums (as opposed to iterating all data with a running sum),

then Kahan summation makes a lot of sense in the second phase - when you sum-up-the-sums, because the errors you're avoiding are by now more significant, while the overhead is paid only for a small fraction of the overall sum operations.

Case 2

When you're working with a lower-precision floating-point type, without being sure you're meeting the accuracy requirement, and you're not allowed to switch to a larger, higher-precision type.