Re: Significance Arithmetic

*To*: mathgroup at smc.vnet.net*Subject*: [mg37011] Re: Significance Arithmetic*From*: Daniel Lichtblau <danl at wolfram.com>*Date*: Sun, 6 Oct 2002 05:32:59 -0400 (EDT)*References*: <000001c26bd9$e486f400$0300a8c0@HolyCow>*Sender*: owner-wri-mathgroup at wolfram.com

>Please allow me to summarize what I've learned in the recent discussion, and >retract my claim that Accuracy, Precision, and SetAccuracy are useless. >Numbers come in three varieties The technical term is "flavors". >- machine precision, Infinite precision, >and "bignum" or "bigfloat". Bignums and bigfloats (synonymous?) Actually bignums can also refer to integers too large to represent as machine integers. But I tend to use "bignum" when I really mean "bigfloat", and I suspect this sloppy practice may be common. >aren't called that in the Help Browser, but they're the result of using >N[expr,k] or >SetAccuracy[expr,k] where k is bigger than machine precision. >If k <= machine precision, the result is a machine precision number, even >if you know the expression isn't that precise. >If, when you use N or SetAccuracy as described above, the expression >contains undefined symbols, you get an expression with all its numerics >replaced by bignums of the indicated precision. When the symbols are >defined later, if ANY of them are machine precision, the expression is >computed with machine arithmetic - with the side-effect that coefficients >that originally were Infinite-precision are now only machine precision. >That is, x^2 might have become x^2.0000000000000000000000000000000000 >but later became x^2., for instance. I think this is correct in cases where all symbolic stuff gets replaced by numeric values. In general there is a sort of coercion to lowest precision, with the caveat that machine floats pollute everything. >If all the symbols have been set to "bignum" or Infinite precision values, >the computation will be done taking precision into account, and the result >has a Precision or Accuracy that makes sense. In all other cases, >Precision returns Infinity for entirely Infinite-precision expressions >and 16 for everything else. I'm not sure I understand this last sentence. My interpretation: "Computations that are exact will have infinite precision. Computations in machine arithmetic will claim a precision of 16". If that is what you are claiming, then yes, that's what Mathematica is doing (but see my last remarks). >When one of the experts says "significance arithmetic" that's what they >mean - using SetAccuracy or N to give things more than 16 digits, leaving >no machine precision numbers anywhere in the expression, and using Accuracy >or Precision, which ARE meaningful in that case, to judge the result. >(It's meaningful if all your inputs really have more than 16 digits of >precision, that is.) I'm as guilty as anyone else in this thread, perhaps more so, of being too loose with the technical jargon. Also I am not certain what version 4 makes of SetAccuracy/SetPrecision in terms of significance arithmetic. In the development kernel they will force everything in sight to have the indicated precision, whether justified or not. This may well introduce error even with exact input, e.g. in cases where intermediate computations would require higher precision in order to get an end result with the requested precision or accuracy. N[], on the other hand, will handle that and, except in pathological circumstances, will give a result with the correct precision. As another minor point, "arbitrary precision numbers" are simply (tautologically?) numbers that may have arbitrarily large precision (subject to software limitations). "Significance arithmetic" refers to a particular model of manipulating such numbers with a mechanism for tracking precision. There are other models, in particular fixed precision arithmetic; that we use the former, by default, is an occasional source of sturm und drang in this news group. I'm sure the distinction between arbitrary precision numbers and significance arithmetic has at least minor relevance to this thread, and I imagine I've helped to confuse the issue in some places by using the terms almost interchangeably. >You can't use "significance arithmetic" to determine how much precision a >result has if your inputs have 16 or 15 or 2 digits of precision. One can, if the numbers are really bignums (of low precision, naturally). What one cannot do at present is create such low precision numbers via N[]. >In the example we've been looking at, you can give the inputs MORE accuracy >than you really believe they have, and still get back 0 digits from >Precision at the end, so there are clearly no trustworthy digits when >you use the original inputs either. If an expression is on the razor's >edge, and has lost only a few digits of precision, that wouldn't work >so well. >Oddly enough, "significance arithmetic" in the Browser doesn't take you >to any of that. Instead, it takes you to Interval arithmetic, a more >sophisticated method, which may give a more accurate gauge of how much >precision you really have, and WILL deal with machine precision numbers >and numbers with even less precision. It does a very good job on the >example. However, it isn't very suitable for Complex numbers, matrices, >etc. NSolve and NIntegrate probably can't handle it, either. I have filed a suggestion in-house that the documentation on significance arithmetic take one to the section on arbitrary precision numbers (3.1.5), as that would be more appropriate. Note that that section, while primarily concerned with the significance arithmetic model, also briefly mentions fixed precision bignum arithmetic. >Daniel Lichtblau promises that all this will be clearer in the next release. I'm not sure I'd go that far. What I will claim is that the distinction between machine numbers and bignums will be more transparent to users. At present if one does, say, N[number,precision] then one will get a machine number if prec<=$MachinePrecision. We have made a change so that this will no longer be the case. I am not prepared to go into details at this time (sorry). Perhaps more important for everyday use, and certainly more pertinent for this thread, Precision[] will distinguish between bignums of 16 digits precision and machine numbers. Again, I have to defer on details. At the very least I think the pitfall of believing a claim of 16 digits precision for machine numbers will be removed. Daniel Lichtblau Wolfram Research