[Numpy-discussion] The power of strides - Combinations

Mario Moura moura.mario at gmail.com
Mon Dec 6 21:18:41 EST 2010


Hi Folks

Is it possible some example how deal with strides with combinations, let see:

>>> from numpy import *
>>> import itertools
>>> dt = dtype('i,i,i')
>>> a = fromiter(itertools.combinations(range(10),3), dtype=dt, count=-1)
>>> a
array([(0, 1, 2), (0, 1, 3), (0, 1, 4), (0, 1, 5), (0, 1, 6), (0, 1, 7),
       (0, 1, 8), (0, 1, 9), (0, 2, 3), (0, 2, 4), (0, 2, 5), (0, 2, 6),
       (0, 2, 7), (0, 2, 8), (0, 2, 9), (0, 3, 4), (0, 3, 5), (0, 3, 6),
       (0, 3, 7), (0, 3, 8), (0, 3, 9), (0, 4, 5), (0, 4, 6), (0, 4, 7),
       (0, 4, 8), (0, 4, 9), (0, 5, 6), (0, 5, 7), (0, 5, 8), (0, 5, 9),
       (0, 6, 7), (0, 6, 8), (0, 6, 9), (0, 7, 8), (0, 7, 9), (0, 8, 9),
       (1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 2, 6), (1, 2, 7), (1, 2, 8),
       (1, 2, 9), (1, 3, 4), (1, 3, 5), (1, 3, 6), (1, 3, 7), (1, 3, 8),
       (1, 3, 9), (1, 4, 5), (1, 4, 6), (1, 4, 7), (1, 4, 8), (1, 4, 9),
       (1, 5, 6), (1, 5, 7), (1, 5, 8), (1, 5, 9), (1, 6, 7), (1, 6, 8),
       (1, 6, 9), (1, 7, 8), (1, 7, 9), (1, 8, 9), (2, 3, 4), (2, 3, 5),
       (2, 3, 6), (2, 3, 7), (2, 3, 8), (2, 3, 9), (2, 4, 5), (2, 4, 6),
       (2, 4, 7), (2, 4, 8), (2, 4, 9), (2, 5, 6), (2, 5, 7), (2, 5, 8),
       (2, 5, 9), (2, 6, 7), (2, 6, 8), (2, 6, 9), (2, 7, 8), (2, 7, 9),
       (2, 8, 9), (3, 4, 5), (3, 4, 6), (3, 4, 7), (3, 4, 8), (3, 4, 9),
       (3, 5, 6), (3, 5, 7), (3, 5, 8), (3, 5, 9), (3, 6, 7), (3, 6, 8),
       (3, 6, 9), (3, 7, 8), (3, 7, 9), (3, 8, 9), (4, 5, 6), (4, 5, 7),
       (4, 5, 8), (4, 5, 9), (4, 6, 7), (4, 6, 8), (4, 6, 9), (4, 7, 8),
       (4, 7, 9), (4, 8, 9), (5, 6, 7), (5, 6, 8), (5, 6, 9), (5, 7, 8),
       (5, 7, 9), (5, 8, 9), (6, 7, 8), (6, 7, 9), (6, 8, 9), (7, 8, 9)],
      dtype=[('f0', '<i4'), ('f1', '<i4'), ('f2', '<i4')])
>>>

Many thanks Mr. Warren about this
((itertools.combinations(range(10),3), dtype=dt, count=-1))

But as you can see itertools.combinations are emitted in lexicographic
sort order but NOT with "power of" strides.

So what I see is every element in this array into one memory spot but
I would like to know if is possible, use "the power of strides"!

>>> x = a.reshape(120,1)
x = stride_tricks.as_strided(a,shape=(120,),strides=(4,4))

Should I use some sub-class like record array, scalar array?

So what I want is repetitive elements on same memory spot. I want save
memory in big arrays (main reason) and want go fast.

How can I deal with this in random arrays but with repetitive
elements? Is it possible have custom strides in subclass(that change
in dimension) ? How do this?

Best Regards

Mario



More information about the NumPy-Discussion mailing list