Is there a command that does exact numerical conversion of non-exact to exact numbers?

Question

I generally prefer to do all my intermediate calculations with exact numbers, and then round my result at the end. Thus I will typically convert each arbitrary-precision number to its exact equivalent; e.g., 1.7 becomes 17/10. However, the only method I've found that ensures numerically exact conversion is the manual one: delete the decimal point, and then divide by 10^z, where z is the number of digits to the right of the decimal.

For instance, consider a = 399847593.00000068. If I use the above method, I get a fraction that is exactly equal to a. Is there a command that achieves this?

Edit added for clarity: I'm not looking for exact rational representations of the computer's internal binary representation of base-10 floating point numbers; I understand the latter typically can't be exactly equal to the floating point. Rather, I'm looking for exact rational representation of the floating point numbers themselves (which the software can do, if I enter them manually), which will then effectively be carried through the entire calculation. At the end of the calculation, final cancellations, and numerical conversion to a floating point, if desired, can then be done.

I tried SetPrecision[a,Infinity] and SetAccuracy[a, Infinity], but both give fractions that are not exactly equal to a (see screenshot below). Why is this? [Edit: I've removed my speculations here, since Szabloc's answer explains the behavior of these commands.]

From the name, Rationalize might seem to be a good candidate, but Rationalize[a, 0] likewise doesn't give a numerically exact conversion, as expected from the documentation: "Rationalize[x,0] gives a rational number equivalent to x up to the precision of x." Finally, multiplying by 10^z (see first paragraph), applying Floor, and then dividing by 10^z likewise doesn't achieve the desired result:

{a = 399847593.00000068, Precision[a] // N}
mExact = 39984759300000068/10^8; (*manual method*)
mNum25 = NumberForm[N[mExact, 25], 
ExponentFunction -> (If[-Infinity < # < Infinity, Null, #] &)];
{mExact, Precision[mExact], mNum25}
pExact = SetPrecision[a, Infinity]; (*SetPrecision method*)
pNum25 = NumberForm[N[pExact, 25], 
ExponentFunction -> (If[-Infinity < # < Infinity, Null, #] &)];
{pExact, Precision[pExact], pNum25}
aExact = SetAccuracy[a, Infinity]; (*SetAccuracy method*)
aNum25 = NumberForm[N[aExact, 25], 
ExponentFunction -> (If[-Infinity < # < Infinity, Null, #] &)];
{aExact, Precision[aExact], aNum25}
rExact = Rationalize[a, 0]; (*Rationalize method*)
rNum25 = NumberForm[N[rExact, 25], 
ExponentFunction -> (If[-Infinity < # < Infinity, Null, #] &)];
{rExact, Precision[rExact], rNum25}
fExact = Floor[a*10^8]/10^8; (*Floor method*)
fNum25 = NumberForm[N[fExact, 25], 
ExponentFunction -> (If[-Infinity < # < Infinity, Null, #] &)];
{fExact, Precision[fExact], fNum25}

Answer 1

However, the only method I've found that ensures numerically exact conversion is the manual one: delete the decimal point, and then divide by 10^z, where z is the number of digits to the right of the decimal.

This does not produce an exact conversion because floating point numbers are represented in binary, not in decimal.

I tried SetPrecision[a,Infinity] and SetAccuracy[a, Infinity], but both give fractions that are not exactly equal to a (see screenshot below).

In fact the result of SetPrecision[..., Infinity] is the one that is exactly equal to the input. Floating point numbers are represented in binary. You can see all their digits using RealDigits[..., 2].

The following will give an exact conversion, and the same result as SetPrecision[..., Infinity] (thanks @george2079!)

exactConvert[x_Real] := FromDigits[RealDigits[x, 2], 2]

If you try it on 0.1, you don't get 1/10:

exactConvert[0.1]
(* 3602879701896397/36028797018963968 *)

SetPrecision[0.1, Infinity]
(* 3602879701896397/36028797018963968 *)

We don't get 1/10 because 1/10 is simply not exactly representable in binary. When Mathematica prints it as 0.1, it does some rounding. This already shows that it does not make sense for most use cases to do a truly exact conversion.

Rationalize returns a more reasonable result:

Rationalize[0.1, 0]
(* 1/10 *)

The important thing to keep in mind is that floating point numbers are meant as an approximate representation. For most use cases an exact conversion simply does not make sense. However, if you do want to do it, you can using the functions above.

In my opinion, Rationalize with a reasonable chosen precision makes more sense. For a machine number, a reasonable precision is something just below $MachinePrecision, i.e. about 15 digits. This is why Rationalize[0.1, 0] gives 1/10 instead of the truly exact 3602879701896397/36028797018963968.

---

To sum up, the key problem here is that your concept of "exactness" as taking all displayed decimal digits is simply flawed; and that true exactness is simply not useful unless you are concerned with floating point representations.

Answer 2

Here are a couple ideas:

Round[a, 10^-Round[Accuracy[a]]]
FromDigits @ RealDigits[a]

1999237965000003/5000000

1999237965000003/5000000