issues

This is just a suggestion to improve the documentation on apply_ufunc. The way I see it, this is one of the most powerful functions that xarray has to offer but (IMHO) the documentation is really small and with only a few examples.

From personal experience, every time I have to use it I get confused and it takes me a long time to figure out what important keywords like input_core_dims and output_core_dims actually do. After talking to some colleagues of mine I found that they share the same opinion so it appears that I'm not the only one.

PS: I honestly still don't quite understand what most (if not all) of the keywords do, so I'm not the man for the job.

EDIT

An example of something that could be improved upon is this function taken from the documentation:

def mean(obj, dim): # note: apply always moves core dimensions to the end return apply_ufunc(np.mean, obj, input_core_dims=[[dim]], kwargs={'axis': -1})

It's really easy to understand, but if I want to use it with more than one axis it doesn't work:

a=xr.DataArray(np.random.randn(3,3,3), dims=("x", "y", "z")) def mean(obj, dims): # note: apply always moves core dimensions to the end return xr.apply_ufunc(np.mean, obj, input_core_dims=[dims], kwargs={'axis': -1}) mean(a, "x") # works mean(a, ("x", "y")) # returns ValueError: applied function returned data with unexpected number of dimensions: 2 vs 1, for dimensions ('z',)

And I have no idea how to make the second, more general example work.

What happened:

When I try to give a variable a long_name that's a complex latex expression and then plot that variable the expression doesn't get rendered by latex

What you expected to happen:

I expected the name to get rendered by latex

Minimal Complete Verifiable Example:

In the example below I'm plotting a variable with a complex long_name via xarray and then plotting it again (in a separate figure) using only matplotlib and manually setting xlabel(). The matplotlib-only version works fine (right), but the xarray version doesn't render (left).

```python import numpy as np from matplotlib import pyplot as plt import xarray as xr da = xr.DataArray(range(5), dims="x", coords = dict(x=range(5))) name = r"$Ra_s = \mathrm{mean}(\epsilon_k) / \mu M^2_\infty$" da.x.attrs = dict(long_name = name) da.plot()

plt.figure() plt.plot(range(5)) plt.xlabel(name) ```

Anything else we need to know?:

Environment:

Pardon me if I've missed something, but from the docs and the issues raised it doesn't seem like anyone has proposed to add a marker type in Dataset.plot.scatter. From the docs it seems that right now you can organize points using hue and marker size. It would be nice to add marker type to the mix, and I imagine that it wouldn't too hard.

The only issue I see is that there are a finite number of marker types by default, but that's no different from the finite number of colors in the default color wheel.

Thoughts?

I was wondering if there is interest in developing support for reading unformatted binary files into DataArrays/Datasets.

I have been using a couple of models for a while that output unformatted Fortran binary files that I have to read into DataArrays and Datasets. I have developed my own custom functions to do this and they work quite well for my purposes, but I was wondering is the community thinks this is something that would be useful for more people. I know the syntax could be a bit cumbersome, but I was thinking it could be implemented like

da = xr.DataArray.from_binary(filename, access="direct", dtype=np.float64, coords=coords, dims=dims,)

From there we could figure out the counts to read, etc. If there's interest in this feature we could discuss it and I'd be happy to implement.

Cheers

Basically I'm trying to swap the names and data (basically the underlying numpy array would be the same, but the coords would change) of two dimensions in my DataArray and I was looking for options that could do that.

So I thought swap_dims would be a good candidate for that given its description but it doesn't work. In fact, based on the docs, I have no idea how to use it and what it does. Based off of issues like this it seems I'm not alone.

Maybe it would be good to add example of usage of this function?

Hi, this is my first a feature request here. I've been using xarray for a while but it always comes somewhat short when I'm trying to do animations. It always ends up being a big hassle.

Is there a good way to provide some functionality to make animations easier? I really like the way xarray sets up the plots by default, but I always end up re-writing it when setting up an animation, which I always feel like is kind of a shame.

Cheers

