Improving Supercomputing Accuracy by Sacrificing Precision

A large portion of engineering calculations overall requires something like three significant digits of precision; the problem is that these digits need to be accurate, i.e. we need a good error estimate, consistent with that precision. Most numerical algorithms do not provide such estimates, and so we've fallen into a cargo cult of excess precision, hoping that it will save us from the accuracy loss in the calculation. It often works, but occasionally fails, and we have no idea which one happened.

I have a simple example of that: a polynomial rp(x,y):=1335/4y^6+x^2(11x^2y^2-y^6+(-121)y^4-2)+11/2y^8+x/(2*y) that evaluates to about 1.1726 in both single and double precision, but whose real value is -0.827....

So, the bottom line is that I'd gladly trade off precision for better accuracy guarantees---but it turns out that's surprisingly hard in general case.

TLDR: When using an iterative solver, do the first few calculations in reduced precision, and only then switch to double -- It is more energy efficient.

I always thought it would be cool to have a top500 list that does not restrict the algorithm, just accuracy and precision of fft. It would be interesting to see how algorithms would get us from 10 petaflops to "1 exaflop equivalent" -- the flops equivalent would be time speedup to get the same answer in less time. As it is they have very strict algorithm requirements (which makes sense if you are regularizing on flops). Just curious, but of course execution time on the top supercomputers isn't cheap.

The idea of changing the method as you advance in the problem is not a new one, here's a recent article in SIAM Review http://epubs.siam.org/doi/abs/10.1137/130936725