In-place operations about sparse HOT 4 CLOSED

cc @mrocklin @nils-werner Your thoughts would be welcome here.

from sparse.

The docs say about inplace modification of immutable vs mutable types:

x += y is equivalent to x = operator.iadd(x, y)

and

For immutable targets such as strings, numbers, and tuples, the updated value is computed, but not assigned back to the input variable:

from operator import iadd

a = 'hello'                 # hello
iadd(a, ' world')           # hello world
a                           # hello

For mutable targets such as lists and dictionaries, the inplace method will perform the update, so no subsequent assignment is necessary:

s = list('hello')           # hello
iadd(s, list(' world'))     # hello world
s                           # hello world

To me, that sounds like solution 1. would be acceptable behaviour.

Another solution that comes to mind would be to keep self as it is and only replace shape, coords and data.

from sparse.

Another solution that comes to mind would be to keep self as it is and only replace shape, coords and data.

coords and data I agree on. shape, I'm not so sure about. Take the following simple example using Numpy (they don't support assigning when the shape isn't broadcastable to the output shape):

>>> import numpy as np
>>> x = np.zeros((1, 5))
>>> y = np.ones((5, 5))
>>> x += y
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: non-broadcastable output operand with shape (1,5) doesn't match the broadcast shape (5,5)

from sparse.

Option 1 seems fine with me with a couple of small comments:

1. We should continue to fail when we would have failed before, like in x += 1 (because this would densify)
2. We might consider operating genuinely in place when it's convenient. This is often the case when operating with scalars like x *= 2 or x /= 2

from sparse.