Finding cumulative sum and then average the values in R

Question

I want to compute cumulative sum for the first (n-1) columns(if we have n columns matrix) and subsequently average the values. I created a sample matrix to do this task. I have the following matrix

ma = matrix(c(1:10), nrow = 2, ncol = 5)
ma
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    3    5    7    9
[2,]    2    4    6    8   10

I wanted to find the following

ans = matrix(c(1,2,2,3,3,4,4,5), nrow = 2, ncol = 4)
ans
     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4
[2,]    2    3    4    5

The following are my r function.

ColCumSumsAve <- function(y){
  for(i in seq_len(dim(y)[2]-1)) {
    y[,i] <- cumsum(y[,i])/i
  }
}
ColCumSumsAve(ma)

However, when I run the above function its not producing any output. Are there any mistakes in the code?

Thanks.

Answer 1

There were several mistakes.

Solution

This is what I tested and what works:

colCumSumAve <- function(m) {
  csum <- t(apply(X=m, MARGIN=1, FUN=cumsum))
  res <- t(Reduce(`/`, list(t(csum), 1:ncol(m))))
  res[, 1:(ncol(m)-1)]
}

Test it with:

> colCumSumAve(ma)
     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4
[2,]    2    3    4    5

which is correct.

Explanation:

colCumSumAve <- function(m) {
  csum <- t(apply(X=m, MARGIN=1, FUN=cumsum)) # calculate row-wise colsum
  res <- t(Reduce(`/`, list(t(csum), 1:ncol(m))))
  # This is the trickiest part.
  # Because `csum` is a matrix, the matrix will be treated like a vector 
  # when `Reduce`-ing using `/` with a vector `1:ncol(m)`.
  # To get quasi-row-wise treatment, I change orientation
  # of the matrix by `t()`. 
  # However, the output, the output will be in this transformed
  # orientation as a consequence. So I re-transform by applying `t()`
  # on the entire result at the end - to get again the original
  # input matrix orientation.
  # `Reduce` using `/` here by sequencial list of the `t(csum)` and
  # `1:ncol(m)` finally, has as effect `/`-ing `csum` values by their
  # corresponding column position.
  res[, 1:(ncol(m)-1)] # removes last column for the answer.
  # this, of course could be done right at the beginning,
  # saving calculation of values in the last column,
  # but this calculation actually is not the speed-limiting or speed-down-slowing step
  # of these calculations (since this is sth vectorized)
  # rather the `apply` and `Reduce` will be rather speed-limiting.
}

Well, okay, I could do then:

colCumSumAve <- function(m) {
  csum <- t(apply(X=m[, 1:(ncol(m)-1)], MARGIN=1, FUN=cumsum))
  t(Reduce(`/`, list(t(csum), 1:ncol(m))))
}

or:

colCumSumAve <- function(m) {
  m <- m[, 1:(ncol(m)-1)] # remove last column
  csum <- t(apply(X=m, MARGIN=1, FUN=cumsum))
  t(Reduce(`/`, list(t(csum), 1:ncol(m))))
}

This is actually the more optimized solution, then.

Original Function

Your original function makes only assignments in the for-loop and doesn't return anything. So I copied first your input into a res, processed it with your for-loop and then returned res.

ColCumSumsAve <- function(y){
  res <- y
  for(i in seq_len(dim(y)[2]-1)) {
    res[,i] <- cumsum(y[,i])/i
  }
  res
}

However, this gives:

> ColCumSumsAve(ma)
     [,1] [,2]     [,3] [,4] [,5]
[1,]    1  1.5 1.666667 1.75    9
[2,]    3  3.5 3.666667 3.75   10

The problem is that the cumsum in matrices is calculated in column-direction instead row-wise, since it treats the matrix like a vector (which goes columnwise through the matrix).

Corrected Original Function

After some frickeling, I realized, the correct solution is:

ColCumSumsAve <- function(y){
  res <- matrix(NA, nrow(y), ncol(y)-1) 
  # create empty matrix with the dimensions of y minus last column
  for (i in 1:(nrow(y))) {           # go through rows
    for (j in 1:(ncol(y)-1)) {       # go through columns
      res[i, j] <- sum(y[i, 1:j])/j  # for each position do this
    }
  }
  res   # return `res`ult by calling it at the end!
}

with the testing:

> ColCumSumsAve(ma)
     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4
[2,]    2    3    4    5

Note: dim(y)[2] is ncol(y) - and dim(y)[1] is nrow(y) - and instead seq_len(), 1: is shorter and I guess even slightly faster.

Note: My solution given first will be faster, since it uses apply, vectorized cumsum and Reduce. - for-loops in R are slower.

Late Note: Not so sure that the first solution is faster. Since R-3.x it seems that for loops are faster. Reduce will be the speed limiting funtion and can be sometimes incredibly slow.

Answer 2

Here's how I did it

> t(apply(ma, 1, function(x) cumsum(x) / 1:length(x)))[,-NCOL(ma)]
     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4
[2,]    2    3    4    5

This applies the cumsum function row-wise to the matrix ma and then divides by the correct length to get the average (cumsum(x) and 1:length(x) will have the same length). Then simply transpose with t and remove the last column with [,-NCOL(ma)].

The reason why there is no output from your function is because you aren't returning anything. You should end the function with return(y) or simply y as Marius suggested. Regardless, your function doesn't seem to give you the correct response anyway.

Answer 3

All you need is rowMeans:

nc <- 4
cbind(ma[,1],sapply(2:nc,function(x) rowMeans(ma[,1:x])))
     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4
[2,]    2    3    4    5

Answer 4

k <- t(apply(ma,1,cumsum))[,-ncol(k)]
for (i in 1:ncol(k)){
  k[,i] <- k[,i]/i
}
k

This should work.