ArbitraryPrecision Numbers

When you do calculations with arbitraryprecision numbers, the Wolfram Language keeps track of precision at all points. In general, the Wolfram Language tries to give you results which have the highest possible precision, given the precision of the input you provided.

The Wolfram Language treats arbitraryprecision numbers as representing the values of quantities where a certain number of digits are known, and the rest are unknown. In general, an arbitraryprecision number x is taken to have Precision[x] digits which are known exactly, followed by an infinite number of digits which are completely unknown.

This computes to 10digit precision.
In[1]:=
Click for copyable input
Out[1]=
After a certain point, all digits are indeterminate.
In[2]:=
Click for copyable input
Out[2]=

When you do a computation, the Wolfram Language keeps track of which digits in your result could be affected by unknown digits in your input. It sets the precision of your result so that no affected digits are ever included. This procedure ensures that all digits returned by the Wolfram Language are correct, whatever the values of the unknown digits may be.

This evaluates to 30digit precision.
In[3]:=
Click for copyable input
Out[3]=
The result has a precision of exactly 30 digits.
In[4]:=
Click for copyable input
Out[4]=
If you give input only to a few digits of precision, the Wolfram Language cannot give you such highprecision output.
In[5]:=
Click for copyable input
Out[5]=
If you want the Wolfram Language to assume that the argument is exactly , then you have to say so explicitly.
In[6]:=
Click for copyable input
Out[6]=

In many computations, the precision of the results you get progressively degrades as a result of "roundoff error". A typical case of this occurs if you subtract two numbers that are close together. The result you get depends on highorder digits in each number, and typically has far fewer digits of precision than either of the original numbers.

Both input numbers have a precision of around 20 digits, but the result has much lower precision.
In[7]:=
Click for copyable input
Out[7]=
Adding extra digits in one number but not the other is not sufficient to allow extra digits to be found in the result.
In[8]:=
Click for copyable input
Out[8]=

The precision of the output from a function can depend in a complicated way on the precision of the input. Functions that vary rapidly typically give less precise output, since the variation of the output associated with uncertainties in the input is larger. Functions that are close to constants can actually give output that is more precise than their input.

Here is a case where the output is less precise than the input.
In[9]:=
Click for copyable input
Out[9]=
Here is evaluated to 20digit precision.
In[10]:=
Click for copyable input
Out[10]=
The result you get by adding the exact integer has a higher precision.
In[11]:=
Click for copyable input
Out[11]=

It is worth realizing that different ways of doing the same calculation can end up giving you results with very different precisions. Typically, if you once lose precision in a calculation, it is essentially impossible to regain it; in losing precision, you are effectively losing information about your result.

Here is a 40digit number that is close to 1.
In[12]:=
Click for copyable input
Out[12]=
Adding to it gives another 40digit number.
In[13]:=
Click for copyable input
Out[13]=
The original precision has been maintained.
In[14]:=
Click for copyable input
Out[14]=
This way of computing loses precision.
In[15]:=
Click for copyable input
Out[15]=
The result obtained in this way has quite low precision.
In[16]:=
Click for copyable input
Out[16]=

The fact that different ways of doing the same calculation can give you different numerical answers means, among other things, that comparisons between approximate real numbers must be treated with care. In testing whether two real numbers are "equal", the Wolfram Language effectively finds their difference, and tests whether the result is "consistent with zero" to the precision given.

These numbers are equal to the precision given.
In[17]:=
Click for copyable input
Out[17]=

The internal algorithms that the Wolfram Language uses to evaluate mathematical functions are set up to maintain as much precision as possible. In most cases, builtin Wolfram Language functions will give you results that have as much precision as can be justified on the basis of your input. In some cases, however, it is simply impractical to do this, and the Wolfram Language will give you results that have lower precision. If you give higherprecision input, the Wolfram Language will use higher precision in its internal calculations, and you will usually be able to get a higherprecision result.

N[expr]evaluate expr numerically to machine precision
N[expr,n]evaluate expr numerically trying to get a result with n digits of precision

Numerical evaluation.

If you start with an expression that contains only integers and other exact numeric quantities, then N[expr,n] will in almost all cases succeed in giving you a result to n digits of precision. You should realize, however, that to do this the Wolfram Language sometimes has to perform internal intermediate calculations to much higher precision.

The global variable $MaxExtraPrecision specifies how many additional digits should be allowed in such intermediate calculations.

variable
default value
$MaxExtraPrecision50maximum additional precision to use

Controlling precision in intermediate calculations.

The Wolfram Language automatically increases the precision that it uses internally in order to get the correct answer here.
In[18]:=
Click for copyable input
Out[18]=
Using the default setting $MaxExtraPrecision=50, the Wolfram Language cannot get the correct answer here.
In[19]:=
Click for copyable input
Out[19]=
This tells the Wolfram Language that it can use more digits in its internal calculations.
In[20]:=
Click for copyable input
Out[20]=
Now it gets the correct answer.
In[21]:=
Click for copyable input
Out[21]=
This resets $MaxExtraPrecision to its default value.
In[22]:=
Click for copyable input
Out[22]=

Even when you are doing computations that give exact results, the Wolfram Language still occasionally uses approximate numbers for some of its internal calculations, so that the value of $MaxExtraPrecision can thus have an effect.