I have witnessing a weird behavior with xarray. Here's a MWE

python import xarray as xr da=xr.DataArray(np.random.rand(5,5,5), dims=['x', 'y', 'z'], coords=dict(x=range(5), y=range(5), z=range(5))) da[...,1:]-da[...,:-1] I expected this work just as da.diff(dim='z'), but it always returns a zero-values DataArray.

Expected Output

``` <xarray.DataArray (x: 5, y: 5, z: 4)> array([[[-0.22148 , 0.246586, 0.043931, -0.37468 ], [-0.522721, -0.016258, -0.386125, 0.932965], [-0.227799, -0.140233, 0.400886, -0.130469], [-0.04763 , 0.656787, -0.597745, 0.212088], [ 0.089159, 0.376483, -0.712572, 0.397021]],

   [[ 0.161166, -0.387264,  0.052542,  0.477284],
    [ 0.30892 ,  0.426818, -0.370983,  0.059737],
    [ 0.429502, -0.395471,  0.238937,  0.360634],
    [ 0.702574, -0.150469,  0.300272, -0.483837],
    [ 0.419341,  0.317944, -0.089965, -0.102932]],

   [[ 0.371919, -0.140948,  0.583743, -0.827194],
    [-0.037487, -0.345201, -0.457696,  0.281395],
    [ 0.43892 ,  0.156371, -0.351781, -0.016645],
    [-0.542661,  0.51394 , -0.615431, -0.039449],
    [-0.439784, -0.153804,  0.314933, -0.539498]],

   [[-0.398652,  0.830793, -0.408786, -0.355191],
    [-0.757028, -0.017731,  0.086872, -0.182064],
    [ 0.174183, -0.075571,  0.604353, -0.347382],
    [-0.388407,  0.342358,  0.059482,  0.347141],
    [ 0.759616, -0.446468, -0.060504, -0.217946]],

   [[-0.283018, -0.078172,  0.276102, -0.236144],
    [-0.427625, -0.044339,  0.484844, -0.06352 ],
    [-0.073386,  0.336733,  0.429961, -0.839064],
    [ 0.256269, -0.586563, -0.076288, -0.220549],
    [ 0.320014, -0.633854, -0.026103,  0.333301]]])

Coordinates: * z (z) int64 1 2 3 4 * y (y) int64 0 1 2 3 4 * x (x) int64 0 1 2 3 4 ```

The output I'm getting is:

``` <xarray.DataArray (x: 5, y: 5, z: 3)>
array([[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],

   [[0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.]],

   [[0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.]],

   [[0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.]],

   [[0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.],                                                                                                                                                        
    [0., 0., 0.]]])

Coordinates:
* z (z) int64 1 2 3
* y (y) int64 0 1 2 3 4 * x (x) int64 0 1 2 3 4

```

Is there something I'm missing here or is this really the expected behavior?

Output of xr.show_versions()

This is based off of this question I posted in SO. Basically I have a huge 2D domain that is separated into a lot of smaller 2D domains (as DataArrays). I have been trying to find a way to combine them all into one huge DataArray based on their coordinates. Kind of like assembling a mosaic. Here's a MWE of one of my tries that didn't work:

```python a=xr.DataArray(np.random.rand(4,4)+0, dims=("x", "y"), coords=dict(x=range(4), y=range(4))) b=xr.DataArray(np.random.rand(4,4)+1, dims=("x", "y"), coords=dict(x=range(4,8), y=range(4))) c=xr.DataArray(np.random.rand(4,4)+2, dims=("x", "y"), coords=dict(x=range(4,8), y=range(4,8)))

d=xr.concat([a,b,c], dim="x") d.plot.imshow(x="x") ```

This is somewhat close to what I wanted, but since it only concatenates in one direction, the output is wrong. You can read the question I linked above for a more detail explanation with a figure.

At this point I'm thinking that what I want is not possible with what's currently implemented in xarray. So if indeed this is the case, I think this could be understood as a feature request, since I think this functionality would be very useful.