Question

So i have a .wav file. from this i got the data:
as expected from a sound file it is in stereo so the data looks like

List 1 (Original List)

[ [1,2],
[2,3],
[4,9],
[1,5],
[1,7],
….]

Note: I just made up those numbers, however the point is it’s a nested list.
The problem here is I’m doing FFT on that and as such want to only use the average of the two channels so i want:

List 2 (Averaged)

[
[1.5],
[2.5],
[6.5],
[3],
[4],
….
]

so for that I did:

averaged_array =  [sum(x)/len(x) for x in original_list]

I assume len(x) is a constant time operation even though it will always be 2.

The problem here is that the length of the original list is >900,000 I believe. On my home computer I can average it in ~46 seconds. At the computer I have to use for the presentation it takes ~121 seconds. This is a sizeable increase and it frankly is bad to have to wait around while it runs. Is there anyway I can optimize this so the time it takes it reduced?

Note: I believe this is a double core computer so I cannot run this in parallel (I think?).
It is possible for me to ssh into a server (with a few i7’s running on it) which I’ve been given permission to use.. Would it be better if I somehow ssh’ed and did the calculations there? The original computer I’m using I believe is ~2 ghz but is an old dell model relative (the series from a few years ago). Additionally, McAfee and another process eat up ~50% of the processing as well and I have no rights to kill these.

If I do that:

• How would I do the calculations on this remote computer via SSH? (I’m using python 2.7 and would really prefer not to install any external libraries as this is not my computer but an organization computer)
• Would I be able to do the calculations in a sort of “order”? I thought that when doing things in parallel, you could not maintain order as it would be done as soon as a core is open to compute it. By order I mean: I want the list to maintain the average at the same index of the original list.
  Ex. [ [1,2], [3,4]] should give [ [2.5], [3.5]] not [ [3.5], [2.5]]

Answer 1

For this kind of tasks, you really want to use the de facto standard NumPy module. This module handles large arrays in an efficient way (it even does FFT for you, if this is what you need).

Here is how you can do your average:

>>> a = numpy.array([[1,2], [2,3], [4,9], [1,5], [1,7]])
>>> numpy.average(a, axis=-1)
array([ 1.5,  2.5,  6.5,  3. ,  4. ])

Performing the average on an array of 1 million pairs takes only 22 ms on my machine.

The FFT can then be done with the numpy.fft module.