Mathematica Stack Exchange is a question and answer site for users of Mathematica. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

I want to write recursive function for calculating the arithmetic mean of a vector.

For $X(n)=\{1,2,3,\ldots, n\}$, the formula is ${\rm Mean}(X(n))=((n-1)\, {\rm Mean}((X(n-1))+X_n)/n$.

My program works in my R-language version, but here in Mathematica it takes in account only the last two number. How can I fix my code?

Meen[x_] := (
   If[Length[x] == 1, 
     n = Length[x] - 1; 
     y = x[[1 ;; n]]; 
     result = 1/(n + 1)*(n*Meen[x[[1 ;; n]]]  + x[[n + 1]])]

X = {1, 2, 3, 4, 5};
share|improve this question

Here is another way to do it. It is a tail-recursive formulation, so you don't have to worry about exceeding $RecursionLimit.

mean[{}, k___, m_: 0] := m
mean[{most___, last_}, k_: 0, m_: 0] := mean[{most}, k + 1, (k m + last)/(k + 1)]


SeedRandom[42]; nums = RandomReal[100., 3000];
Mean[nums], mean[nums]}
{50.1012, 50.1012}
share|improve this answer

The problem with your code is, that n is a global variable and changes in each recursion step. This influences calculations on a higher recursion level. To avoid that you need to create a local variable n at each recursion step. You can do this by using for example Module or Block. Leaving your code pretty much untouched the result is:

Meen[x_] := 
  If[Length[x] == 1, Return[x],(*If condition is TRUE*)
   n = Length[x] - 1;
   result = 1/(n + 1)*(n*Meen[x[[1 ;; n]]] + x[[n + 1]])]]
share|improve this answer

Here is a straightforward way based on the formula you provided:

    mean[{x_}] := x;
    mean[{x_, y___}] := Block[{$RecursionLimit = Infinity}, 
                              (Length[{y}] * mean[{y}] + x)/ Length[{x, y}]]


mean[{a, b, c, d}]


1/4 (a + b + c + d)

using nums as defined by m_goldberg

mean[nums] == Mean[nums]


share|improve this answer

I accept that there are a number of reasons to define this function recursively, including desire to get intermediate results. Mathematica's Mean is very efficient (I appreciate this is likely not the intent). This recursive approach becomes very very slow for data size 1000000. A "recursive" approach (using the method):

mn[u_] := Module[
  list = Thread[{u, Range[Length[u]]}];
  First@Fold[((#2[[2]] - 1) #1 + #2)/#2[[2]] &, First@list, Rest@list]]

OnRandomReal[1,1000000] takes 5.9 seconds...compared with 0. for Mean... I hve tried some of the other methods and my machine hungs up but do not take my word for it.

share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

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