issue_comments

here's the dask issue about np.percentile's missing axis parameter: dask/dask#2824

that would work if we would be working with variables, but Dataset.quantile does a lot more that I didn't want to copy.

We should issue a release soon though.

I agree

sorry, my mistake. I've been testing on master which has #3559 merged and thus works with dask arrays. Unless someone has a better idea, I'd suggest copying that approach for now: using apply_ufunc to apply np.nanpercentile. ~~Ideally, that would change the quantile call to~~ python percentiles = quantile(ds, q=percentile / 100, dim="time") ~~I'll try to write a working quantile function.~~ Edit: see below, with that you should be able to use python ds.quantile(...)

This ```python def quantile(self, q, dim=None, interpolation="linear", keep_attrs=None): from xarray.core.computation import apply_ufunc from xarray.core import utils

scalar = utils.is_scalar(q) 
q = np.atleast_1d(np.asarray(q, dtype=np.float64)) 
if dim is None: 
    dim = self.dims

if utils.is_scalar(dim): 
    dim = [dim]

def _wrapper(npa, **kwargs): 
    # move quantile axis to end. required for apply_ufunc 
    return np.moveaxis(np.nanpercentile(npa, **kwargs), 0, -1)

axis = np.arange(-1, -1 * len(dim) - 1, -1) 
result = apply_ufunc( 
    _wrapper, 
    self, 
    input_core_dims=[dim], 
    exclude_dims=set(dim), 
    output_core_dims=[["quantile"]], 
    output_dtypes=[np.float64], 
    output_sizes={"quantile": len(q)}, 
    dask="parallelized", 
    kwargs={"q": q * 100, "axis": axis, "interpolation": interpolation}, 
)

# for backward compatibility 
result = result.transpose("quantile", ...) 
if scalar: 
    result = result.squeeze("quantile") 
if keep_attrs: 
    result.attrs = self._attrs

return result

xr.Variable.quantile = quantile `` seems to makequantile` work, but it might be a bad idea to monkeypatch. Thoughts, @dcherian?

you should be able to just use quantile. I called compute to demonstrate it returns the same values as np.percentile, but you don't need it with quantile.

the reason for this is that the percentile implementation of dask arrays does not support axis. I think you can achieve the same thing by either using compute() (which is probably not desirable) or by using quantile: python In [13]: # Get the percentiles at each lat/lon: ...: ds = ds.compute() ...: percentiles = ds.reduce(np.percentile, q=percentile, dim='time') ...: quantiles = ds.quantile(q=percentile / 100, dim="time") ...: xr.testing.assert_identical(percentiles.drop_vars("height"), quantiles.drop_vars("quantile")) the only difference is that the unused coordinate height disappears and a quantile dimension is added.