# Machine‐Precision Numbers

Whenever machineprecision numbers appear in a calculation, the whole calculation is typically done in machine precision. The Wolfram Language will then give machineprecision numbers as the result.

Whenever the input contains any machineprecision numbers, the Wolfram Language does the computation to machine precision:
 In:= Out= Zeta[5.6] yields a machineprecision result, so the N is irrelevant:
 In:= Out= This gives a higherprecision result:
 In:= Out= When you do calculations with arbitraryprecision numbers, as discussed in "ArbitraryPrecision Numbers", the Wolfram Language always keeps track of the precision of your results, and gives only those digits which are known to be correct, given the precision of your input. When you do calculations with machineprecision numbers, however, the Wolfram Language always gives you a machineprecision result, whether or not all the digits in the result can, in fact, be determined to be correct on the basis of your input.

This subtracts two machineprecision numbers:
 In:= Out= The result is taken to have machine precision:
 In:= Out= Here are all the digits in the result:
 In:= Out//InputForm= The fact that you can get spurious digits in machineprecision numerical calculations with the Wolfram Language is in many respects quite unsatisfactory. The ultimate reason, however, that the Wolfram Language uses fixed precision for these calculations is a matter of computational efficiency.

The Wolfram Language is usually set up to insulate you as much as possible from the details of the computer system you are using. In dealing with machineprecision numbers, you would lose too much, however, if the Wolfram Language did not make use of some specific features of your computer.

The important point is that almost all computers have special hardware or microcode for doing floatingpoint calculations to a particular fixed precision. The Wolfram Language makes use of these features when doing machineprecision numerical calculations.

The typical arrangement is that all machineprecision numbers in the Wolfram Language are represented as "doubleprecision floatingpoint numbers" in the underlying computer system. On most current computers, such numbers contain a total of 64 binary bits, typically yielding 16 decimal digits of mantissa.

The main advantage of using the builtin floatingpoint capabilities of your computer is speed. Arbitraryprecision numerical calculations, which do not make such direct use of these capabilities, are usually many times slower than machineprecision calculations.

There are several disadvantages of using builtin floatingpoint capabilities. One already mentioned is that it forces all numbers to have a fixed precision, independent of what precision can be justified for them.

A second disadvantage is that the treatment of machineprecision numbers can vary slightly from one computer system to another. In working with machineprecision numbers, the Wolfram Language is at the mercy of the floatingpoint arithmetic system of each particular computer. If floatingpoint arithmetic is done differently on two computers, you may get slightly different results for machineprecision Wolfram Language calculations on those computers.

 \$MachinePrecision the number of decimal digits of precision \$MachineEpsilon the minimum positive machine‐precision number which can be added to 1.0 to give a result distinguishable from 1.0 \$MaxMachineNumber the maximum machine‐precision number \$MinMachineNumber the minimum positive machine‐precision number \$MaxNumber the maximum magnitude of an arbitrary‐precision number \$MinNumber the minimum magnitude of a positive arbitrary‐precision number

Properties of numbers on a particular computer system.

Since machineprecision numbers on any particular computer system are represented by a definite number of binary bits, numbers that are too close together will have the same bit pattern, and so cannot be distinguished. The parameter \$MachineEpsilon gives the distance between 1.0 and the closest number that has a distinct binary representation.

This gives the value of \$MachineEpsilon for the computer system on which these examples are run:
 In:= Out= Although this prints as 1., the Wolfram Language knows that the result is larger than 1:
 In:= Out= InputForm reveals that the result is not exactly 1:
 In:= Out//InputForm= Subtracting 1 gives \$MachineEpsilon:
 In:= Out= This prints as 1. also:
 In:= Out= In this case, however, the result is not distinguished from 1. to machine precision:
 In:= Out//InputForm= Subtracting 1 from the result yields 0:
 In:= Out= Machine numbers have not only limited precision, but also limited magnitude. If you generate a number that is larger in magnitude than \$MaxMachineNumber, the Wolfram Language will automatically convert the number to arbitraryprecision form.

This is the maximum machineprecision number that can be handled on the computer system used for this example:
 In:= Out= The Wolfram Language automatically converts any result larger than \$MaxMachineNumber to arbitrary precision:
 In:= Out= Here is another computation whose result is outside the range of machine-precision numbers:
 In:= Out= As of Version 11.3, if a machine-precision computation generates a number that is smaller in magnitude than \$MinMachineNumber, the Wolfram Language will issue a warning. However, it will retain the result as a subnormal machine number that has leading zeros in its binary significand.

This is the minimum machineprecision number that can be put into normal form on the computer system used for this example:
 In:= Out= The Wolfram Language issues warnings about computations that produce numbers smaller than \$MinMachineNumber, but it does not automatically convert to arbitrary-precision arithmetic:
 In:=  Out= It is possible to lose all significant digits and end up with a machine zero answer:
 In:=  Out= Converting to arbitrary precision using SetPrecision can avoid this underflow:
 In:= Out= 