Skip to main content

input forms - Explicit digit-count (precision) of real number


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



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 )


Comments

Post a Comment

Popular posts from this blog

plotting - Plot 4D data with color as 4th dimension

I have a list of 4D data (x position, y position, amplitude, wavelength). I want to plot x, y, and amplitude on a 3D plot and have the color of the points correspond to the wavelength. I have seen many examples using functions to define color but my wavelength cannot be expressed by an analytic function. Is there a simple way to do this? Answer Here a another possible way to visualize 4D data: data = Flatten[Table[{x, y, x^2 + y^2, Sin[x - y]}, {x, -Pi, Pi,Pi/10}, {y,-Pi,Pi, Pi/10}], 1]; You can use the function Point along with VertexColors . Now the points are places using the first three elements and the color is determined by the fourth. In this case I used Hue, but you can use whatever you prefer. Graphics3D[ Point[data[[All, 1 ;; 3]], VertexColors -> Hue /@ data[[All, 4]]], Axes -> True, BoxRatios -> {1, 1, 1/GoldenRatio}]
Post a Comment
Read more

plotting - Filling between two spheres in SphericalPlot3D

Manipulate[ SphericalPlot3D[{1, 2 - n}, {θ, 0, Pi}, {ϕ, 0, 1.5 Pi}, Mesh -> None, PlotPoints -> 15, PlotRange -> {-2.2, 2.2}], {n, 0, 1}] I cant' seem to be able to make a filling between two spheres. I've already tried the obvious Filling -> {1 -> {2}} but Mathematica doesn't seem to like that option. Is there any easy way around this or ... Answer There is no built-in filling in SphericalPlot3D . One option is to use ParametricPlot3D to draw the surfaces between the two shells: Manipulate[ Show[SphericalPlot3D[{1, 2 - n}, {θ, 0, Pi}, {ϕ, 0, 1.5 Pi}, PlotPoints -> 15, PlotRange -> {-2.2, 2.2}], ParametricPlot3D[{ r {Sin[t] Cos[1.5 Pi], Sin[t] Sin[1.5 Pi], Cos[t]}, r {Sin[t] Cos[0 Pi], Sin[t] Sin[0 Pi], Cos[t]}}, {r, 1, 2 - n}, {t, 0, Pi}, PlotStyle -> Yellow, Mesh -> {2, 15}]], {n, 0, 1}]
Post a Comment
Read more

plotting - Mathematica: 3D plot based on combined 2D graphs

I have several sigmoidal fits to 3 different datasets, with mean fit predictions plus the 95% confidence limits (not symmetrical around the mean) and the actual data. I would now like to show these different 2D plots projected in 3D as in but then using proper perspective. In the link here they give some solutions to combine the plots using isometric perspective, but I would like to use proper 3 point perspective. Any thoughts? Also any way to show the mean points per time point for each series plus or minus the standard error on the mean would be cool too, either using points+vertical bars, or using spheres plus tubes. Below are some test data and the fit function I am using. Note that I am working on a logit(proportion) scale and that the final vertical scale is Log10(percentage). (* some test data *) data = Table[Null, {i, 4}]; data[[1]] = {{1, -5.8}, {2, -5.4}, {3, -0.8}, {4, -0.2}, {5, 4.6}, {1, -6.4}, {2, -5.6}, {3, -0.7}, {4, 0.04}, {5, 1.0}, {1, -6.8}, {2, -4.7}, {3, -1....
Post a Comment
Read more