The Wolfram Language supports three types of computer arithmetic:

Each has their respective benefits and weaknesses, and understanding when to use each for the fastest and most accurate results is an important part of any Wolfram Language programmer’s toolbox. This article aims to provide a general overview of each type without diving into all the technical specifics. More details can be found in the Wolfram Language documentation, which will be linked throughout.

## Machine-precision arithmetic

Machine-precision arithmetic is used when a number is entered with a decimal point (for example, 4.2 or 1.) or when the single argument N function is used (for example, N[1/2]). On most modern computers, machine-precision arithmetic results in roughly 16 digits of mantissa (digits following the decimal point).

The main advantage of using machine-precision arithmetic is speed. Arbitrary-precision numerical calculations are usually many times slower than machine-precision calculations.

While machine-precision computation is fast, it should be avoided when working with very large or very small numbers where accuracy is critical (use arbitrary precision instead) or when a symbolic result is required (use infinite precision instead).

It is also worth noting that when using machine precision, roundoff errors are not tracked. This is done for speed, but can result in erroneous results. For example, Out[1] is incorrect in the following:

``````In[1]:= N[Sin[10^50]]
Out[1]= -0.4805

In[2]:= N[Sin[10^50], 20]
Out[2]= -0.78967249342931008271``````

Most of the Wolfram Language’s built-in mathematical functions provide output that best matches the given input’s precision. If you feed these functions a machine-precision input, they will result in a machine-precision output. For example:

``````In[3]:= Sin[4.2]
Out[3]= -0.871576

In[4]:= Precision[%]
Out[4]= MachinePrecision``````

Similarly, if you combine machine-precision inputs with arbitrary- or infinite-precision inputs in a single calculation, the result will be given in machine precision:

``````In[5]:= 3 + 4.5
Out[5]= 7.5

In[6]:= Precision@%
Out[6]= MachinePrecision``````

Numerical operators (NIntegrate, NSum, NDSolve, etc.) return machine precision by default.

## Arbitrary-precision arithmetic

When you do calculations with arbitrary-precision arithmetic 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.

Arbitrary-precision numbers are most commonly created by using the N function with its second argument. For example, N[Pi, 20] gives the numeric result of Pi to 20 digits of precision (3.1415926535897932385).

Arbitrary precision is useful for calculations that require a high degree of precision, including working with very large or very small numbers. However, arbitrary-precision computations are slower than machine-precision calculations, so arbitrary-precision numbers are usually not used when high accuracy is not required.

As with machine-precision numbers, if you feed built-in mathematical functions an arbitrary-precision input, they will result in an arbitrary-precision output. For example:

``````In[1]:= N[7, 30]^2
Out[1]= 49.0000000000000000000000000000

In[2]:= Precision[%]
Out[2]= 29.699``````

Combining machine-precision and arbitrary-precision input will result in machine-precision output. As a result, errors will not be tracked.

An effective way to evaluate an expression in arbitrary-precision is to use SetPrecision:

``````In[3]:= SetPrecision[1.9658*(1.23423423/500 + 600/3.9879), 20]
Out[3]= 295.76954069704845551
``````

You can force numerical operators (NIntegrate, NSum, NDSolve, etc.) to use arbitrary precision by setting their WorkingPrecision option.

## Infinite-precision arithmetic

Infinite-precision arithmetic is used when exact inputs are known and exact outputs are desired, or when manipulating expressions algebraically.

Rationalize is a useful function to convert floating-point numbers to an exact number.

If you feed built-in mathematical functions an infinite-precision input, they will result in an infinite-precision output. For example:

``````In[1]:= Cos[Pi]
Out[1]= -1

In[2]:= Precision[%]
Out[2]= \[Infinity]``````

Combining infinite-precision and machine-precision input will result in machine-precision output.