Return to Answer

Consider any numerical integration method $I^*(f,a,b)$ that approximates the exact integral $I$ of a function $f$ over an interval $[a,b]$. It will be implemented by a computation represented by, say, I[f[x], {x, a, b}]. Conceiving an NIntegrate[] command in this way breaks the error into two independent components. The first is the error of the method $I^* - I$, where $I^* = I^*(f,a,b)$ is assumed to be computed exactly; this error is often called the "truncation error." The second is the difference between $I^*$ and I[f[x], {x, a, b}]; this error is usually thought of as "rounding error."

The error estimator of an NIntegrate[] method endeavors to yield an upper bound on the truncation error. The options PrecisionGoal and AccuracyGoal set the goal for this bound. The error estimate is often done by comparing the method with a less accurate method, e.g. in the "GaussKronrodRule" and the "ClenshawCurtisRule". For a well-behaved function, using either of these rules, the error can be greatly overestimated, as noted in this answer.

The option WorkingPrecision, which controls the Precision[] and Accuracy[] of the result, is used to control rounding error. (It also affects the default PrecisionGoal, which affects the bound on the truncation error discussed above and which @ilian also notes in his answer.) Precision@arb16 and Accuracy@arb16 reflect this rounding error. Normally this, too, is an upper bound.** So Precision[] has little to do with the truncation error in approximating the integral.

