def test_weighted_mean_no_nan(weights, expected):
da = DataArray([1, 2])
weights = DataArray(weights)
expected = DataArray(expected)
result = da.weighted(weights).mean()
assert_equal(expected, result)
def test_interpolate_kwargs():
da = xr.DataArray(np.array([4, 5, np.nan], dtype=np.float64), dims="x")
expected = xr.DataArray(np.array([4, 5, 6], dtype=np.float64), dims="x")
actual = da.interpolate_na(dim="x", fill_value="extrapolate")
assert_equal(actual, expected)
expected = xr.DataArray(np.array([4, 5, -999], dtype=np.float64), dims="x")
actual = da.interpolate_na(dim="x", fill_value=-999)
assert_equal(actual, expected)
def test_weighted_mean_bool():
# https://github.com/pydata/xarray/issues/4074
da = DataArray([1, 1])
weights = DataArray([True, True])
expected = DataArray(1)
result = da.weighted(weights).mean()
assert_equal(expected, result)
def test_interpolate_kwargs():
da = xr.DataArray(np.array([4, 5, np.nan], dtype=np.float64), dims='x')
expected = xr.DataArray(np.array([4, 5, 6], dtype=np.float64), dims='x')
actual = da.interpolate_na(dim='x', fill_value='extrapolate')
assert_equal(actual, expected)
expected = xr.DataArray(np.array([4, 5, -999], dtype=np.float64), dims='x')
actual = da.interpolate_na(dim='x', fill_value=-999)
assert_equal(actual, expected)
def test_weighted_std_nan(weights, expected):
da = DataArray([np.nan, 2])
weights = DataArray(weights)
expected = DataArray(expected)
result = da.weighted(weights).std()
assert_equal(expected, result)
def test_weighted_sum_of_weights_nan(weights, expected):
da = DataArray([np.nan, 2])
weights = DataArray(weights)
result = da.weighted(weights).sum_of_weights()
expected = DataArray(expected)
assert_equal(expected, result)
def test_ffill_bfill_nonans():
vals = np.array([1, 2, 3, 4, 5, 6], dtype=np.float64)
expected = xr.DataArray(vals, dims='x')
actual = expected.ffill(dim='x')
assert_equal(actual, expected)
actual = expected.bfill(dim='x')
assert_equal(actual, expected)
def test_ffill_bfill_nonans():
vals = np.array([1, 2, 3, 4, 5, 6], dtype=np.float64)
expected = xr.DataArray(vals, dims="x")
actual = expected.ffill(dim="x")
assert_equal(actual, expected)
actual = expected.bfill(dim="x")
assert_equal(actual, expected)
def test_weighted_quantile_bool():
# https://github.com/pydata/xarray/issues/4074
da = DataArray([1, 1])
weights = DataArray([True, True])
q = 0.5
expected = DataArray([1], coords={"quantile": [q]}).squeeze()
result = da.weighted(weights).quantile(q)
assert_equal(expected, result)
def test_weighted_sum_of_weights_bool():
# https://github.com/pydata/xarray/issues/4074
da = DataArray([1, 2])
weights = DataArray([True, True])
result = da.weighted(weights).sum_of_weights()
expected = DataArray(2)
assert_equal(expected, result)
def test_weighted_sum_equal_weights(da, factor, skipna):
# if all weights are 'f'; weighted sum is f times the ordinary sum
da = DataArray(da)
weights = xr.full_like(da, factor)
expected = da.sum(skipna=skipna) * factor
result = da.weighted(weights).sum(skipna=skipna)
assert_equal(expected, result)
def test_ffill_bfill_allnans():
vals = np.full(6, np.nan, dtype=np.float64)
expected = xr.DataArray(vals, dims='x')
actual = expected.ffill(dim='x')
assert_equal(actual, expected)
actual = expected.bfill(dim='x')
assert_equal(actual, expected)
def test_dimension_wo_coords():
da = xr.DataArray(np.arange(12).reshape(3, 4), dims=['x', 'y'],
coords={'y': [0, 1, 2, 3]})
da_w_coord = da.copy()
da_w_coord['x'] = np.arange(3)
assert_equal(da.interp(x=[0.1, 0.2, 0.3]),
da_w_coord.interp(x=[0.1, 0.2, 0.3]))
assert_equal(da.interp(x=[0.1, 0.2, 0.3], y=[0.5]),
da_w_coord.interp(x=[0.1, 0.2, 0.3], y=[0.5]))
def test_ffill_bfill_allnans():
vals = np.full(6, np.nan, dtype=np.float64)
expected = xr.DataArray(vals, dims="x")
actual = expected.ffill(dim="x")
assert_equal(actual, expected)
actual = expected.bfill(dim="x")
assert_equal(actual, expected)
def test_interpolate():
vals = np.array([1, 2, 3, 4, 5, 6], dtype=np.float64)
expected = xr.DataArray(vals, dims='x')
mvals = vals.copy()
mvals[2] = np.nan
missing = xr.DataArray(mvals, dims='x')
actual = missing.interpolate_na(dim='x')
assert_equal(actual, expected)
def test_interpolate():
vals = np.array([1, 2, 3, 4, 5, 6], dtype=np.float64)
expected = xr.DataArray(vals, dims="x")
mvals = vals.copy()
mvals[2] = np.nan
missing = xr.DataArray(mvals, dims="x")
actual = missing.interpolate_na(dim="x")
assert_equal(actual, expected)
def test_interpolate_limits():
da = xr.DataArray(np.array([1, 2, np.nan, np.nan, np.nan, 6],
dtype=np.float64), dims='x')
actual = da.interpolate_na(dim='x', limit=None)
assert actual.isnull().sum() == 0
actual = da.interpolate_na(dim='x', limit=2)
expected = xr.DataArray(np.array([1, 2, 3, 4, np.nan, 6],
dtype=np.float64), dims='x')
assert_equal(actual, expected)
def test_dimension_wo_coords() -> None:
da = xr.DataArray(
np.arange(12).reshape(3, 4), dims=["x", "y"], coords={"y": [0, 1, 2, 3]}
)
da_w_coord = da.copy()
da_w_coord["x"] = np.arange(3)
assert_equal(da.interp(x=[0.1, 0.2, 0.3]), da_w_coord.interp(x=[0.1, 0.2, 0.3]))
assert_equal(
da.interp(x=[0.1, 0.2, 0.3], y=[0.5]),
da_w_coord.interp(x=[0.1, 0.2, 0.3], y=[0.5]),
)
def test_interpolate_limits():
da = xr.DataArray(np.array([1, 2, np.nan, np.nan, np.nan, 6],
dtype=np.float64), dims='x')
actual = da.interpolate_na(dim='x', limit=None)
assert actual.isnull().sum() == 0
actual = da.interpolate_na(dim='x', limit=2)
expected = xr.DataArray(np.array([1, 2, 3, 4, np.nan, 6],
dtype=np.float64), dims='x')
assert_equal(actual, expected)
def test_weighted_quantile_simple():
# Check that weighted quantiles return the same value as numpy quantiles
da = DataArray([0, 1, 2, 3])
w = DataArray([1, 0, 1, 0])
w_eps = DataArray([1, 0.0001, 1, 0.0001])
q = 0.75
expected = DataArray(np.quantile([0, 2], q), coords={"quantile": q}) # 1.5
assert_equal(expected, da.weighted(w).quantile(q))
assert_allclose(expected, da.weighted(w_eps).quantile(q), rtol=0.001)
def test_weighted_mean_equal_weights(da, skipna, factor):
# if all weights are equal (!= 0), should yield the same result as mean
da = DataArray(da)
# all weights as 1.
weights = xr.full_like(da, factor)
expected = da.mean(skipna=skipna)
result = da.weighted(weights).mean(skipna=skipna)
assert_equal(expected, result)
def test_weighted_mean_nan(weights, expected, skipna):
da = DataArray([np.nan, 2])
weights = DataArray(weights)
if skipna:
expected = DataArray(expected)
else:
expected = DataArray(np.nan)
result = da.weighted(weights).mean(skipna=skipna)
assert_equal(expected, result)
def test_interpolate_dask():
da, _ = make_interpolate_example_data((40, 40), 0.5)
da = da.chunk({"x": 5})
actual = da.interpolate_na("time")
expected = da.load().interpolate_na("time")
assert isinstance(actual.data, dask_array_type)
assert_equal(actual.compute(), expected)
# with limit
da = da.chunk({"x": 5})
actual = da.interpolate_na("time", limit=3)
expected = da.load().interpolate_na("time", limit=3)
assert isinstance(actual.data, dask_array_type)
assert_equal(actual, expected)
def test_bfill_dask():
da, _ = make_interpolate_example_data((40, 40), 0.5)
da = da.chunk({'x': 5})
actual = da.bfill('time')
expected = da.load().bfill('time')
assert isinstance(actual.data, dask_array_type)
assert_equal(actual, expected)
# with limit
da = da.chunk({'x': 5})
actual = da.bfill('time', limit=3)
expected = da.load().bfill('time', limit=3)
assert isinstance(actual.data, dask_array_type)
assert_equal(actual, expected)
def test_bfill_dask():
da, _ = make_interpolate_example_data((40, 40), 0.5)
da = da.chunk({'x': 5})
actual = da.bfill('time')
expected = da.load().bfill('time')
assert isinstance(actual.data, dask_array_type)
assert_equal(actual, expected)
# with limit
da = da.chunk({'x': 5})
actual = da.bfill('time', limit=3)
expected = da.load().bfill('time', limit=3)
assert isinstance(actual.data, dask_array_type)
assert_equal(actual, expected)
def test_ffill_bfill_dask(method):
da, _ = make_interpolate_example_data((40, 40), 0.5)
da = da.chunk({"x": 5})
dask_method = getattr(da, method)
numpy_method = getattr(da.compute(), method)
# unchunked axis
with raise_if_dask_computes():
actual = dask_method("time")
expected = numpy_method("time")
assert_equal(actual, expected)
# chunked axis
with raise_if_dask_computes():
actual = dask_method("x")
expected = numpy_method("x")
assert_equal(actual, expected)
# with limit
with raise_if_dask_computes():
actual = dask_method("time", limit=3)
expected = numpy_method("time", limit=3)
assert_equal(actual, expected)
# limit < axis size
with pytest.raises(NotImplementedError):
actual = dask_method("x", limit=2)
# limit > axis size
with raise_if_dask_computes():
actual = dask_method("x", limit=41)
expected = numpy_method("x", limit=41)
assert_equal(actual, expected)
def test_rolling_wrapped_bottleneck(self, da, name, center, min_periods) -> None:
bn = pytest.importorskip("bottleneck", minversion="1.1")
# Test all bottleneck functions
rolling_obj = da.rolling(time=7, min_periods=min_periods)
func_name = f"move_{name}"
actual = getattr(rolling_obj, name)()
expected = getattr(bn, func_name)(
da.values, window=7, axis=1, min_count=min_periods
)
assert_array_equal(actual.values, expected)
with pytest.warns(DeprecationWarning, match="Reductions are applied"):
getattr(rolling_obj, name)(dim="time")
# Test center
rolling_obj = da.rolling(time=7, center=center)
actual = getattr(rolling_obj, name)()["time"]
assert_equal(actual, da["time"])
def test_rolling_wrapped_bottleneck(
self, ds, name, center, min_periods, key
) -> None:
bn = pytest.importorskip("bottleneck", minversion="1.1")
# Test all bottleneck functions
rolling_obj = ds.rolling(time=7, min_periods=min_periods)
func_name = f"move_{name}"
actual = getattr(rolling_obj, name)()
if key == "z1": # z1 does not depend on 'Time' axis. Stored as it is.
expected = ds[key]
elif key == "z2":
expected = getattr(bn, func_name)(
ds[key].values, window=7, axis=0, min_count=min_periods
)
else:
raise ValueError
assert_array_equal(actual[key].values, expected)
# Test center
rolling_obj = ds.rolling(time=7, center=center)
actual = getattr(rolling_obj, name)()["time"]
assert_equal(actual, ds["time"])
def test_interpolate_use_coordinate():
xc = xr.Variable('x', [100, 200, 300, 400, 500, 600])
da = xr.DataArray(np.array([1, 2, np.nan, np.nan, np.nan, 6],
dtype=np.float64),
dims='x', coords={'xc': xc})
# use_coordinate == False is same as using the default index
actual = da.interpolate_na(dim='x', use_coordinate=False)
expected = da.interpolate_na(dim='x')
assert_equal(actual, expected)
# possible to specify non index coordinate
actual = da.interpolate_na(dim='x', use_coordinate='xc')
expected = da.interpolate_na(dim='x')
assert_equal(actual, expected)
# possible to specify index coordinate by name
actual = da.interpolate_na(dim='x', use_coordinate='x')
expected = da.interpolate_na(dim='x')
assert_equal(actual, expected)
def test_interpolate_use_coordinate():
xc = xr.Variable('x', [100, 200, 300, 400, 500, 600])
da = xr.DataArray(np.array([1, 2, np.nan, np.nan, np.nan, 6],
dtype=np.float64),
dims='x', coords={'xc': xc})
# use_coordinate == False is same as using the default index
actual = da.interpolate_na(dim='x', use_coordinate=False)
expected = da.interpolate_na(dim='x')
assert_equal(actual, expected)
# possible to specify non index coordinate
actual = da.interpolate_na(dim='x', use_coordinate='xc')
expected = da.interpolate_na(dim='x')
assert_equal(actual, expected)
# possible to specify index coordinate by name
actual = da.interpolate_na(dim='x', use_coordinate='x')
expected = da.interpolate_na(dim='x')
assert_equal(actual, expected)
def test_keywargs():
if not has_scipy:
pytest.skip("scipy is not installed.")
da = get_example_data(0)
assert_equal(da.interp(x=[0.5, 0.8]), da.interp({"x": [0.5, 0.8]}))
def test_interp1d_fastrack(method, vals):
expected = xr.DataArray(vals, dims="x")
actual = expected.interpolate_na(dim="x", method=method)
assert_equal(actual, expected)
def test_interpolate_nonans():
vals = np.array([1, 2, 3, 4, 5, 6], dtype=np.float64)
expected = xr.DataArray(vals, dims="x")
actual = expected.interpolate_na(dim="x")
assert_equal(actual, expected)
def test_interpolate_nonans():
vals = np.array([1, 2, 3, 4, 5, 6], dtype=np.float64)
expected = xr.DataArray(vals, dims='x')
actual = expected.interpolate_na(dim='x')
assert_equal(actual, expected)
def test_interpolate_allnans():
vals = np.full(6, np.nan, dtype=np.float64)
expected = xr.DataArray(vals, dims='x')
actual = expected.interpolate_na(dim='x')
assert_equal(actual, expected)
def test_keywargs():
if not has_scipy:
pytest.skip('scipy is not installed.')
da = get_example_data(0)
assert_equal(da.interp(x=[0.5, 0.8]), da.interp({'x': [0.5, 0.8]}))
def test_ffill():
da = xr.DataArray(np.array([4, 5, np.nan], dtype=np.float64), dims='x')
expected = xr.DataArray(np.array([4, 5, 5], dtype=np.float64), dims='x')
actual = da.ffill('x')
assert_equal(actual, expected)
def test_interpolate_allnans():
vals = np.full(6, np.nan, dtype=np.float64)
expected = xr.DataArray(vals, dims="x")
actual = expected.interpolate_na(dim="x")
assert_equal(actual, expected)
def test_ffill():
da = xr.DataArray(np.array([4, 5, np.nan], dtype=np.float64), dims="x")
expected = xr.DataArray(np.array([4, 5, 5], dtype=np.float64), dims="x")
actual = da.ffill("x")
assert_equal(actual, expected)
