This question already has an answer here:

Precision[N[1.0, 20]]
Precision[N[1, 20]]

It would be so much more intuitive and less error prone, if Precision[N[1.0, 20]] would be 20 and not MachinePrecision. Why do I have to explicitly use N[Rationalized[1.0], 20] to upgrade the precision?

If it is about the warning messages during the calculations, Mathematica could return a warning already at the Precision[N[1.0, 20]] step.

Edit I am not attempting to use N for rounding. I also understand the difference between MachinePrecision and arbitrary precision, which is very well described in this answer.

I want to know, why does Mathematica not consider the description of the number existing in the underling binary representation as exact if I apply N, and why I need to wrap it with Rationalize.

Is it performance?

Is it some deep semantic meaning of N vs SetPrecision?

Is set SetPrecision any different from N@Rationalize@?


marked as duplicate by Michael E2, Carl Woll, Henrik Schumacher, eyorble, bbgodfrey Sep 1 '18 at 0:24

This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.

  • 2
    $\begingroup$ I don't know why and it also puzzles me frequently. Use SetPrecision instead. $\endgroup$ – Henrik Schumacher Aug 30 '18 at 17:33
  • $\begingroup$ Darn! SetPrecision does exactly, what I thought N should do. Why do I even bother reading tutorial/NumericalPrecision and other related guides? $\endgroup$ – Johu Aug 30 '18 at 17:43
  • 3
    $\begingroup$ @Henric My simple idea about this is the following. Machine numbers are doublefloats; they form a number system by themselves. Something like precision is undefined for double floats. Therefore, when we ask for the precision of a double float, Mathematica returns MachinePrecision and we cannot approximate them with the function N with a second argument. By using SetPrecision instead of N, we actually assign a precision to a double float. In contrast, exact numbers have an infinite precision by themselves and therefore can be approximated to any precision in the second argument of N. $\endgroup$ – Fred Simons Aug 30 '18 at 18:26

N can only lower precision, it cannot raise precision.

N[1.3`4, 10] //Precision


Since MachinePrecision is considered to be the lowest possible precision for a number, applying N to a machine precision number does nothing.


(Hopefully the following will resolve some of your confusion)

Let's start with your title. N does not upgrade precision because that would mean that N is making up digits so that the precision could increase. Making up digits to increase the precision of a number is a job for SetPrecision.

Think of N as taking an input with some validated amount of precision, and returning an output with a smaller validated amount of precision (approximating). By validated amount of precision, I'm referring to the precision tracking that goes on for arbitrary precision numbers. This is the value returned by Precision. N will never return a number with a larger validated amount of precision, because in order to do so, it would have to make up digits. So:

Precision[N[3`4, 10]]   


If N returned a number with 10 digits of precision, those digits would be completely made up.

Therefore, you can trust the value returned by N. If the value returned by N had 10 digits of precision, than the input had enough precision so that a 10 digit approximation could be obtained. If the value returned by N had less than 10 digits of precision, than the input did not have enough precision to determine a 10 digit approximation.

Finally, let's consider machine numbers. It should be clear that machine numbers have no precision tracking, so the validated amount of precision is 0. There is no way for N to convert such numbers into arbitrary precision numbers with some validated amount of precision.

  • 1
    $\begingroup$ Another great piece of information not mentioned in manual for N or in selected guides. $\endgroup$ – Johu Aug 30 '18 at 17:55
  • 2
    $\begingroup$ I think that's the last example under Scope > Machine and Adaptive Precision, although that was not the first place I looked... $\endgroup$ – Brett Champion Aug 30 '18 at 18:03
  • 1
    $\begingroup$ Actually, you can specify precision lower than MachinePrecision. This could be useful in error analysis. $\endgroup$ – mikado Aug 30 '18 at 19:40
  • 2
    $\begingroup$ @mikado You can specify a number lower than the value of MachinePrecision (i.e. $MachinePrecision). I don't think that's relevant to the question, though. $\endgroup$ – Carl Woll Aug 30 '18 at 20:01

Is it some deep semantic meaning of N vs SetPrecision?

Yes. SetPrecision forcibly changes the precision. N simply computes a numerical (i.e. inexact) approximation up to the given number of digits. While doing this, N does respect the rules of inexact arithmetic, and it does not prevent precision tracking from working the way it usually does. I.e. if we operate together a number with 3 digits of precision and a number with 20 digits of precision, the result will still have only ~3 digits. N won't add extra digits not present in the original number—that would "making up data", and thus should be controlled explicitly by you, the user. That's what SetPrecision is for.

  • 1
    $\begingroup$ Very good explanation for the respective behaviors. Also answers: "why does Mathematica not consider the description of the number existing in the underling binary representation as exact if I apply N" $\endgroup$ – Daniel Lichtblau Aug 31 '18 at 21:36

Not the answer you're looking for? Browse other questions tagged or ask your own question.