The general approach in numerical analysis has tended to focus on bounding error. Mathematica's error estimators and arbitrary-precision numerics follow this approach. I don't believe there is a way to get a better estimate of the error, without knowing the exact value of the integral or computing it to a higher precision. (One could perhaps use a rule with a good error estimator; the approach in the rule chebRule in the linked answer above does somewhat better on a function that is analytic on {0, 1} than "GaussKronrodRule", but the OP's function has a singularity at 1.)

**Technical note: The precision-tracking rules used to keep track of the precision of a computation are based on linear approximation of the error. They do not produce an upper bound in themselves but aim to be accurate. However, Mathematica keeps extra guard bits in the internal representation of arbitrary-precision numbers, so that the actual internal number computed usually has a rounding error of much less magnitude than the Precision[] and Accuracy[].

Consider any numerical integration method $I^*(f,a,b)$ that approximates the exact integral $I$ of a function $f$ over an interval $[a,b]$. It will be implemented by a computation represented by, say, I[f[x], {x, a, b}]. Conceiving an NIntegrate[] command in this way breaks the error into two independent components. The first is the error of the method $I^* - I$, where $I^* = I^*(f,a,b)$ is assumed to be computed exactly; this error is often called the "truncation error." The second is the difference between $I^*$ and I[f[x], {x, a, b}]; this error is usually thought of as "rounding error."

The error estimator of an NIntegrate[] method endeavors to yield an upper bound on the truncation error. The options PrecisionGoal and AccuracyGoal set the goal for this bound. The error estimate is often done by comparing the method with a less accurate method, e.g. in the "GaussKronrodRule" and the "ClenshawCurtisRule". For a well-behaved function, using either of these rules, the error can be greatly overestimated, as noted in this answer.

The option WorkingPrecision, which controls the Precision[] and Accuracy[] of the result, is used to control rounding error. (It also affects the default PrecisionGoal, which affects the bound on the truncation error discussed above and which @ilian also notes in his answer.) Precision@arb16 and Accuracy@arb16 reflect this rounding error. Normally this, too, is an upper bound.** So Precision[] has little to do with the truncation error in approximating the integral.

The general approach in numerical analysis has tended to focus on bounding error. Mathematica's error estimators and arbitrary-precision numerics follow this approach. I don't believe there is a way to get a better estimate of the error, without knowing the exact value of the integral or computing it to a higher precision. (One could perhaps use a rule with a good error estimator; the approach in the rule chebRule in the linked answer above does somewhat better on a function that is analytic on {0, 1} than "GaussKronrodRule", but the OP's function has a singularity at 1.)

**Technical note: The precision-tracking rules used to keep track of the precision of a computation are based on linear approximation of the error. They do not produce an upper bound in themselves but aim to be accurate. However, Mathematica keeps extra guard bits in the internal representation of arbitrary-precision numbers, so that the actual internal number computed usually has a rounding error of much less magnitude than the Precision[] and Accuracy[].

Consider any numerical integration method $I^*(f,a,b)$ that approximates the exact integral $I$ of a function $f$ over an interval $[a,b]$. It will be implemented by a computation represented by, say, I[f[x], {x, a, b}]. Conceiving an NIntegrate[] command in this way breaks the error into two independent components. The first is the error of the method $I^* - I$, where $I^* = I^*(f,a,b)$ is assumed to be computed exactly; this error is often called the "truncation error." The second is the difference between $I^*$ and I[f[x], {x, a, b}]; this error is usually thought of as "rounding error."

The error estimator of an NIntegrate[] method endeavors to yield an upper bound on the truncation error. The options PrecisionGoal and AccuracyGoal set the goal for this bound. The error estimate is often done by comparing the method with a less accurate method, e.g. in the "GaussKronrodRule" and the "ClenshawCurtisRule". For a well-behaved function, with one of these two rules, the error can be greatly overestimated, as noted in this answer.

The option WorkingPrecision, which controls the Precision[] and Accuracy[] of the result, is used to control rounding error. (It also affects the default PrecisionGoal, which affects the bound on the truncation error discussed above and which @ilian also notes in his answer.) Precision@arb16 and Accuracy@arb16 reflect this rounding error. Normally this, too, is an upper bound. So Precision[] has little to do with the truncation error in approximating the integral.

The general approach in numerical analysis has tended to focus on bounding error. Mathematica's error estimators and arbitrary-precision numerics follow this approach. I don't believe there is a way to get a better estimate of the error, without knowing the exact value of the integral or computing it to a higher precision. (One could perhaps use a rule with a good error estimator; the approach in the rule chebRule in the linked answer above does somewhat better on a function that is analytic on {0, 1} than "GaussKronrodRule", but the OP's function has a singularity at 1.)

Consider any numerical integration method $I^*(f,a,b)$ that approximates the exact integral $I$ of a function $f$ over an interval $[a,b]$. It will be implemented by a computation represented by, say, I[f[x], {x, a, b}]. Conceiving an NIntegrate[] command in this way breaks the error into two independent components. The first is the error of the method $I^* - I$, where $I^* = I^*(f,a,b)$ is assumed to be computed exactly; this error is often called the "truncation error." The second is the difference between $I^*$ and I[f[x], {x, a, b}]; this error is usually thought of as "rounding error."

The error estimator of an NIntegrate[] method endeavors to yield an upper bound on the truncation error. The options PrecisionGoal and AccuracyGoal set the goal for this bound. The error estimate is often done by comparing the method with a less accurate method, e.g. in the "GaussKronrodRule" and the "ClenshawCurtisRule". For a well-behaved function, using either of these rules, the error can be greatly overestimated, as noted in this answer.

The option WorkingPrecision, which controls the Precision[] and Accuracy[] of the result, is used to control rounding error. (It also affects the default PrecisionGoal, which affects the bound on the truncation error discussed above and which @ilian also notes in his answer.) Precision@arb16 and Accuracy@arb16 reflect this rounding error. Normally this, too, is an upper bound.** So Precision[] has little to do with the truncation error in approximating the integral.

The general approach in numerical analysis has tended to focus on bounding error. Mathematica's error estimators and arbitrary-precision numerics follow this approach. I don't believe there is a way to get a better estimate of the error, without knowing the exact value of the integral or computing it to a higher precision. (One could perhaps use a rule with a good error estimator; the approach in the rule chebRule in the linked answer above does somewhat better on a function that is analytic on {0, 1} than "GaussKronrodRule", but the OP's function has a singularity at 1.)

**Technical note: The precision-tracking rules used to keep track of the precision of a computation are based on linear approximation of the error. They do not produce an upper bound in themselves but aim to be accurate. However, Mathematica keeps extra guard bits in the internal representation of arbitrary-precision numbers, so that the actual internal number computed usually has a rounding error of much less magnitude than the Precision[] and Accuracy[].

Consider any numerical integration method $I^*(f,a,b)$ that approximates the exact integral $I$ of a function $f$ over an interval $[a,b]$. It will be implemented by a computation represented by, say, I[f[x], {x, a, b}]. Conceiving an NIntegrate[] command in this way breaks the error into two independent components. The first is the error of the method $I^* - I$, where $I^* = I^*(f,a,b)$ is assumed to be computed exactly; this error is often called the "truncation error." The second is the difference between $I^*$ and I[f[x], {x, a, b}]; this error is usually thought of as "rounding error."

The error estimator of an NIntegrate[] method endeavors to yield an upper bound on the truncation error. This is often done by comparing the method with a less accurate method, e.g. in the "GaussKronrodRule" or the "ClenshawCurtisRule". For a well-behaved function and one of these two rules, the error can be greatly overestimated, as noted in this answer.

The option WorkingPrecision, which controls the Precision[] and Accuracy[] of the result, is used to control rounding error. Precision@arb16 and Accuracy@arb16 reflect this rounding error. Normally this, too, is an upper bound. So Precision[] has little to do with the truncation error of the estimate of the integral.

The general approach in numerical analysis has tended to focus on bounding error. Mathematica's error estimators and arbitrary-precision numerics follow this approach. I don't believe there is a way to get a better estimate of the error, without knowing the exact value. (Although, perhaps one could use a rule with a good error estimator; the approach in the rule chebRule in the linked answer above does somewhat better on a function that is analytic on {0, 1} than "GaussKronrodRule", but the OP's function has a singularity at 1.)

Consider any numerical integration method $I^*(f,a,b)$ that approximates the exact integral $I$ of a function $f$ over an interval $[a,b]$. It will be implemented by a computation represented by, say, I[f[x], {x, a, b}]. Conceiving an NIntegrate[] command in this way breaks the error into two independent components. The first is the error of the method $I^* - I$, where $I^* = I^*(f,a,b)$ is assumed to be computed exactly; this error is often called the "truncation error." The second is the difference between $I^*$ and I[f[x], {x, a, b}]; this error is usually thought of as "rounding error."

The error estimator of an NIntegrate[] method endeavors to yield an upper bound on the truncation error. The options PrecisionGoal and AccuracyGoal set the goal for this bound. The error estimate is often done by comparing the method with a less accurate method, e.g. in the "GaussKronrodRule" and the "ClenshawCurtisRule". For a well-behaved function, with one of these two rules, the error can be greatly overestimated, as noted in this answer.

The option WorkingPrecision, which controls the Precision[] and Accuracy[] of the result, is used to control rounding error. (It also affects the default PrecisionGoal, which affects the bound on the truncation error discussed above and which @ilian also notes in his answer.) Precision@arb16 and Accuracy@arb16 reflect this rounding error. Normally this, too, is an upper bound. So Precision[] has little to do with the truncation error in approximating the integral.

The general approach in numerical analysis has tended to focus on bounding error. Mathematica's error estimators and arbitrary-precision numerics follow this approach. I don't believe there is a way to get a better estimate of the error, without knowing the exact value of the integral or computing it to a higher precision. (One could perhaps use a rule with a good error estimator; the approach in the rule chebRule in the linked answer above does somewhat better on a function that is analytic on {0, 1} than "GaussKronrodRule", but the OP's function has a singularity at 1.)