68

Control the Precision and Accuracy of Numerical Results This is an excellent question. Of course everyone could claim highest accuracy for their product. To deal with this situation there exist benchmarks to test for accuracy. One such benchmark is from NIST. This specific benchmark deals with the accuracy of statistical software for instance. The NIST ...


23

UpArrow[a_, n_Integer] := Nest[a^# &, 1, n] then UpArrow[4, 3] or 4 \[UpArrow] 3 To complete this method you may wish to add an input alias: AppendTo[CurrentValue[$FrontEndSession, InputAliases], "up" -> "\[UpArrow]"]; Now EscupEsc will enter \[UpArrow]. Change $FrontEndSession to $FrontEnd and run it only once to make the change persist ...


22

SetPrecision[] does this: SetPrecision[0.1, ∞] 3602879701896397/36028797018963968


20

Introduction This seems to be a question more about IEEE 754 binary64 format than about Mathematica per se. The significand is 53 bits (52 stored, since the leading bit is assumed to be 1 in a normal number). When the input "0.1" is converted to a number, presumably, at some point 1. is divided by 10. The OP used the term "truncate," but more precisely, ...


19

Indeed, there is no direct method to input a repeating decimal. The closest you can get is to input the repeating digits into FromDigits[]: $$0.\overline{142857}$$ FromDigits[{{{1, 4, 2, 8, 5, 7}}, 0}] 1/7 $$0.\overline{3}$$ FromDigits[{{{3}}, 0}] 1/3 $$0.1\overline{6}$$ FromDigits[{{1, {6}}, 0}] 1/6 Of course, this also applies for e.g. ...


13

N A one-character answer is disallowed by SE, so I will expand. N is mostly what I use. If I have an expression like $2 x + 3$, I sometimes write it 2. x + 3. in Mathematica; then if x is numeric, whether it happens to be an Integer or not, the expression will always be Real or Complex.


13

One way is to plot the function 0 against a log axis. LogLogPlot[0, {t, 1, 12}, Axes -> {True, False}, Ticks -> {Range[12]}] or, changing the numbers LogLogPlot[0, {t, 64, 96}, Axes -> {True, False}, Ticks -> {Range[64, 96]}] The Axis function turns off the vertical axis (because you just want the number line) and the Ticks specifies where ...


13

In some settings the integers, fractions, rational numbers, reals, and complexes are five distinct systems. Further, for reals and complexes, there are the standard reals and complexes as well as nonstandard systems. There are mappings from some to others, so that a subset of the reals in an isomorphic image of the integers (as rings), and so on for ${\bf Z}...


12

You may use for example: pr[n_] := NumberForm[n, Infinity, ExponentFunction -> (Null &)] so that: pr[1.52522*10^7] (* 15252200. *)


12

As noted in post, responses and comments, Real is a Mathematica head and, as such, is distinct from Integer and Rational and Complex. All of these are regarded as "atomic" (notwitstanding that Rational has two Integer "parts", and Complex is comprised of any mix of the other three types). These atomic types are in a sense distinct from the domains one ...


11

I have faced this problem earlier but failed attempts with simple operations based on NumberForm, Round.. have forced me to stop looking for general solution. I have thought my skills in MMA were too low, but also today I am not able to do this in simple way. (haven't I learned anything? :)) This form of expression uncertainty in measurement is described ...


11

Here's a more general variant a(↑...↑)b with any given number of up-arrows, as defined on MathWorld: (* Short-hand for single arrow. *) UpArrow[a_, b_] := UpArrow[1][a, b]; (* Trivial case of a(↑...↑)1. *) UpArrow[_][a_, 1] := a; (* Single arrow: exponentation. *) UpArrow[1][a_, b_] := a^b; (* Generic case: do a recursion. *) UpArrow[n_Integer][a_, ...


11

Not as clean as J.M.'s method but this seems to give the same result: 0.1 ~RealDigits~ 2 ~FromDigits~ 2 3602879701896397/36028797018963968 Follow with Numerator and Denominator if needed.


11

Use the Resource Function ResourceFunction["RepeatingDecimalToRational"][0.3, 1] (* 1/3 *)


10

There is a tolerance Internal`$EqualTolerance that is applied when testing Real numbers. If the numbers agree up to the last Internal`$EqualTolerance digits, then they are treated as equal. Try this: eps = 1.0; p = 0; Block[{Internal`$EqualTolerance = 0.}, While[(1.0 + eps) > 1.0, eps = eps/2.0; p += 1]; ] eps p eps*2 (* 1.11022*10^-16 53 2....


10

Already answered in the comments by DumpsterDoofus and Daniel Lichtblau, to summarize: Machine floating point numbers such as 0.2 are not always exactly representable in binary (no terminating expansion in base 2). Thus floating point arithmetic is susceptible to roundoff error and other accuracy problems. For example, the following are not exactly equal to ...


10

You can use SetPrecision to find a more precise result. r0 = 0.97646105481464028; r1 = Rationalize[r0] r2 = SetPrecision[r0, Infinity] 8795179285210031/9007199254740992 r2 - r0 0. If you increase the Precision of your input, you can get a rational number that is closer to 0.97646105481464028. Precision@r0 MachinePrecision r0 = 0....


10

That can easily be done by separating each number into digits and re-assembling them as Number {3097, 3097, 3097, 3097} // IntegerDigits // Flatten // FromDigits


9

PlusMinus[{x_, err_}] := Module[{errE = Last@MantissaExponent[err], xE = Last@MantissaExponent[x]}, Row[{"(", NumberForm[N@Round[x, 10^(errE - 1)]*10^(-xE + 1), {xE - errE + 1, xE - errE}], " \[PlusMinus] ", NumberForm[N@Round[err, 10^(errE - 1)]*10^(-xE + 1), {1, xE - errE}, ExponentFunction -> (Null &)], ")", " \[Times]...


9

However, the only method I've found that ensures numerically exact conversion is the manual one: delete the decimal point, and then divide by 10^z, where z is the number of digits to the right of the decimal. This does not produce an exact conversion because floating point numbers are represented in binary, not in decimal. I tried SetPrecision[a,Infinity]...


9

you can try this: integerQ[x_] := x == Round[x]


8

From FromDigits>>Details: For example: N@FromDigits[RealDigits[123.55555]] (* 123.556 *)


8

May be I'm overthinking this one. list = {0, 1, -2, 259}; f[x_, y_] := x + (2 Boole@NonNegative[x] - 1 ) y/10^IntegerLength[y]//N ; list /. {a_, b_, c_, d_} -> {f[a, b], f[c, d]} (* {0.1, -2.259} *)


8

As noted in the comments this behavior follows from the definition of FromDigits, though I only understood this myself within the last year or two when someone* used it to boost performance. Consider a symbolic example: sym = FromDigits[{a, b, c}] sym /. { a -> {a1, a2, a3, a4, a5}, b -> {b1, b2, b2, b4, b5}, c -> {c1, c2, c3, c4, ...


8

The documentation is misleading in this case. The wrapper NumberForm is not transparent to numerical calculation -- it stops it dead. This means you should only apply it to your final calculations when all the numerical work is done. So the following works. NumberForm[{n1, n2 - n1}, 3] {0.235, 0.766} If what you want is for all the numerical work in a ...


8

Original answer The reason for getting extra quotes is that these extra quotes are explicitly present in the box form of the expression generated by such functions as EngineeringForm, NumberForm etc.: ToBoxes@EngineeringForm[6.08717*10^6] TagBox[InterpretationBox[ RowBox[{"\"6.08717\"", "\[Times]", SuperscriptBox["10&...


8

The number entry form base^^digits is only valid for explicit [0-9] digits in the place of both base and digits. You cannot write literal b^^1001 and then attempt to replace b as b^^1001 does not parse to this input form. Likewise the number entry form m*^exp is only valid for explicit [0-9] digits in the place of both m and exp. The combination of these ...


8

Update This seems to do what you want a bit more simply than your own solution. f[{a_, b_}] := NumberForm[ SetAccuracy[a ± b, Accuracy @ SetPrecision[b, 2]], ExponentFunction -> (Null &) ] // ToString // Quiet Your test: f[{12.3456, 0.0123}] f[{12.3456, 0.123}] f[{129.3456, 1.23}] f[{-129.3456, 12.3}] f[{12.9999, 0.02}] f[{1, 100}] f[{-...


8

Rational is for exact numeric values, not symbolic expressions, i.e. its arguments must be integers. Rational[x,y] is syntactically valid input but no more meaningful than foo[x,y]. FindInstance[foo[x, y] =!= x/y, {x, y}, Integers] {{x -> 33, y -> 16}} FindInstance["meaningless" =!= x/y, {x, y}, Integers] gives the same output. Why values 33 and ...


Only top voted, non community-wiki answers of a minimum length are eligible