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?

  • 1
    $\begingroup$ As currently phrased, this doesn't ask any specific question. Rather, it reads like a "give me the code I need" request. Could you rephrase it to be a specific question? $\endgroup$
    – m_goldberg
    Jan 12, 2015 at 15:44
  • $\begingroup$ Hard to believe you would downvote over this. This feels like a Jeopardy "didn't phrase it in the form of a question" technicality. Yes, basically I am asking for ideas about what code I could write to do this. I thought I did pretty well with this question actually (short of possibly missing a duplicate in my search, which I'm always nervous about), citing 3 ideas I came up with on my own and why they won't work or would be messy. Editing the original post to add a "How can I do this?" sentence at end. Happy? $\endgroup$
    – Paco Jain
    Jan 12, 2015 at 16:05
  • $\begingroup$ How are you entering the numbers in the first place? You might consider storing the numbers as strings so that you will have the exact representation as supplied to work with. $\endgroup$
    – george2079
    Jan 12, 2015 at 16:29
  • $\begingroup$ Maybe I'm just feeling grumpy today, but no, "How can I do this?" won't make me happy. If you reduced your question to "How can I write explicitPrecision?", and removed all the additional discussion, I would be a lot more receptive to your post. Also, are you aware that input such 12.34230` is immediately converted internally to machine precession? This is likely part of your difficulties. $\endgroup$
    – m_goldberg
    Jan 12, 2015 at 16:36
  • $\begingroup$ @george2079: I thought about that... but it does seem a little hacky (to me at least). It may be the way I go if I don't get any better ideas either on my own or from others here. Mainly, I feel like it's not the "right" way to solve the problem, and if I better way is out there, then I'd like to learn about it. With so many built-in functions, there's so many obscure ones that I've never seen used, but if they exist already I don't want to reinvent the wheel. I've been working at WRI now for over 6 months, and I still "discover" new functions a couple times a week. $\endgroup$
    – Paco Jain
    Jan 12, 2015 at 16:44

3 Answers 3


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]  :>
                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 )

  • $\begingroup$ Thanks! I appreciate the response! At first I didn't catch that this would give a way to handle keyed-in numbers, and so complements m_goldberg's solution. +1, and nice solution. $\endgroup$
    – Paco Jain
    Jan 12, 2015 at 17:42

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]

{0, 4}
{0, 4}
{2, 5}
  • $\begingroup$ Thanks! This was appoximately what I had in mind, but wondered if there was a way to do it without any String manipulation. I will accept after a day or two to see if other solutions pop up. $\endgroup$
    – Paco Jain
    Jan 12, 2015 at 17:38
  • 1
    $\begingroup$ @rdjain1 Sadly I don't think there is a way to do this without Strings or some other alternative input form. (I include george's method as an alternative input form by the way.) For a long time I have wished for a simple syntax for entry of arbitrary precision numbers with precision set to the number of digits provided. I have yet to find a way to do this apart from something like m_goldberg provided above. $\endgroup$
    – Mr.Wizard
    Jan 12, 2015 at 18:18

I am also having similar kind of problem. Now I am using Mathematica 13.0. The solution I am following is as follows.

i = 4; (*no of decimal places to be accurate*)
Map[N[IntegerPart[# 10^i]/10^i, i + 1] &, data]

The above code exactly chops the number to the required number of digits and converts to real number with accuracy equal to i+1 digits.

If the rounding of the decimal places is required, the following modification in the code has to be incorporated.

i = 4;
Map[N[Ceiling[IntegerPart[# 10^(i + 1)], 10]/10^(i + 1), i + 1] &, data]

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.