issue_comments

I moved the docs around and added a note on multi-dimensional indexing.

Oh, wow -- I didn't even realize that worked in pandas! Combined with NA-skipping aggregation functions in pandas that makes expressions like a[a < 0].mean() work just like the same expression in NumPy.

So instead of adding where, perhaps we should just support boolean indexing like pandas.

The main difference is that where can cleanly support broadcasting, whereas we currently don't do broadcasting in indexing. For example, suppose a is a 2-dimensional DataArray with dimensions (x, y). Now considering the following cases: 1. a[x > 0] 2. a[y > 0] 3. a[x > 0, y > 0] 4. a[(x > 0) & (y > 0)]

Currently, (1) and (3) work by selection. If we adopt the pandas behavior, (4) would also work, but by broadcasting and masking. This seems like a potential recipe for confusion, because once you have (4), case (2) seems like a natural variation. We could implement (2), but should it mask or select?

My sense is that we'll probably be happier if we have entirely distinct APIs for masking (.where) and selection ([] and .loc[]).

Both R and pandas allow the user to do a[a < 0] and a[a < 0] = 0. So what I'm wondering is why not extend xray's indexing to also work on arrays that are the same shape and have the same labels as the original array?

The problem is that a[a < 0] in NumPy flattens arrays with more than one dimension. We can't do this in xray without doing something like pointwise indexing to flatten out the labels, too.

Right now, you can do that by chaining two operations: a.where(a > 0).fillna(0). It would definitely be better to support it in one (a.where(a > 0, 0)).

I suppose we could also support a[a < 0] = 0, but it seems a little strange given that we don't support a[a < 0].

@clarkfitzg Yes, that's mostly right. The main differences: 1. The order of the arguments here is different, to match the pandas methods (which has more of a SQL flavor to it). 2. I'm not exposing the third argument, because xray objects don't yet implement broadcasting operations with more than 2 arguments at once. This is something that needs refactoring -- the logic in _binary_op should be generalized to any number of arguments.