We will discuss a simple one here, not the more complicated Levin's
**u**-transform that Maple actually uses in its `evalf(Sum(...))`

construct. Note also that in the `share`

library, there is a whole
package of such sequence acceleration techniques. See `?share`

and `?share,trans`

for details.

If

then

is called the Césaro limit of . Note that it is a limit of
* average* values of . Many theoretical results are known
about this method (see Hardy's book * Divergent Series*, for
example), including the fact that it is * regular*. This means
that if converges in the ordinary sense, then the Césaro
limit converges to the same thing.

Weniger remarks that regularity is actually not what we really want, because it seems that regular methods won't speed convergence up very much; Levin's **u**-transform is not a regular method, for example. But
regularity is a nice theoretical property, anyway, and the example is
rather simple.

** Example**. If , then if **n** is even
and if **n** is odd. This means that

We can check that for the first few values of **n** and see that we have made no blunders (unless I have a typo up there).

Then the average value of up to **n** is

Clearly this tends to as , so the Césaro
limit of is . Incidentally,
this is what `evalf(Sum( (-1)^k, k=0..infinity))`

gets, so
the Levin's **u**-transform method agrees with the Césaro sum,
which is also the same (in this case) as putting **x=-1** in
.

Let us code this in Maple.

cesaro := proc( a::algebraic, n::name) local m,k, s, avg; s := sum( a, n=0..k); # Hardwired assumption avg := sum(s, k=0..m)/(m+1); limit( avg, m=infinity) end:

This works symbolically, and not numerically, but I think it is clear that we could do the same thing numerically, by computing , , and so on up to some predetermined number, and then computing the running averages and seeing if that settles down.

After defining this procedure, `cesaro((-1)^k, k)`

gives
as expected. More interestingly, `cesaro( sin(k*theta), k)`

gives .

Indeed the Fourier sine series for is exactly

(you can do the calculations yourself), but the series on the right does
* not* converge in the usual sense. By the way, `evalf(Sum)`

fails on this one, for numerical values of .

** Break for a stretch**

Fri Jan 30 13:19:12 EST 1998