A problem about function N

Question

Toady,I have a problem about N,described as below:

For example

 N[1/3, 5]
(* ==> 0.33333*)

and N[1/3, 5] can make the result keep five significant figures.

data= RandomReal[{0, 2},8]
(* ==> {0.952811, 0.834171, 0.309447, 1.41046, 1.46811, 0.385663,1.50229,1.82034}*)

However,I want to make the data Keep four significant figures,so I use the function N[#, 4]&

N[#, 4]&/@data
(* ==> {0.952811, 0.834171, 0.309447, 1.41046, 1.46811, 0.385663,1.50229,1.82034}*)

Unfortunately,it failed.

My trail:

I copy the result,and paste in a input:

0.9528112485377731`, 0.8341711402854446`, 0.3094468949977962`, 
1.410457480346131`, 1.4681075372399688`, 0.38566305213741137`, 
1.502289805503937`, 1.820341132427437`

I wipe out the symbol `,and

data1= {0.9528112485377731, 0.8341711402854446, 0.3094468949977962, 
        1.410457480346131, 1.4681075372399688, 0.38566305213741137, 
        1.502289805503937, 1.820341132427437};
N[#, 4]&/@data1

==>(Wrong result,still keeping six significant figures )

{0.952811, 0.834171, 0.309447, 1.41046, 1.46811, 0.385663, 1.50229, 1.82034}
 

So my question is why and how to revise it?

Answer 1

Arbitrary and machine precision

It is important to understand that there are two different and in some respects separate numeric systems within Mathematica: machine-precision and arbitrary-precision. (I described this in brief here.)

Machine-precision numerics are much faster than arbitrary precision numerics, therefore it is normally undesirable to convert machine to arbitrary as you gain no precision and lose much performance. N respects this situation by not converting machine-precision numbers into arbitrary-precision numbers:

x = 1.23456789
Precision[x]

1.23457

MachinePrecision

y = N[x, 3]
Precision[y]

1.23457

MachinePrecision

Although this example is attempting to truncate a MachinePrecision number the corollary to this is that N also will not raise the precision of such as number. See: Confused by (apparent) inconsistent precision

The solution is not to use N for this operation. The correct tool will depend on your task.

Formatting

If this is to be a formatting operation use a formatting tool such as NumberForm:

NumberForm[data1, 4]

{0.9528, 0.8342, 0.3094, 1.41, 1.468, 0.3857, 1.502, 1.82}

There are multiple options and several related functions which should allow you to format your output quite precisely. See the documentation for more.

Converting to arbitrary precision

If you wish to convert machine-precision to arbitrary-precision use e.g. SetAccuracy or SetPrecision:

data2 = SetPrecision[data1, 4]

{0.9528, 0.8342, 0.3094, 1.410, 1.468, 0.3857, 1.502, 1.820}

Precision /@ data2

{4., 4., 4., 4., 4., 4., 4., 4.}

Note that although these numbers have less precision than machine precision they are still arbitrary precision numbers, and will incur the additional overhead of that system along with precision tracking etc.

Rounding a machine-precision number

Perhaps the most likely desire is the one I overlooked initially, as noted in the comments and further discussed in How do you round numbers so that it affects computation? you can indeed Round a machine-precision number to approximate fewer digits, but be aware that you are truncating (zero-filling) binary digits therefore things may not work exactly as you expect. For example:

data3 = Round[data1, 0.001]

{0.953, 0.834, 0.309, 1.41, 1.468, 0.386, 1.502, 1.82}

data3 // InputForm

{0.9530000000000001, 0.834, 0.309, 1.41, 1.468, 0.386, 1.502, 1.82}

Note the first element.

Answer 2

For the question of "why N function cannot work well", according to the documentation (Examples -> Scope -> Machine and Adaptive Precision):

N[e,p] works adaptively using arbitrary-precision numbers when p is not MachinePrecision.

Now the RandomReal[ ] function returns exactly MachinePrecision number(s), so I think that's why you can't use N[data, 4] to reset the precision.

One way is to use SetPrecision.

PS. Please understand the difference of the following results carefully:

FullForm[N[3, #]] & /@ {
                         MachinePrecision,
                        $MachinePrecision
                       } // Column

One is the MachinePrecision number (thus not arbitrary-precision), while the other is an arbitrary-precision number happened to have a precision of $MachinePrecision (which is a number).