FWIW the bn.push example still has some unanswered questions - would be interested to know if there's an easier way of doing that. Particularly if it's just a 'dim for axis' swap

Congrats!

Gave this a quick spin for filling. A few questions:

• Is there an easy of way of merely translating dims into axes? Maybe that already exists?
• Is there as easy way to keep a dimension? Or should it be in the signature and a new_dim?

```python da=xr.DataArray(np.random.rand(10,3), dims=('x','y')) da = da.where(da>0.5) In [43]: da Out[43]: <xarray.DataArray (x: 10, y: 3)> array([[ nan, 0.57243305, 0.84363016], [ nan, 0.90788156, nan], [ nan, 0.50739189, 0.93701278], [ nan, nan, 0.86804167], [ nan, 0.50883914, nan], [ nan, nan, nan], [ nan, 0.91547763, nan], [ 0.72920182, nan, 0.6982745 ], [ 0.73033449, 0.950719 , 0.73077113], [ nan, nan, 0.72463932]])

In [44]: xr.apply(bn.push, da) . # already better than bn.push(da)! Out[44]: <xarray.DataArray (x: 10, y: 3)> array([[ nan, 0.57243305, 0.84363016], [ nan, 0.90788156, 0.90788156], [ nan, 0.50739189, 0.93701278], [ nan, nan, 0.86804167], [ nan, 0.50883914, 0.50883914], [ nan, nan, nan], [ nan, 0.91547763, 0.91547763], [ 0.72920182, 0.72920182, 0.6982745 ], [ 0.73033449, 0.950719 , 0.73077113], [ nan, nan, 0.72463932]])

but changing the axis is verbose and transposes the array - are there existing tools for this?

In [48]: xr.apply(bn.push, da, signature='(x)->(x)', new_coords=[dict(x=da.x)]) Out[48]: <xarray.DataArray (y: 3, x: 10)> array([[ nan, nan, nan, nan, nan, nan, nan, 0.72920182, 0.73033449, 0.73033449], [ 0.57243305, 0.90788156, 0.50739189, 0.50739189, 0.50883914, 0.50883914, 0.91547763, 0.91547763, 0.950719 , 0.950719 ], [ 0.84363016, 0.84363016, 0.93701278, 0.86804167, 0.86804167, 0.86804167, 0.86804167, 0.6982745 , 0.73077113, 0.72463932]]) Coordinates: * x (x) int64 0 1 2 3 4 5 6 7 8 9 o y (y) - ```

• The triple nested signature is pretty tough to write! Two kwargs?

Either way, the first step is probably to write a function backfill(values, axis) that acts on NumPy arrays.

Right. Surprisingly, I can't actually find something like this out there. The pandas code is good but highly 1-2 dimension specific.

Let me know if I'm missing (pun intended - long day) something. Is there a library of these sorts of functions over n-dims somewhere else (even R / Julia)? Or are we really the first people in the world to be doing this?

I'm thinking through how difficult it would be to add back-fill method to DataArray (that could be an argument to fillna or a bfill method - that's a separate discussion).

Would this PR help? I'm trying to wrap my head around the options. Thanks

Would it be possible to write something like np.einsum with xarray named dimensions?

I think it's possible, by supplying the dimensions to sum over, and broadcasting the others. Similar to the inner_product example, but taking *dims rather than dims. Is that right?

Thanks for thinking through these

This suggests maybe ds[bool_array] -> da.where(bool_array, drop=True).

I think that makes sense. drop=False would be too confusing

Maybe something like: left_join(da, inner_join(bool_array, other))?

The way I was thinking about it: both other and bool_array need a value for every value in da. So they both need to be subsets. So something like:

``` python assert set(other.dims) =< set(da.dims) assert set(bool_array.dims) =< set(da.dims)

other, _ = xr.broadcast(other, da) bool_array, _ = xr.broadcast(bool_array, da)

da.where(bool_array, other) ```

Is that consistent with the joins you were thinking of?

When this is done & we can do where, I wonder whether

python da[bool_array] = 5

...could be sugar for...

python da.where(bool_array, 5)

i.e. do we get multidimensional indexing for free?

This looks awesome! Would simplify a lot of the existing op stuff!