470,644 Members | 1,202 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 470,644 developers. It's quick & easy.

Numeric/Numarray equivalent to zip ?

What's the fastest and most elegant equivalent of zip() in
Numeric/Numarray between two equally sized 1D arrays ? That is, how to
combine two (N,)-shaped arrays to one (N,2) (or (2,N)) shaped ? I
expect the fastest and the most elegant idiom to be identical, as it is
usually the case in this excellent library, but if not, both would be
useful to know. Thanks,

George

Jul 19 '05 #1
5 1398
George Sakkis wrote:
What's the fastest and most elegant equivalent of zip() in
Numeric/Numarray between two equally sized 1D arrays ? That is, how to
combine two (N,)-shaped arrays to one (N,2) (or (2,N)) shaped ? I
expect the fastest and the most elegant idiom to be identical, as it is
usually the case in this excellent library, but if not, both would be
useful to know. Thanks,


Look at combining concatenate(), reshape(), and transpose(). In Scipy, I
would use hstack() and vstack().

--
Robert Kern
rk***@ucsd.edu

"In the fields of hell where the grass grows high
Are the graves of dreams allowed to die."
-- Richard Harter

Jul 19 '05 #2
George Sakkis wrote:
What's the fastest and most elegant equivalent of zip() in
Numeric/Numarray between two equally sized 1D arrays ? That is, how to
combine two (N,)-shaped arrays to one (N,2) (or (2,N)) shaped ? I
expect the fastest and the most elegant idiom to be identical, as it is
usually the case in this excellent library, but if not, both would be
useful to know. Thanks,

import Numeric as nu
a = nu.array(range(3))
nu.array([a, a]) array([[0, 1, 2],
[0, 1, 2]]) nu.transpose(nu.array([a, a]))

array([[0, 0],
[1, 1],
[2, 2]])

Or am I missing something? As to speed, it seems to be the fastest to
write...

Peter

Jul 19 '05 #3
"Peter Otten" <__*******@web.de> wrote:
George Sakkis wrote:
What's the fastest and most elegant equivalent of zip() in
Numeric/Numarray between two equally sized 1D arrays ? That is, how to
combine two (N,)-shaped arrays to one (N,2) (or (2,N)) shaped ? I
expect the fastest and the most elegant idiom to be identical, as it is usually the case in this excellent library, but if not, both would be useful to know. Thanks,

import Numeric as nu
a = nu.array(range(3))
nu.array([a, a]) array([[0, 1, 2],
[0, 1, 2]]) nu.transpose(nu.array([a, a])) array([[0, 0],
[1, 1],
[2, 2]])

Or am I missing something? As to speed, it seems to be the fastest to
write...


Though not the fastest to execute; using concatenate instead of
initializing an array from a list [a,a] is more than 2,5 time faster in
my system (~4.6 vs 11.8 usec per loop according to timeit.py), and it's
not harder either. One difference is that the equivalent expression for
concatenate expects arrays of shape (1,len(a)) instead of 1D arrays os
shape (len(a),):
a = reshape(range(5), (1,5))
a array([ [0, 1, 2, 3, 4]]) concatenate((a,a))

array([[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]])
George

Jul 19 '05 #4
George Sakkis wrote:
Though not the fastest to execute; using concatenate instead of
initializing an array from a list [a,a] is more than 2,5 time faster in
my system (~4.6 vs 11.8 usec per loop according to timeit.py), and it's
not harder either.
That surprises me. I would expect essentially the same amount of
data-shuffling.
One difference is that the equivalent expression for
concatenate expects arrays of shape (1,len(a)) instead of 1D arrays os
shape (len(a),):


If you want to start out with 1D arrays, just reorder the operations:
a = array(range(5))
reshape(concatenate((a, a)), (2, 5)) array([[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]])


Peter
Jul 19 '05 #5
"Peter Otten" <__*******@web.de> wrote:
George Sakkis wrote:
Though not the fastest to execute; using concatenate instead of
initializing an array from a list [a,a] is more than 2,5 time faster in my system (~4.6 vs 11.8 usec per loop according to timeit.py), and it's not harder either.


That surprises me. I would expect essentially the same amount of
data-shuffling.


Here are some timing comparisons of four versions I tried. The first
three work on 1D arrays directly and the fourth on 2D row arrays (i.e.
shape (1,len(a))):

from Numeric import *

# 11.5 usec/loop
def ziparrays_1(*arrays):
return array(arrays)

# 8.1 usec/loop
def ziparrays_2(*arrays):
a = zeros((len(arrays),len(arrays[0])))
for i in xrange(len(arrays)):
a[i] = arrays[i]
return a

# 13.6 usec/loop
def ziparrays_3(*arrays):
return reshape(concatenate(arrays), (len(arrays),len(arrays[0])))

# 4.6 usec/loop
def ziparrays_4(*arrays):
return concatenate(arrays)
So if one has the choice, it's better to start with 2D arrays instead
of 1D. Comparing versions 3 and 4, it's surprising that reshape takes
twice as much as concatenate.

George

Jul 19 '05 #6

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

reply views Thread by Travis Oliphant | last post: by
1 post views Thread by proof | last post: by
10 posts views Thread by Bryan | last post: by
reply views Thread by robert | last post: by
5 posts views Thread by Erik Johnson | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.