The Wolfram Language works this out using bounds from approximate numbers.
In[23]:=
Click for copyable input
Out[23]=
With the default value of $MaxExtraPrecision, the Wolfram Language cannot work this out.
In[24]:=
Click for copyable input
Out[24]=
Temporarily resetting $MaxExtraPrecision allows the Wolfram Language to get the result.
In[25]:=
Click for copyable input
Out[25]=

In doing calculations that degrade precision, it is possible to end up with numbers that have no significant digits at all. But even in such cases, the Wolfram Language still maintains information on the accuracy of the numbers. Given a number with no significant digits, but accuracy a, the Wolfram Language can then still tell that the actual value of the number must be in the range . The Wolfram Language by default prints such numbers in the form .

Here is a number with 20digit precision.
In[26]:=
Click for copyable input
Out[26]=
Here there are no significant digits left.
In[27]:=
Click for copyable input
Out[27]=
But the Wolfram Language still keeps track of the accuracy of the result.
In[28]:=
Click for copyable input
Out[28]=
Adding the result to an exact gives a number with quite high precision.
In[29]:=
Click for copyable input
Out[29]=

One subtlety in characterizing numbers by their precision is that any number that is consistent with zero must be treated as having zero precision. The reason for this is that such a number has no digits that can be recognized as significant, since all its known digits are just zero.

This gives a number whose value is consistent with zero.
In[30]:=
Click for copyable input
Out[30]=
The number has no recognizable significant digits of precision.
In[31]:=
Click for copyable input
Out[31]=
But it still has a definite accuracy that characterizes the uncertainty in it.
In[32]:=
Click for copyable input
Out[32]=

If you do computations whose results are likely to be near zero, it can be convenient to specify the accuracy, rather than the precision, that you want to get.

N[expr,p]evaluate expr to precision p
N[expr,{p,a}]evaluate expr to at most precision p and accuracy a
N[expr,{Infinity,a}]evaluate expr to any precision but to accuracy a

Specifying accuracy as well as precision.

Here is a symbolic expression.
In[33]:=
Click for copyable input
Out[33]=
This shows that the expression is equivalent to zero.
In[34]:=
Click for copyable input
Out[34]=
N cannot guarantee to get a result to precision 20.
In[35]:=
Click for copyable input
Out[35]=
But it can get a result to accuracy 20.
In[36]:=
Click for copyable input
Out[36]=

When the Wolfram Language works out the potential effect of unknown digits in arbitraryprecision numbers, it assumes by default that these digits are completely independent in different numbers. While this assumption will never yield too high a precision in a result, it may lead to unnecessary loss of precision.

In particular, if two numbers are generated in the same way in a computation, some of their unknown digits may be equal. Then, when these numbers are, for example, subtracted, the unknown digits may cancel. By assuming that the unknown digits are always independent, however, the Wolfram Language will miss such cancellations.

Here is a number computed to 20digit precision.
In[37]:=
Click for copyable input
Out[37]=
The quantity has about 34digit precision.
In[38]:=
Click for copyable input
Out[38]=
This quantity has lower precision, since the Wolfram Language assumes that the unknown digits in each number are independent.
In[39]:=
Click for copyable input
Out[39]=

Numerical algorithms sometimes rely on cancellations between unknown digits in different numbers yielding results of higher precision. If you can be sure that certain unknown digits will eventually cancel, then you can explicitly introduce fixed digits in place of the unknown ones. You can carry these fixed digits through your computation, then let them cancel, and get a result of higher precision.

SetPrecision[x,n]create a number with n decimal digits of precision, padding with base2 zeros if necessary
SetAccuracy[x,n]create a number with n decimal digits of accuracy

Functions for modifying precision and accuracy.

This introduces 10 more digits in .
In[40]:=
Click for copyable input
Out[40]=
The digits that were added cancel out here.
In[41]:=
Click for copyable input
Out[41]=
The precision of the result is now about 44 digits, rather than 34.
In[42]:=
Click for copyable input
Out[42]=

SetPrecision works by adding digits which are zero in base 2. Sometimes, the Wolfram Language stores slightly more digits in an arbitraryprecision number than it displays, and in such cases, SetPrecision will use these extra digits before introducing zeros.

This creates a number with a precision of 40 decimal digits. The extra digits come from conversion to base 10.
In[43]:=
Click for copyable input
Out[43]=
variable
default value
$MaxPrecisionInfinitymaximum total precision to be used
$MinPrecision0minimum precision to be used

Global precision control parameters.

By making the global assignment $MinPrecision=n, you can effectively apply SetPrecision[expr,n] at every step in a computation. This means that even when the number of correct digits in an arbitraryprecision number drops below n, the number will always be padded to have n digits.

If you set $MaxPrecision=n as well as $MinPrecision=n, then you can force all arbitraryprecision numbers to have a fixed precision of n digits. In effect, what this does is to make the Wolfram Language treat arbitraryprecision numbers in much the same way as it treats machine numbersbut with more digits of precision.

Fixedprecision computation can make some calculations more efficient, but without careful analysis you can never be sure how many digits are correct in the results you get.

Here is a small number with 20digit precision.
In[44]:=
Click for copyable input
Out[44]=
With the Wolfram Languages usual arithmetic, this works fine.
In[45]:=
Click for copyable input
Out[45]=
This tells the Wolfram Language to use fixedprecision arithmetic.
In[46]:=
Click for copyable input
Out[46]=
The first few digits are correct, but the rest are wrong.
In[47]:=
Click for copyable input
Out[47]=