Skip to content

Accumulate

Status: Stable

documented, exercised by the test suite and/or worked examples, with no known limitations recorded.

Description

Accumulate[list]

gives a list of the successive accumulated totals of elements in list. The result has the same length as list.

Accumulate[list] is effectively equivalent to FoldList[Plus, list].

Accumulate[list, Method -> "CompensatedSummation"] uses Kahan

Notes Accumulate works with integers, arbitrary-precision bignums, machine doubles, and symbolic expressions, and threads naturally over rows (so for a matrix it accumulates within columns). The head of the input is preserved: Accumulate\[{a, b, c, d}\] -\> {a, a + b, a + b + c, a + b + c + d} Accumulate\[f\[a, b, c, d\]\] -\> f\[a, a + b, a + b + c, a + b + c + d\] compensated summation to reduce numerical error when every element of list is a machine number. For symbolic or mixed input the option is ignored and the standard symbolic accumulation is returned. Accumulate has the attribute Protected.

Examples (9)

Every input below was run against the current Mathilda build and its output recorded.

Basic examples (4)

In[1]:= Accumulate[{a, b, c, d}]
Out[1]= {a, a + b, a + b + c, a + b + c + d}

In[2]:= Accumulate[{{a, b}, {c, d}, {e, f}}]
Out[2]= {{a, b}, {a + c, b + d}, {a + c + e, b + d + f}}

In[3]:= Accumulate[f[a, b, c, d]]
Out[3]= f[a, a + b, a + b + c, a + b + c + d]

In[4]:= Accumulate[{1, 2, 3, 4, 5}]
Out[4]= {1, 3, 6, 10, 15}

Options (1)

In[5]:= Accumulate[{1.0, 2.0, 3.0}, Method -> "CompensatedSummation"]
Out[5]= {1.0, 3.0, 6.0}

Applications (4)

In[6]:= Accumulate[{1, 2, 3, 4, 5}]
Out[6]= {1, 3, 6, 10, 15}

In[7]:= Accumulate[{a, b, c, d}]
Out[7]= {a, a + b, a + b + c, a + b + c + d}

In[8]:= Accumulate[Table[1/k, {k, 1, 5}]]
Out[8]= {1, 3/2, 11/6, 25/12, 137/60}

In[9]:= Accumulate[{{1, 2}, {3, 4}, {5, 6}}]
Out[9]= {{1, 2}, {4, 6}, {9, 12}}

Implementation notes

builtin_accumulate returns the list of cumulative sums (prefix sums), keeping the input expression's head. The default path folds running = Plus[running, elem] left to right via the evaluator, so it works on any addable elements (integers, rationals, symbolics, matrix rows). When the optional Method -> "CompensatedSummation" is supplied and every element is a machine number, it instead runs Kahan compensated summation in double precision (tracking a running correction term c), emitting Real partial sums. An empty list returns a copy unchanged.

  • Protected.
  • Accumulate[list] has the same length as list, and is effectively equivalent to FoldList[Plus, list].
  • The head of the input is preserved, so Accumulate[f[a, b, c]] returns f[a, a + b, a + b + c].
  • Threads naturally over rows via Listable Plus, so Accumulate of a matrix accumulates within columns.
  • Works on machine integers, GMP arbitrary-precision integers, machine-precision doubles, and symbolic expressions.
  • With Method -> "CompensatedSummation", Kahan compensated summation is used in double precision when every element is a machine number, reducing floating-point round-off error. For symbolic or mixed input the option is silently ignored and the standard symbolic accumulation is returned.

Attributes: Protected.

References

See also: Plus

Notes & additional examples

Notes

Accumulate[list] gives the running (prefix) sums, equivalent to FoldList[Plus, list], and the result has the same length as the input. It works on exact rationals — Accumulate[Table[1/k, {k, 1, 5}]] returns the partial sums of the harmonic series — as well as symbolic terms. For a matrix (a list of rows), accumulation is performed row-wise, so column totals build up down the matrix. The head of the input is preserved.