Ok, then it is clearly a bottleneck/numpy issue. I will raise it there and close it here.

Thanks!

It's just a simple numpy.ndarray.transpose: python In [1]: import numpy as np ...: import bottleneck as bn ...: ...: n_time = 1 ...: spec_data = np.random.random(size=(n_time,192,121)) ...: ...: bn.nanmax(spec_data.transpose(0, 2, 1)) Segmentation fault numpy.transpose returns a view, so I guess that's what causes bottleneck to segfault? Not sure, though, especially since changing the order does not trigger the segfault: spec_data.transpose(1, 0, 2)... maybe bottleneck doesn't like views with a first dimension of size 1?

I can reproduce it with calling bn.nanmax directly, but I can not reproduce it without the xarray.transpose() function.

• If I call nanmax on the internal data of xarray then nanmax fails with a segfault:

python np_data = xdata['Spec name'].data bn.nanmax(np_data) # Segfault - But if I create a copy of that data and then call nanmax then it works fine.

python np_data = xdata['Spec name'].data new_data = np_data.copy() bn.nanmax(new_data) # works

I suspect that the xarray.transpose function does something with the data-structure (lazy reshuffling of dimensions?) that triggers the fault in bottleneck.

Full code:

```python from collections import OrderedDict import numpy as np import xarray as xr

xr.show_versions()

n_time = 1 # 1 : Fails, 2 : everything is fine

from xarray.core.options import OPTIONS OPTIONS["use_bottleneck"] = True # Set to False for work-around

Build some dataset

dirs = np.linspace(0,360, num=121) freqs = np.linspace(0,4,num=192) spec_data = np.random.random(size=(n_time,192,121))

dims = ('time', 'freq', 'dir') coords = OrderedDict() coords['time'] = range(n_time) coords['freq'] = freqs coords['dir'] = dirs

xdata = xr.DataArray( data=spec_data, coords=coords, dims=dims, name='Spec name', ).to_dataset()

xdata = xdata.transpose(..., "freq")

import bottleneck as bn np_data = xdata['Spec name'].data

new_data = np_data.copy() bn.nanmax(new_data) # works

bn.nanmax(np_data) # Segfault print('direct bn call done') ```

Thanks for the detail @RubendeBruin . I'm guessing this a bottleneck issue — would you be up for trying to run bottleneck's nanmax function on the underlying numpy array (xdata.data), and seeing whether that has the same effect?

tests on another machine (also win64) with the same result.

Running under WSL/Ubuntu results in a Segmentation Fault