How can I find the cumulative sum of a vector without using the cumsum funtion or any loops

If I have [4 -2 6 1 2], how I find the cum sum of this vector without using the cumsum function or loops or any other functions. I method I am allowed to use is just simple vector operations (sum,diff,etc) functions.

[the cyclist]

I assume this is homework. People are happy to help, but you need to show some effort first.

[Image Analyst]

What's wrong with the totally obvious:

theSum = 4 + -2 + 6 + 1 + 2;

That is one way that works without loops or any functions. It meets all your stated requirements. Anything wrong with it?

http://www.mathworks.com/matlabcentral/answers/8626-how-do-i-get-help-on-homework-questions-on-matlab-answers

[Stephen23]

"It meets all your stated requirements"

All except for the "cumulative sum" part.

Answer 1

[Tim Berk]

I know this is your homework, but I thought it was a fun problem.

You can do this with matrix manipulations:

A = [4 -2 6 1 2]
B = tril(ones(length(A)))
C = A.*B
cum_sum = sum(C,2)

[Stephen23]

+1 nice and simple.

Answer 2

[Stephen23]

>> A = [4,-2,6,1,2];
>> sum(triu(A(:)*ones(1,numel(A))),1)
ans =
    4    2    8    9   11
>> cumsum(A)
ans =
    4    2    8    9   11

[Tim Berk]

I think that's the exact same as my suggestion.

[Stephen23]

"I think that's the exact same as my suggestion."

That is quite a strong claim - lets have a look. You use ones to generate a matrix (I used ones to create a vector), and then tril to get a lower triangular array of ones and zeros:

B =
 1   0   0   0   0
 1   1   0   0   0
 1   1   1   0   0
 1   1   1   1   0
 1   1   1   1   1

No such matrix occurs occur anywhere in my code (even as an intermediate variable). You then array-multiply (which I did not use) this using implicit array expansion (which I did not use) to generate this matrix (which I never get):

>> A.*B
ans =
   4  -0   0   0   0
   4  -2   0   0   0
   4  -2   6   0   0
   4  -2   6   1   0
   4  -2   6   1   2

If you actually look at my code the first step is to create a matrix filled with the values of A (something that never occurs in your answer), which I achieve using matrix multiplication (something that you did not use):

>> A(:)*ones(1,numel(A))
ans =
   4   4   4   4   4
  -2  -2  -2  -2  -2
   6   6   6   6   6
   1   1   1   1   1
   2   2   2   2   2

And then the second step is to get the triangular array from that matrix which already has all of the values in it (which you do not do). Basically I do the first two steps in the reverse order to your code.

And of course the matrix orientation is also different: did you notice that my intermediate matrix has a different orientation to yours? And why? You might like to look at the two matrices shown above, and how they are calculated (hint: different commands and different inputs). This is also why we had to sum over different dimensions, and get output vectors with different orientations.

Also note that my code fundamentally works with any size or orientation input array:

>> A = [4;-2;6;1;2];
>> sum(triu(A(:)*ones(1,numel(A))),1)
ans =
    4    2    8    9   11

whereas your code cannot handle this (try it).

So there we have it: a different sequence of commands, different intermediate variables, different orientations, different matrices passed to tril or triu (lets not mention that), different permitted inputs, different output orientation. The only common command I can find is ones. I cannot find one single identical intermediate variable, even taking into account any trivial transposing.

Can you please justify your claim that "that's the exact same as my suggestion" ? It is a very strong claim that someone has copied "exact" code without attribution.

[Tim Berk]

Sorry to offend you. You are right, yours works for any dimension and is therefore more useful. I got triggered by you submitting an answer that is very similar to mine with no further explanation why it would be better. I'm happy to have gotten that information now.

My version for any dimension would be

C = A(:).*B;
cum_sum = sum(C,1)

Which is a (small) difference and indeed not the exact same.

Correct me if I'm wrong but, aren't they the same in terms of matrix manipulations? As all these manipulations are linear we can reverse the order. Multiplying A by the triangular matrix of ones (my version) is no different from taking the triangular matrix of A multiplied by ones (your version).

I have to admit, in addition to working in any dimension, your solution is also faster.

A = rand(10000,1);
clearvars -except A
tic;
cum_sum = sum(triu(A(:)*ones(1,numel(A))),1); % yours
toc
clearvars -except A
tic;
cum_sum = sum(A(:).*tril(ones(length(A))),1); % mine
toc

[Stephen23]

"... with no further explanation why it would be better"

I certainly don't make any claim that my code is better. I leave that up to the OP to decide. One never knows what the OP really wants, needs, or has already. Your answer is perfectly fine, and I doubt that there is really any advantage in one over the other.

"...aren't they the same in terms of matrix manipulations?"

Even if operations can be performed in a different order from a mathematical perspective this does not necessarily mean that for numeric computations the same is true: for numeric computation order is significant, so in general your statement is not true because of the propagation of numeric error. Of course multiplying by ones and zeros this is unlikely to make any difference... in this case. Hopefully they give the same output.

"...your solution is also faster"

Perhaps the speed difference is due to matrix multiply being slightly faster than the implicit expansion, or generating a vector of ones vs. a matrix of ones, or numel being faster than length. Not much difference though, and it could easily change between MATLAB versions.

"My version for any dimension would be C = A(:).*B;"

Nope, this is wrong:

>> sum(A(:).*B,1)
ans =
   11    7    9    3    2

You would also need to transpose B to get the right answer:

>> sum(A(:).*B.',1)
ans =
    4    2    8    9   11

[Tim Berk]

"You would also need to transpose B to get the right answer:"

That's right. Or using triu instead of tril.

Since you seem to be interested in small details: technically your code does not work for "any size or orientation array". It only gives the right answer for row vectors, as the answer is always a row vector. If you input a column vector, the answer is the transpose of the actual cumsum. If you input a 2D array the answer is a row vector that has nothing to do with the cumsum of that array.

The cumulative sum of

A = [1 2; 3 4]

Should be

[1 2; 4 6]

or

[1 3; 3 7]

depending on which dimension we are taking the cumulative sum over. Neither of our methods gives such an answer.

[Stephen23]

@Tim Berk: Good catch, you are right, I was wrong that my code works with "any size ... input array".

Answer 3

[Andrei Bobrov]

sum(hankel([zeros(numel(A)-1,1);A(1)],A))

Answer 4

[the cyclist]

Perhaps the only solution which will not raise the eyebrows of OP's instructor:

A = [4 -2 6 1 2];

nA = numel(A);

cumA = zeros(1,nA);

for ia = 1:nA
    cumA(ia) = sum(A(1:ia));
end

:-)

[Tim Berk]

Depends on whether it is a course on matlab or on vector calculus.

In any case, a for loop might not be a good idea for large nA. If I were to instruct a course on matlab, I would prefer students to work with the fastest solution.

[the cyclist]

The for loop is fast for moderately large nA. In fact, it is the fastest of the three solutions that I tried (in admittedly little testing on my part). For very large nA, there might also be memory issues for some solutions.

rng default
N = 5000;
NR = 100;
A = rand(1,N);

tic
for ii = 1:NR
nA = numel(A);
cumA1 = zeros(1,nA);
for ia = 1:nA
    cumA1(ia) = sum(A(1:ia));
end
end
toc

tic
for ii = 1:NR
B = tril(ones(length(A)));
C = A.*B;
cumA2 = sum(C,2);
end
toc

tic
for ii = 1:NR
cumA3 = sum(triu(A(:)*ones(1,numel(A))),1);
end
toc