Numpy ndarray subclass - forcing reshape in __array_finalize__

Question

I am having trouble with the following:

I would like to write an ndarray subclass and enforce shape (-1,3) for any new instance of this subclass, whichever way it comes about- explicit constructor, view casting or from template.

I've tried loads of things but none seem to work. I reckon I haven't fully grasped the underlying process. Any help is much appreciated!

import numpy as np

class test(np.ndarray):
def __new__(cls, *args, **kwargs):
    return np.ndarray.__new__(cls, *args, **kwargs)

def __array_finalize__(self, obj):

#        self.resize(-1,3)
#        self.reshape(-1,3)
#        self=self.reshape(-1,3)
        np.reshape(self,(-1,3))

a=np.array([1,2,3])
b=a.view(test)
c=test(a)
d=a.reshape(-1,3)
print '+++++++'
print a.shape,a
print '+++++++'
print b.shape,b
print '+++++++'
print c.shape,c
print '+++++++'
print d.shape,d

To clarify what I am trying to do:

I have vector fields which I want to treat generically as 3D, hence the (:,3) shape and (-1,3) shape resizing. I am looking for a pure object oriented solution to implement essentially a few additional methods to complement what already comes with NumPy.

For example, I’ve started writing some stuff purely with ndarrays, but the code would be much more readable if I could just write

normalizedVector = ndarray.view(my3DVectorClass).normalize()

rather than

normalizedVector = ndarray / ( sum(ndarray**2, axis=1)**0.5 )

My problems with the second:

I would like to be able to not have to worry about whether or not I am asking for the normalized version of a shape (3,) or (:,3) array.
I would like to be able to use pure linear algebra terminology inside the classes method implementations and not have to bother with indexing and error/dimension checking within method definitions

I guess you could argue to just work with instances of my3DVectorClass exclusively but I would then have to do the reverse view casting when using all of the SciPy machinery, since they expect ndarray if I'm not mistaken, which would make these parts of the code a little bloated.

If I might have my logic wrong somehow I am grateful for suggestions. I’m still very much on the learning curve for both OOP and SciPy/NumPy.

Thanks a lot already!

Markus

You need __array_wrap__, etc.

seberg
– seberg

2013-02-19 23:13:20 +00:00
Commented Feb 19, 2013 at 23:13 — seberg
– seberg, Commented Feb 19, 2013 at 23:13

Robert Kern · Accepted Answer · 2013-02-20 09:53:55Z

7

You should take a look at how the matrix class is implemented. It does similar tricks to maintain ndims=2.

However, I and many others consider such trickery more trouble than it is worth. The matrix class has caused a lot of problems in the past because it only partly acts like a normal ndarray. Consider writing functions instead. The code example you give above would be the most readable like so: normalizedVector = normalize(ndarray). Making more subclasses is not always the best design, even when using object-oriented style.

answered Feb 20, 2013 at 9:53

Robert Kern

13.5k3 gold badges37 silver badges32 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Markus Over a year ago

Hi Robert, indeed not what I was hoping to hear, but you're spot on. Functions were the straightforward solution in the end. Thanks for the advice!

Jaime · Accepted Answer · 2013-02-19 21:11:10Z

reshape will try to create a view of the data with the new shape, and if it can't it will create a copy of your data with the new shape. But the original object is left unchanged. To modify the shape in-place, you can do:

self.shape = (-1, 3)

For example:

>>> a = np.arange(9)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> np.reshape(a, (-1, 3)) # creates a view with the new shape
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> a # but the original object is unchanged
array([0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> a.shape = (-1, 3) # this modifies the original object
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

You have to be careful though, because if it cannot be reshaped without making a copy, it will raise an AttributeError:

>>> a = np.arange(36).reshape(6, 6).T
>>> b = np.reshape(a, (-1, 3)) # creates a copy of the data in a
>>> a.shape = (-1, 3) # tries to reshape in-place, and fails
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: incompatible shape for a non-contiguous array

Collectives™ on Stack Overflow

Numpy ndarray subclass - forcing reshape in __array_finalize__

2 Answers 2

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related