Question

Edit: I’ve found what the problem boils down to:

If you run this code:

A = ones((10,4))
view = A[:,1]
view.fill(7)
A

or

A = ones((10,4))
view = A[:,1:3]
view.fill(7)
A

You’ll see that the columns of A change

If you run this:

A = ones((10,4))
view = A[:,(1,2)]
view.fill(7)
A

There’s no side effects on A. Is this behavior on purpose or a bug?

I have a function that calculates the amount I have to rotate certain columns of x,y points in a matrix. The function only takes one input – a matrix mat:

def rotate(mat):

In the function, I create views to make working with each section easier:

rot_mat = mat[:,(col,col+1)]

Then, I calculate a rotation angle and apply it back on the view that I had created before:

rot_mat[row,0] = cos(rot)*x - sin(rot)*y
rot_mat[row,1] = sin(rot)*x + cos(rot)*y

If I perform this in the main body of my program, the changes to my rot_mat view would propagate to the original matrix mat. When I turned it into a function, the views stopped having side effects on the original matrix. What’s the reasoning for this and is there any way to get around it? I should also note that it isn’t changing mat within the function itself. At the end, I just try to return mat but no changes have been made.

Full code for function:

def rotate(mat):
    # Get a reference shape
    ref_sh = 2*random.choice(range(len(filelist)))
    print 'Reference shape is '
    print (ref_sh/2)
    # Create a copy of the reference point matrix
    ref_mat = mat.take([ref_sh,ref_sh+1],axis=1)
    # Calculate rotation for each set of points
    for col in range(len(filelist)):
        col = col * 2 # Account for the two point columns
        rot_mat = mat[:,(col,col+1)]
        # Numerator = sum of wi*yi - zi*xi
        numer = inner(ref_mat[:,0],rot_mat[:,1]) - inner(ref_mat[:,1],rot_mat[:,0])
        # Denominator = sum of wi*xi + zi*yi
        denom = inner(ref_mat[:,0],rot_mat[:,0]) + inner(ref_mat[:,1],rot_mat[:,1])
        rot = arctan(numer/denom)
        # Rotate the points in rot_mat.  As it's a view of mat, the effects are
        # propagated.
        for row in range(num_points):
            x = rot_mat[row,0]
            y = rot_mat[row,1]
            rot_mat[row,0] = cos(rot)*x - sin(rot)*y
            rot_mat[row,1] = sin(rot)*x + cos(rot)*y
    return mat

Answer 1

When you do view = A[:,(1,2)] you are using advanced indexing (Numpy manual: Advanced Indexing), which means that the array returns a copy, not a view. It’s advanced because your indexing object is a tuple “containing at least one sequence” (the sequence being the tuple (1,2)). The total explicit selection object obj in your case would equal (slice(None), (1,2)), i.e. A[(slice(None), (1,2))] returns the same thing as A[:,(1,2)].

As larsmans suggests above, it seems that __getitem__ and __setitem__ behave differently for advanced indexing, which makes sense, because assigning values to a copy would have no use (the copy would not be stored).