current community

your communities

more stack exchange communities

Stack Exchange
tour help
careers 2.0
Take the 2-minute tour ×
Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no registration required.
up vote 10 down vote favorite
1

My question is about a specific array operation that I want to express using numpy.

I have an array of floats w and an array of indices idx of the same length as w and I want to sum up all w with the same idx value and collect them in an array v. As a loop, this looks like this:

for i, x in enumerate(w):
     v[idx[i]] += x

Is there a way to do this with array operations? My guess was v[idx] += w but that does not work, since idx contains the same index multiple times.

Thanks!

share|improve this question
    
And atomic really is an inappropriate description for what you want to do. –  Constantinius Mar 20 '12 at 16:06
    
How would you describe it? Hope new title is better. –  Andreas Mueller Mar 20 '12 at 16:08
1  
@Constantinius, He accepted an answer for all but one of the questions he asked, which had one response which, while good, did not address his actual problem. Perhaps you should work on not drawing attention to the game aspect of this site. –  Mike Graham Mar 20 '12 at 16:12
    
I like the new description, much better. Atomic is often referred to in context of multi-threaded programming, so the question title was misleading. –  Constantinius Mar 20 '12 at 16:12
    
@MikeGraham I accepted some good answers as response to his comment. –  Andreas Mueller Mar 20 '12 at 16:13
show 4 more comments

2 Answers

up vote 14 down vote accepted

numpy.bincount was introduced for this purpose:

tmp = np.bincount(idx, w)
v[:len(tmp)] += tmp

I think as of 1.6 you can also pass a minlength to bincount.

share|improve this answer
    
I was aware of bincount but I didn'know it could handle weights! awesome :) –  Andreas Mueller Mar 20 '12 at 16:32
    
cool, almost forget this tiny little elf. –  nye17 Mar 20 '12 at 16:36
    
Please feel free to feel as my hero for the rest of the day :) –  Andreas Mueller Mar 20 '12 at 16:37
add comment
up vote 4 down vote

This is a known behavior and, though somewhat unfortunate, does not have a numpy-level workaround. (bincount can be used for this if you twist its arm.) Doing the loop yourself is really your best bet.

Note that your code might have been a bit more clear without re-using the name w and without introducing another set of indices, like

for i, w_thing in zip(idx, w):
    v[i] += w_thing

If you need to speed up this loop, you might have to drop down to C. Cython makes this relatively easy.

share|improve this answer
    
Simpler still: for i in idx: v[i] += w[i]. –  larsmans Mar 20 '12 at 16:23
1  
Or the excellent scipy.weave.inline. –  katrielalex Mar 20 '12 at 16:24
    
Without indices this should work, right? The code you posted simply does v + w, right? (If v is longer than w only the first len(w) elements are used. Reusing w was an pretty bad typo, sorry. –  Andreas Mueller Mar 20 '12 at 16:24
    
@AndreasMueller, Sorry, I had a typo. –  Mike Graham Mar 20 '12 at 16:26
    
@larsmans, There was a typo in my code snippet which I have fixed. That code does not do the same thing as OP's code. –  Mike Graham Mar 20 '12 at 16:26
show 1 more comment

Your Answer

 
discard

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.