What do you mean by " careful numerical analysis of the inputs and results"? 1) Comparison of results obtained assuming different precisions? 2) Some kind of interval arithmetics? Is any sort of it available in MATHEMATICA? 3) Comparisons of the results with any independently available data? 4) Anything else? Lesław

SetPrecision takes all numbers and mathematical constants it sees and assigns them their numerical equivalents at the requested precision. Then the expressions containing them are evaluated, and error is probagated (assuming one did not use MachinePrecision as the second argument). N by contrast attempts to evaluate the entire expression to the requested precision (same caveat). Here is an example.

ee = Sin[10^5];
prec = 4;
{InputForm@N[ee, prec], InputForm@SetPrecision[ee, prec]}

(* Out[829]= {InputForm[0.0357487979720165093`4.], InputForm[0``0.0]} *)

Notice that all precision was lost in the second case, where SetPrecision was used.

There are situations where the attained precision on application of N to a numeric expression might not be correct. The cause I am aware of is in evaluation of special functions, in cases where the error estimates might be off. I believe this is a rare situation though.

Using N in a symbolic computation is a different fish. For example, code in definite integration needs to account for presence of singular points that might only be approximately known. Code in functions such as Together (used by Integrate) might use Rationalize or take other steps just to avoid crashing; such code was not designed for handling approximate numbers (and indeed, the literature on this is far from complete).

With all this in mind, your approach seems reasonable, but I cannot offer any guarantee. Moreover I am fairly sure it would require careful numerical analysis of the inputs and results in order to provide such guarantee.

It is effectively impossible to answer this without full code to replicate it. Also it is not obvious how to gauge error in an antiderivative (indefinite integral), since it really depends on how it is subsequently used.

Hello, Series[] returns its result in a symbolic form, so that I understand the result has an "infinite" acuracy. The question is what to do next in order to convert this result to a preselected finite precision and (most importantly) maintain this precision in subsequent calculations. You write "Any subsequent calculations with each of those might indeed maintain 100 digits of precision (depending on the calculations)". What does this mean? Why "might" and not "will"? Why "depending on the calculations"? In ordinary calculations using IEEE754 floating point numbers, every arithmetic operation adds some error, so that in the worst case, after many operations, the precision of the results gradually deteriorates. But according to some manuals for MATHEMATICA, if I use floating point numbers with a a user-selected precision, the precision of the calculations will be adaptively maintained to ensure a selected level. I presume MATHEMATICA uses some mystic method of adding more bits to numbers, if needed. But how to make this happen? Should I use SetPrecision or N, or both (and how)? Please show me using my example. Please note also that I use Integrate[]. I don't use NIntegrate[] so that the issues of AccuracyGoal, PrecisionGoal, and WorkingPrecision do not arise. Lesław

I confess that I don't know much about Series, so I don't know what to expect with the iterator {x,Infinity,20}. Also, this could very well depend on how your F is actually defined. But leaving aside those caveats, I don't think this approach will get you want you want.

The function N cannot actually add any precision. If you try N[1.5,50], you'll notice that it has no effect. On the other hand N[3/2,50] does have an effect, with the result being a number with ~50 digits of precision. So, when you do

s2 = N[s1, 50]

if s1 has precision less than 50 digits, s2 will end up just being the same as s1.

Regarding your questions about SetPrecision... SetPrecision will indeed result in a number with the specified precision, however it cannot know what the original number was supposed to be, so it won't actually improve the accuracy of your calculations. Whatever error there was before you applied SetPrecision will still be there. You'll just have a bunch of garbage digits. So, at the moment you apply SetPrecision, you must somehow know that the new, high precision number is "correct" for using in the subsequent calculations.

For example, compare

SetPrecision[N[Pi, 10], 100]

to

SetPrecision[Pi, 100]

Any subsequent calculations with each of those might indeed maintain 100 digits of precision (depending on the calculations), but the results with the former will be much less "correct" than the results with the latter.

Many built-in functions that do numerical calculations take options like AccuracyGoal, PrecisionGoal, and WorkingPrecision. Using those functions (e.g. NIntegrate) with those options is probably the safest way to get the level of precision/accuracy you're after. You also need to take care not to pollute your computations by mixing lower precision numbers with higher precision ones. The precision of the result will be limited by the lowest precision involved in the calculation. So, start your calculations with infinitely precise quantities (integers, special symbols like Pi, etc) or quantities with sufficiently high precision (you'll have to figure out what that should be), and then never pollute your intermediate results with low-precision quantities (e.g. things like 1.5 will automatically have machine precision, about 15 digits).