What is a quick and easy way to ‘checksum’ an array of floating point numbers, while allowing for a specified small amount of inaccuracy?
e.g. I have two algorithms which should (in theory, with infinite precision) output the same array. But they work differently, and so floating point errors will accumulate differently, though the array lengths should be exactly the same. I’d like a quick and easy way to test if the arrays seem to be the same. I could of course compare the numbers pairwise, and report the maximum error; but one algorithm is in C++ and the other is in Mathematica and I don’t want the bother of writing out the numbers to a file or pasting them from one system to another. That’s why I want a simple checksum.
I could simply add up all the numbers in the array. If the array length is N, and I can tolerate an error of 0.0001 in each number, then I would check if abs(sum1-sum2)<0.0001*N. But this simplistic ‘checksum’ is not robust, e.g. to an error of +10 in one entry and -10 in another. (And anyway, probability theory says that the error probably grows like sqrt(N), not like N.) Of course, any checksum is a low-dimensional summary of a chunk of data so it will miss some errors, if not most… but simple checksums are nonetheless useful for finding non-malicious bug-type errors.
Or I could create a two-dimensional checksum, [sum(x[n]), sum(abs(x[n]))]. But is the best I can do, i.e. is there a different function I might use that would be “more orthogonal” to the sum(x[n])? And if I used some arbitrary functions, e.g. [sum(f1(x[n])), sum(f2(x[n]))], then how should my ‘raw error tolerance’ translate into ‘checksum error tolerance’?
I’m programming in C++, but I’m happy to see answers in any language.
I’ve spent a while looking for a deterministic answer, and been unable to find one. If there is a good answer, it’s likely to require heavy-duty mathematical skills (functional analysis).
I’m pretty sure there is no solution based on “discretize in some cunning way, then apply a discrete checksum”, e.g. “discretize into strings of 0/1/?, where ? means wildcard”. Any discretization will have the property that two floating-point numbers very close to each other can end up with different discrete codes, and then the discrete checksum won’t tell us what we want to know.
However, a very simple randomized scheme should work fine. Generate a pseudorandom string S from the alphabet {+1,-1}, and compute csx=sum(X_i*S_i) and csy=sum(Y_i*S_i), where X and Y are my original arrays of floating point numbers. If we model the errors as independent Normal random variables with mean 0, then it’s easy to compute the distribution of csx-csy. We could do this for several strings S, and then do a hypothesis test that the mean error is 0. The number of strings S needed for the test is fixed, it doesn’t grow linearly in the size of the arrays, so it satisfies my need for a “low-dimensional summary”. This method also gives an estimate of the standard deviation of the error, which may be handy.