WorkingPrecision
is an option for various numerical operations that specifies how many digits of precision should be maintained in internal computations.
Details
- WorkingPrecision is an option for such functions as NIntegrate and FindRoot.
- Setting WorkingPrecision->n causes all internal computations to be done to at most n‐digit precision.
- Setting WorkingPrecision->MachinePrecision causes all internal computations to be done with machine numbers.
- Even if internal computations are done to n‐digit precision, the final results you get may have much lower precision.
Examples
open all close allBasic Examples (2)
Find a root using 60-digit precision arithmetic:
FindRoot[x ^ 2 - 2, {x, 1}, WorkingPrecision -> 60]Solve a differential equation using 24-digit precision arithmetic:
NDSolve[{x''[t] + x[t] / (1 + t ^ 2) == 0, x[0] == 1, x'[0] == 0}, x, {t, 0, 50}, WorkingPrecision -> 24]Plot[First[x[t] /. %], {t, 0, 50}]Scope (4)
Evaluate the function using 24-digit precision arithmetic:
f[x_ ? NumberQ] := x ^ 2 / 2 + Cos[x] - 1Plot[f[x], {x, -0.0001, 0.0001}, WorkingPrecision -> 24]Without higher precision you see mainly numerical roundoff error:
Plot[f[x], {x, -0.0001, 0.0001}]Approximate an integral using 24-digit precision arithmetic:
NIntegrate[1 / Sqrt[Sin[x]], {x, 0, 1}, WorkingPrecision -> 24]The PrecisionGoal is automatically increased to be 10 less than the working precision:
NIntegrate[1 / Sqrt[Sin[x]], {x, 0, 1}, WorkingPrecision -> 24, PrecisionGoal -> 14]Find a minimum of a function, adaptively increasing the precision up to 50 digits:
FindMinimum[Cos[x ^ 2 + y ^ 2] + Sin[x ^ 2 y], {{x, 1.}, {y, 1.}}, WorkingPrecision -> 50]The PrecisionGoal and AccuracyGoal are automatically set to be half the final precision:
FindMinimum[Cos[x ^ 2 + y ^ 2] + Sin[x ^ 2 y], {{x, 1.}, {y, 1.}}, WorkingPrecision -> 50, PrecisionGoal -> 25, AccuracyGoal -> 25]Solve a differential equation with 32-digit precision arithmetic:
sol = NDSolve[{x''[t] + x[t] == 0, x[0] == 1, x'[0] == 0}, x, {t, 0, 10}, WorkingPrecision -> 32];The PrecisionGoal and AccuracyGoal are set to be half of the working precision:
sap = NDSolve[{x''[t] + x[t] == 0, x[0] == 1, x'[0] == 0}, x, {t, 0, 10}, WorkingPrecision -> 32, PrecisionGoal -> 16, AccuracyGoal -> 16];Plot[Evaluate[{First[x[t] /. sol], First[x[t] /. sap]} - Cos[t]], {t, 0, 10}, WorkingPrecision -> 24]Using InterpolationOrder->All will reduce the errors between steps:
sall = NDSolve[{x''[t] + x[t] == 0, x[0] == 1, x'[0] == 0}, x, {t, 0, 10}, WorkingPrecision -> 32, InterpolationOrder -> All];
Plot[Evaluate[First[x[t] /. sall] - Cos[t]], {t, 0, 10}, WorkingPrecision -> 24]Applications (1)
Check the quality of a solution to Duffing's equation by using a sequence of solution precisions:
deqn = Block[{γ = 15 / 100, ϵ = 3 / 10, ω = 1}, {x''[t] + γ x'[t] - x[t] + x[t] ^ 3 == ϵ Cos[ω t], x[0] == 1, x'[0] == 0}];smp = First[x /. NDSolve[deqn, x, {t, 0, 100}, Method -> {"Extrapolation", "StiffnessTest" -> False}]]Plot[smp[t], {t, 0, 100}]Make a sequence of solutions at successively higher working precision:
sols = Table[First[x /. NDSolve[deqn, x, {t, 0, 100}, Method -> {"Extrapolation", "StiffnessTest" -> False}, WorkingPrecision -> wp]], {wp, 18, 36, 3}];A plot shows that some of the solutions deviate toward the end:
Plot[Evaluate[Map[#[t]&, sols]], {t, 80, 100}]Plot the solution x[100] as a function of working precision:
s100 = Map[#[100]&, sols];
ListPlot[s100, DataRange -> {18, 36}]Convergence to the solution at the highest precision indicates about 6 digits can be trusted:
best = s100[[-1]];ListPlot[Log[10, Abs[Drop[s100, -1] - best]], DataRange -> {18, 33}]Possible Issues (2)
Low-precision parameters in functions may invalidate the use of higher-precision arithmetic:
two = Total[ConstantArray[.00001, 200000]]sqrt2 = FindRoot[x ^ 2 - two, {x, 1}, WorkingPrecision -> 100]
The result is a poor approximation to 
:
Sqrt[2] - x /. %Use of exact parameters allows comparison at different precisions:
etwo = SetPrecision[two, Infinity]Table[{wp, Sqrt[etwo] - x /. FindRoot[x ^ 2 - etwo, {x, 1}, WorkingPrecision -> wp]}, {wp, 20, 100, 10}]Expect solution times to increase exponentially as a function of working precision:
deqn = Block[{γ = 15 / 100, ϵ = 3 / 10, ω = 1}, {x''[t] + γ x'[t] - x[t] + x[t] ^ 3 == ϵ Cos[ω t], x[0] == 1, x'[0] == 0}];times = Table[{wp, First[Timing[First[x /. NDSolve[deqn, x, {t, 0, 100}, WorkingPrecision -> wp, Method -> "StiffnessSwitching"]]]]}, {wp, Join[{MachinePrecision}, Range[20, 160, 10]]}];
TableForm[times, TableHeadings -> {{}, {"Precision", "Timing"}}]A log plot of the computation time as a function of working precision:
ListLogPlot[times]Text
Wolfram Research (1988), WorkingPrecision, Wolfram Language function, https://reference.wolfram.com/language/ref/WorkingPrecision.html (updated 2003).
CMS
Wolfram Language. 1988. "WorkingPrecision." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2003. https://reference.wolfram.com/language/ref/WorkingPrecision.html.
APA
Wolfram Language. (1988). WorkingPrecision. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/WorkingPrecision.html