Keep Round-Off errors for educational purpose

Question

I want to show examples of round-off errors in some numerical algorithms to my student, in order to motivate the study of algorithms with a better behavior.

While it is easy in any other language, I found it horrendously complicated in Mathematica. Precision is tracked dynamically which makes SetPrecision[ ..., p] not useful to exhibit roundoff problems. I found out that ScientificForm (maybe with Round[] on top) could do the job, and I spent hours to try to get the output of ScientificForm in expression but failed so far...

I desperately want:

a=SetPrecision[5.291/0.003, 4]

to be strictly equal to 1764 not 1763.67`4 so that I don't get different results when I input:

 {SetPrecision[a*59.16, 4], SetPrecision[1764*59.16, 4]}
 (*  {1.043*10^5, 1.044*10^5}  *)

(this can be obtained by Round[a] but I want the same thing for small or large numbers where Round does not work)

Any simple method to achieve that?

Edit: After several clever answers (but maybe not simple enough) whom authors I am grateful to, due to the level of the students I think I am going to show the example myself with a projector to students and let them program easier stuffs. Thanks again.

Answer 1

You can do

5.291`4/0.003`4
(* 1764. *)

Precision[%]
(* 3.69897 *)

But as you noted, the precision of the result is lower than 4 due to precision tracking.

Here's how to turn off precision tracking:

• How to disable roundoff error tracking in arbitrary precision arithmetic?

---

Since you want to do this for demonstration purposes, I suggest using the Computer Arithmetic package.

<<ComputerArithmetic`

We set the properties of the arithmetic. We use 4 digits and base 10.

SetArithmetic[4]
(* {4,10,RoundingRule->RoundToEven, ExponentRange->{-50,50}, MixedMode->False, IdealDivide->False, IdealDivision->False} *)

Then we can do calculations with "computer numbers":

ComputerNumber[5.291]/ComputerNumber[0.003]
(* 1763.000000000000000 *)

I don't really have any experience with this, but it looks like it was made just for what you need.

Answer 2

Since you liked Szabolcs' answer, but don't want to type ComputerNumber when entering a number, you can hack the input to Mathematica using $PreRead to automatically interpret every number in the input as a ComputerNumber:

<<ComputerArithmetic`

ComputerArithmeticOn[] := (
  $PreRead = (
    # /. s_String /; SyntaxQ@s && Head@ToExpression@s === Real :> 
            RowBox[{"ComputerNumber", "[", s, "]"}]
    ) &;
)

ComputerArithmeticOff[] := ($PreRead = .;)

Now you can do

ComputerArithmeticOn[]

a = 5.291
(* 5.291000000000000000 *)

b = 0.003
(* 0.003000000000000000000 *)

a/b
(* 1763.000000000000000 *)

5.291/0.003
(* 1763.000000000000000 *)

ComputerArithmeticOff[]

5.291/0.003
(* 1763.67 *)

I restricted the input rewriting to just apply to explicit Real numbers to avoid breaking functions that require integers as input (like the SetArithmetic function), but this will probably still break plenty of stuff. It might cover what you need, though.

Answer 3

Round takes a second argument that specifies what to round to. So, I think you can achieve what you want with:

roundToPrecision[x_, prec_] := SetPrecision[
    Round[x, 10^-Floor[prec - RealExponent[x]]],
    prec
]

For your example:

a = roundToPrecision[5.291/0.003, 4];
a //InputForm

1764.`4.

Then, your second example gives:

{SetPrecision[a*59.16,4], SetPrecision[1764*59.16,4]} //InputForm

{104358.2399999999906867743`4., 104358.2399999999906867743`4.}