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:

This PR changes the function label_from_attrs() to wrap text differently if we think it's a LaTeX sequence. This prevents long LaTeX names from not being rendered properly.

I tried to identify if it's a latex code if the string starts with $ and if it has an even number of $ in it. But I'm open to suggestions. I also increased the number of allowed columns for latex code since it generally renders to fewer characters.

• [x] Closes #5681
• [x] Tests added
• [x] Passes pre-commit run --all-files
• [x] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [x] New functions/methods are listed in api.rst

CC: @dcherian @Illviljan

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.