Converting to machine precision

Question

There are multiple ways to convert an expression to machine precision, for example:

In[1]:= a = Sqrt[2]
Out[1]= Sqrt[2]

In[2]:= {1.a, 1`a, N@a, SetPrecision[a,MachinePrecision]}
Out[2]= {1.41421,1.41421,1.41421,1.41421}

In[3]:= Precision /@ %
Out[3]= {MachinePrecision,MachinePrecision,MachinePrecision,MachinePrecision}

My question is whether or not these methods are absolutely equivalent. Is it just a matter of personal taste which one to use, or are there examples where they behave differently?

Answer 1

In terms of speed N and SetPrecision can be expected to be faster as they do not involve an unnecessary multiplication. (Conversely 2` * a would be better than N[2 * a] because the latter does exact multiplication before the conversion.)

---

1. a and 1` a can be considered identical because they represent the same input. Personally I have taken to using the latter form for entering machine-precision integers because the syntax better reminds me of the purpose.

---

One can see that N and SetPrecision[#, MachinePrecision] & are, if not equivalent, closely related. Observe:

N[thing] := 17.5

NValues[thing]

{HoldPattern[N[thing, {MachinePrecision, MachinePrecision}]] :> 17.5}

Now:

N[thing]

SetPrecision[thing, MachinePrecision]

17.5

17.5

The fact that NValues output is given from SetPrecision indicates to me that it is using a common mechanism.

On-the-fly conversion does not use NValues:

1. thing

2` + thing

1. thing

2. + thing

---

Here is another demonstrable difference between N/SetPrecision and multiplication by 1.:

N[ Exp[1000] ]                            // Precision

SetPrecision[Exp[1000], MachinePrecision] // Precision

1. Exp[1000]                              // Precision

12.9546

12.9546

15.9546