Question

Let me explain it by a small example:

>>> x = np.array([[1,2], [3,4], [5,6], [7,8]])
>>> x
array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

I want to have a new array that has the form

array([[0, 0, 1, 2, 3, 4],
       [1, 2, 3, 4, 5, 6],
       [3, 4, 5, 6, 7, 8],
       [5, 6, 7, 8, 0, 0]])

Here, the context has the size +/-1, but I’d like to keep it variable.

What I’m doing so far is appending zeros to the original array:

>>> y = np.concatenate((np.zeros((1, 2)), x, np.zeros((1, 2))), axis=0)
>>> y
array([[ 0.,  0.],
       [ 1.,  2.],
       [ 3.,  4.],
       [ 5.,  6.],
       [ 7.,  8.],
       [ 0.,  0.]])

And putting the values into a new array by reading rows of the new size:

>>> z = np.empty((x.shape[0], x.shape[1]*3))
>>> for i in range(x.shape[0]): z[i] = y[i:i+3].flatten()

That kind of works, but I find it slow, ugly and unpythonic.
Can you think of a better way to do this rearrangement? Additional thumbsup for an in-place-ish solution 🙂

Answer 1

There is the option of using stride_tricks, but I will not say that this is the best answer, because while it is “the most efficient way”, that way is not always the best when considering readability and that it is playing with fire.

# We make it flat (and copy if necessary) to be on the safe side, and because
# it is more obvious this way with stride tricks (or my function below):
y = y.ravel()

# the new shape is (y.shape[0]//2-2, 6). When looking at the raveled y, the first
# dimension takes steps of 2 elements (so y.strides[0]*2) and the second is
# just the old one:
z = np.lib.stride_tricks.as_strided(y, shape=(y.shape[0]//2-2, 6),
                                       strides=(y.strides[0]*2, y.strides[0]))

Note that z here is only a view, so use z.copy() to avoid any unexpected things before editing it, otherwise in your example all 1s will change if you edit one of them. On the up side, if you mean this by “in-place”, you can now change elements in y and z will change too.

If you want to do more of this magic, maybe check out my rolling_window function from https://gist.github.com/3430219, which replaces the last line with:

# 6 values long window, but only every 2nd step on the original array:
z = rolling_window(y, 6, asteps=2)

Important: np.lib.stride_tricks.as_strided by itself is generally not safe and must be used with care as it can create segmentation faults.