Explicit digit-count (precision) of real number

Question

I'm trying to do something which seems like it should be simpler than it is (at least in my attempts at it). I have some code where I read in a list of numbers generated for me by a coworker. These numbers have varying degrees of precision, so the list might be something like

hisData = {0.05467`, 12.34230`, 4.69`, 9.3452`, ...}

I want to compare this to a list that I generated myself, where each number may have different degrees of precision. So my list might read

myData = {0.0547`, 12.34231`, 4.6877`, 9.345`, ...}

The comparison must be done in a particular way: all decimal digits that appear explicitly in any pair of numbers must agree exactly, except possibly when rounding is needed to make the number of digits match, but the number of digits given need not be the same. In the example lists above, all but the second pair of elements "agree". This would be easy enough to do if I had a function called, say, explicitPrecision, that counted the number of digits before and after the decimal that were explicitly typed by the user, so that

explicitPrecision[0.0547`] = {0, 4} (* 0 digits before the decimal, 4 after *)
explicitPrecision[12.34230`] = {2, 5} (* 2 digits before the decimal, 5 after *)

(In the later example, the trailing 0 counts as an explicit digit because it was typed before the backtick). The problem is that the built-in function that I would expect to help me accomplish this, Precision, assumes that all "short" numbers, less than around 16 digits are MachinePrecision. That may be good for numerics, but it isn't what I want to do in this case.

My current attempt uses RealDigits, but that doesn't really work since that function tacks on extra trailing zeros to the digitlist. I can also imagine a solution which manipulates the numbers as strings, but that seems hacky, and furthermore, I do want rounding to work in the appropriate cases so that, for instance, 0.05467 and 0.0547 are marked as equivalent, and that seems hard to do with strings. Also solutions using Round or Chop don't naively seem like they'd work to me since one would have to know in advance to what decimal place one wanted to round. To summarize, really what I'd like is to be able to tell Mathematica to use BigNum-like comparison operations in certain specific places rather than floating point, but I don't want to have to load any external packages. Thanks in advance for your help, and please let me know if any clarification is required.

Edit: To clarify, what is a simple way, using only built-in Mathematica functions accomplish the comparison I spoke about above, and/or to implement the explicitPrecision function I described?

Answer 1

Its a bit like pulling teeth, but here is a way to preserve keyed-in numbers as strings:

$PreRead = ReplaceAll[#, s_String /;
            StringMatchQ[s, NumberString]  :> ((Characters @@ #) &@
                                                        HoldForm[s]) ] &;
    hisData = StringJoin /@ {0.05467, 12.34230, 4.69, 9.3452}
    myData = StringJoin /@ {0.0547, 12.34231, 4.6877, 9.345}
    $PreRead =.; 

{"0.05467", "12.34230", "4.69", "9.3452"}

{"0.0547", "12.34231", "4.6877", "9.345"}

with a handful of values you may as well type in the quote marks, but this would be handy if you pasted in a table.

then for example ( with @m_goldberg's explicitprecision )

 explicitPrecision /@ hisData

{{0, 5}, {2, 5}, {1, 2}, {1, 4}}

of course when you need the actual numbers you do this:

 (ToExpression @ hisData)

{0.05467, 12.3423, 4.69, 9.3452}

-edit- a little cleaner..

 $PreRead = ReplaceAll[#, s_String /;
       StringMatchQ[s, NumberString]  :>
           StringJoin[
                Join[{"\""}, ((Characters @@ #) &@HoldForm[s]), {"\""} ]]] &;
     hisData = {0.05467, 12.34230, 4.69, 9.3452}
     myData = { 0.0547, 12.34231, 4.6877, 9.345}
     $PreRead =.;

arbitrary precision

convert a string representation of a number to an arbitrary precision number:

 arbp[s_] := 
     Module[{dp, p, pr}, If[ StringFreeQ[s, "."] , ToExpression[s],
      dp = First@First@StringPosition[s, "."];
      pr = StringLength[s] - dp ;
       p = (StringLength[#] + 1 - 
         First@First@StringPosition[ # , Except["0" ]]) &@ StringDrop[ s, {dp}];
      N[ Floor[ToExpression[ s] 10^pr ]/ 10^pr , p]]]
     $PreRead = 
        ReplaceAll[#, s_String /; StringMatchQ[s, NumberString] :> 
           StringJoin[ Join[{"\""}, ((Characters @@ #) &@HoldForm[s]), {"\""}]]] &;
     hisData = arbp /@ {0.05467, 12.34230, 4.69, 9.3452}
     $PreRead =.;

{0.05467, 12.34230, 4.69, 9.3452}

 Precision /@ hisData

{4., 7., 3., 5.}

this should be carefully validated .. ( it breaks with "0.000" .. zero needs to be treated as a special case )

Answer 2

Here is a possible implementation for explicitPrecision.

explicitPrecision[x_String] :=
  Module[{u = StringSplit[x, "."]},
    If[Length[u] == 1, Return[{0, StringLength[u[[1]]]}]];
    If[u[[1]] == "0", Return[{0, StringLength[u[[2]]]}]];
    StringLength /@ u]

explicitPrecision[".0547"]

{0, 4}

explicitPrecision["0.0547"]

{0, 4}

explicitPrecision["12.34230"]

{2, 5}