issues

Implements most of https://github.com/pydata/xarray/issues/4325#issuecomment-716399575 ``` python %load_ext memory_profiler

import numpy as np import xarray as xr

temp = xr.DataArray(np.zeros((5000, 500)), dims=("x", "y"))

roll = temp.rolling(x=10, y=20)

%memit roll.sum() %memit roll.reduce(np.sum) %memit roll.reduce(np.nansum) # master branch behaviour peak memory: 245.18 MiB, increment: 81.92 MiB peak memory: 226.09 MiB, increment: 62.69 MiB peak memory: 4493.82 MiB, increment: 4330.43 MiB `` - [x] xref #4325 - [x] asv benchmarks added - [x] Passespre-commit run --all-files- [x] User visible changes (including notable bug fixes) are documented inwhats-new.rst`

• [x] Closes #4373
• [x] Tests added
• [x] Passes isort . && black . && mypy . && flake8
• [x] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [x] New functions/methods are listed in api.rst

I could use some help with adding tests and parameter checking if someone wants to help :)

``` python import numpy as np import xarray as xr

ds = xr.Dataset() ds.coords["x"] = ("x", np.arange(10)) ds.coords["y"] = ("y", np.arange(20)) ds.coords["t"] = ("t", np.arange(4)) ds["u"] = np.sin((ds.x - 5) / 5) * np.sin((ds.y - 10) / 10) ds["v"] = np.sin((ds.x - 5) / 5) * np.cos((ds.y - 10) / 10)

ds = ds * 2*np.cos((ds.t) * 2 * 3.14 /0.75)

ds["u"].attrs["units"] = "m/s" ds["mag"] = np.hypot(ds.u, ds.v)

ds.mag.plot(col="t", x="x")

fg = ds.plot.quiver(x="x", y="y", u="u", v="v", col="t", hue="mag") ```

I think it would be nice to add a quiver plot function. I got this far in my current project:

``` python @xarray.plot.dataset_plot._dsplot def quiver(ds, x, y, ax, u, v, **kwargs): from xarray import broadcast

if x is None or y is None or u is None or v is None:
    raise ValueError("Must specify x, y, u, v for quiver plots.")

# matplotlib autoscaling algorithm
scale = kwargs.pop("scale", None)
if scale is None:
    npts = ds.dims[x] * ds.dims[y]
    # crude auto-scaling
    # scale is typical arrow length as a multiple of the arrow width
    scale = (
        1.8 * ds.to_array().median().values * np.maximum(10, np.sqrt(npts))
    )  # / span

ds = ds.squeeze()
x, y, u, v = broadcast(ds[x], ds[y], ds[u], ds[v])

# no support for these kwargs right now.
kwargs.pop("cmap_params")
kwargs.pop("hue")
kwargs.pop("hue_style")
hdl = ax.quiver(x.values, y.values, u.values, v.values, scale=scale, **kwargs)

return hdl

```

The autoscaling logic is quite crude; I tried to copy what matplotlib does but got somewhat confused. To get faceting to work properly, we'll need to estimate scale around here: https://github.com/pydata/xarray/blob/a36d0a1d4657c848dcdd76d0ecb9c783ad464057/xarray/plot/facetgrid.py#L339-L343