[Date Index] [Thread Index] [Author Index]
Re: locating overlow/underflow (and the issue of accuracy)
On 9/9/10 at 5:31 AM, nbbienia at cyf-kr.edu.pl (Leslaw Bieniasz) wrote: >Thanks, Bill, for your comments. When I run the example that I >posted previously, I notice one thing that makes me suspicious. Up >to about y=50 (if I remember rightly), the output consists of >essentially non-zero digits. For larger y, I observe non-zero digits >initially, then there is a number of zero digits, and the remaining >digits are again non-zero. I do not believe that the string of >zeroes is correct. This may indicate some problem with achieving the >target accuracy. Possibly the last digits are just a rubbish, and >actually accurate are only the initial non-zero digits. The tools needed to determine with a high degree of confidence whether the digits are accurate or not exist in Mathematica. It is up to you to use them if you don't trust the results you are getting. Tools you might use include analyzing the behavior of your expression symbolically (limit behavior, derivative, looking at parts of the expression etc), looking to see if reported digits are stable as you change the number of digits requested, using mathematics to get the same result, using a power series expansion etc. The toolset offered by Mathematic will allow you do as much analysis as you like. The only real limit is your time. >What I generally find discouraging in Mathematica is that the error >diagnostics appears to be very scarce or missing. One gets some >results and one does not know if they are correct or not, or there >is no explanation of why something failed. This isn't likely to change. Ignoring bugs, functions will fall into one of two classes, functions based on well understood algorithms that have provable convergence properties and everything else. For those functions falling into the first class, there is no need for additional diagnostics since the results will be correct. For the other case, it isn't clear more diagnostics will be useful particularly if the algorithm being used involves heuristics or isn't all that well understood. The more likely result is additional execution overhead and additional confusion for users with no real gain.