I'm working on a Mathematica lab for Calc. 2, and I ran into a problem last night. I was trying to calculate the midpoint approximation of the definite integral of Cos[x] from 0 to 2. Here's what I came up with:

Clear[a, b, n, f] 

f[x_] = Cos[x]

a := 0; b := 2; n := 578

N[((b - a)/n)*Sum[f[a + (i - (1/2))*((b - a)/n)], {i, 1, n}]]


This is fine, but if I try to use NSum instead of N[...Sum[...]] then this happens:

Clear[a, b, n]

a := 0; b := 2; n := 578

((b - a)/n)*NSum[f[a + (i - (1/2))*((b - a)/n)], {i, 1, n}]

During evaluation of In[35]:= SequenceLimit::seqlim: The general form of the sequence could not be determined, and the result may be incorrect. >>

During evaluation of In[35]:= SequenceLimit::seqlim: The general form of the sequence could not be determined, and the result may be incorrect. >>


According to the documentation, Sum evaluates the given sum (http://reference.wolfram.com/mathematica/ref/Sum.html), and the N function gives the numerical value of the parameter (http://reference.wolfram.com/mathematica/ref/N.html). Also, NSum should give the numerical approximation of the sum. To my understanding, N[Sum[...]] Should be the same as NSum[...], or am I missing something?

It's not a huge deal as far as typing more, but I'd just like to know why it doesn't work as expected. I've read online that NSum apparently tries to work out part of the sum symbolically, but even if it does I don't see how it could be THAT much different from the real answer.

  • $\begingroup$ Its probably roundoff errors... ((b - a)/n)*Sum[f[a + (i - (1/2))*((b - a)/n)], {i, 1, n}] // N works. $\endgroup$
    – chris
    Mar 25, 2013 at 19:35
  • $\begingroup$ Yes, that does work. That's the same as the first code block that I posted above, but I just don't understand how they could be that much different. The second block above seems to work where n < 159 . Once n gets any bigger you get those warnings and the values get sporadic. $\endgroup$ Mar 25, 2013 at 19:47
  • $\begingroup$ ok then this works: ((b - a)/n)* NSum[f[a + (i - (1/2))*((b - a)/n)], {i, 1, n}, NSumTerms -> 1000] $\endgroup$
    – chris
    Mar 25, 2013 at 19:58
  • 2
    $\begingroup$ You're missing the fact that N[Sum[...]] computes the sum exactly and then converts it to floating point output, whereas NSum[...] attempts, through various numerical mechanisms, to approximate the sum (and might not even actually calculate all the terms in the sum in doing so). As the help notes, it can be fooled and needs judicious application of appropriate options to work well. It sounds like you are attempting to use NSum[...] where you really want something like Total@N@Table[...], especially if you're experimenting with Riemann integration. $\endgroup$
    – whuber
    Mar 25, 2013 at 20:09
  • $\begingroup$ as @whuber said, you probably want to use Total@Table[]. $\endgroup$
    – acl
    Mar 25, 2013 at 21:28

1 Answer 1


The crucial point is that N@Sum is not NSum.

What N@Sum is

N@Sum will first try to evaluate the sum symbolically and then approximate it numerically. Only if Sum cannot perform the first task, and then returns (at least partially) unevaluated, N will resort to using NSum. In case of a finite sum, Sum will always return an evaluated result, consisting possibly of a sum (Plus) of all the terms.

In this example you can see the first situation described: the sum is simplified to \[Pi]^2/6 and then N approximates it:

N@Sum[1/n^2, {n, 1, \[Infinity]}] // Trace

In the following example instead, Sum is not able to find an explicit formula, and in the trace you can see that N is called with the unchanged sum as the argument:

N@Sum[Log[n]/(1 + n^2), {n, 1, \[Infinity]}] // Trace

You can even check that NSum is called by blocking it (I thank L. B. Shifrin for the inspiration):

  Hold@Evaluate@N@Sum[Log[n]/(1 + n^2), {n, 1, \[Infinity]}]

What NSum is

As the Documentation Center clearly states, NSum tries to approximate the result by various summation methods (listed under More Information).

The guide also states that:

You should realize that with sufficiently pathological summands, the algorithms used by NSum can give wrong answers. In most cases, you can test the answer by looking at its sensitivity to changes in the setting of options for NSum.

To get a better sense of this distinction, I think it's useful to check the evaluation


This code shows you at which points f is called:

f[x_] := (Sow[x, "f"]; Cos[x])
a = 0; b = 2; n = 578;
Reap[NSum[f[a + (i - (1/2))*((b - a)/n)], {i, 1, n},
          EvaluationMonitor :> (Sow[i, "i"])],
     {"f", "i"}][[2]];
Print["f[] has been called at: ", %[[1, 1]]]
ListPlot[%%[[2, 1]], PlotRange -> All, PlotLabel -> "Evaluation points"]

As you can see, f has been called 8 times and NSum performed 39 evaluation cycles. This clearly indicates that not all 578 points have been taken in consideration.

On the other hand, if you write

f[x_] := (Sow[x, "f"]; Cos[x])
a = 0; b = 2; n = 578;
Reap[Sum[N@f[a + (i - (1/2))*((b - a)/n)], {i, 1, n}], "f"][[2, 1]] // Short
% // Length

you can see that a long list of exactly 578 evaluation is generated.


What you really need to do is

Sum[N@f[a + (i - (1/2))*((b - a)/n)], {i, 1, n}]
  • 1
    $\begingroup$ That makes a lot of sense. Thank you! Great, detailed answer. $\endgroup$ Mar 25, 2013 at 21:44
  • $\begingroup$ @Caleb1994 This question mathematica.stackexchange.com/questions/17028/… is closely related to your problem. $\endgroup$
    – Artes
    Mar 25, 2013 at 22:06
  • $\begingroup$ Very nice analysis! (+1) $\endgroup$
    – whuber
    Mar 25, 2013 at 22:28
  • 2
    $\begingroup$ @whuber One should however be careful not to overstate the differences between Sum and NSum. According to the documentation for Sum (under "Properties"): Applying N to an unevaluated sum effectively uses NSum $\endgroup$
    – Jens
    Mar 28, 2013 at 3:16

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.