def test_natural_breaks_cpu_equals_gpu():
import cupy
k = 5
# vanilla numpy version
cpu = natural_breaks(numpy_agg, k=k, name='numpy_result')
# cupy
cupy_agg = xr.DataArray(cupy.asarray(elevation),
attrs={'res': (10.0, 10.0)})
gpu = natural_breaks(cupy_agg, k=k, name='cupy_result')
general_output_checks(cupy_agg, gpu)
np.testing.assert_allclose(cpu.data, gpu.data.get(), equal_nan=True)
def test_natural_breaks_cpu_equals_gpu():
import cupy
k = 5
# vanilla numpy version
cpu = natural_breaks(numpy_agg, k=k, name='numpy_result')
# cupy
cupy_agg = xr.DataArray(cupy.asarray(elevation),
attrs={'res': (10.0, 10.0)})
gpu = natural_breaks(cupy_agg, k=k, name='cupy_result')
assert isinstance(gpu.data, cupy.ndarray)
assert np.isclose(cpu, gpu, equal_nan=True).all()
def test_natural_breaks_not_enough_unique_values():
agg = input_data()
n_uniques = np.isfinite(agg.data).sum()
k = n_uniques + 1
result_natural_breaks = natural_breaks(agg, k=k)
n_uniques_result = np.isfinite(result_natural_breaks.data).sum()
np.testing.assert_allclose(n_uniques_result, n_uniques)
def test_natural_breaks_cupy_num_sample(result_natural_breaks_num_sample):
cupy_agg = input_data('cupy')
k, num_sample, expected_result = result_natural_breaks_num_sample
cupy_natural_breaks = natural_breaks(cupy_agg, k=k, num_sample=num_sample)
general_output_checks(cupy_agg,
cupy_natural_breaks,
expected_result,
verify_dtype=True)
def test_natural_breaks_cupy(result_natural_breaks):
cupy_agg = input_data('cupy')
k, expected_result = result_natural_breaks
cupy_natural_breaks = natural_breaks(cupy_agg, k=k)
general_output_checks(cupy_agg,
cupy_natural_breaks,
expected_result,
verify_dtype=True)
def test_natural_breaks_numpy(result_natural_breaks):
numpy_agg = input_data()
k, expected_result = result_natural_breaks
numpy_natural_breaks = natural_breaks(numpy_agg, k=k)
general_output_checks(numpy_agg,
numpy_natural_breaks,
expected_result,
verify_dtype=True)
def test_natural_breaks_cpu():
k = 5
expected_results = np.asarray([[0., 0., 0., 1., np.nan],
[1., 1., 2., 2., 2.], [2., 3., 3., 3., 3.],
[4., 4., 4., 4., np.nan]])
# vanilla numpy
numpy_natural_breaks = natural_breaks(numpy_agg, k=k)
general_output_checks(numpy_agg, numpy_natural_breaks, expected_results)
def test_small_natural_breaks():
k = 5
n, m = 4, 3
agg = xr.DataArray(np.arange(n * m).reshape((n, m)), dims=['x', 'y'])
agg['x'] = np.linspace(0, n, n)
agg['y'] = np.linspace(0, m, m)
natural_breaks_agg = natural_breaks(agg, k=5, init=10)
assert natural_breaks_agg is not None
unique_elements, counts_elements = np.unique(natural_breaks_agg.data,
return_counts=True)
assert len(unique_elements) == k
def test_natural_breaks_cpu():
k = 5
# vanilla numpy
numpy_natural_breaks = natural_breaks(numpy_agg, k=k)
# shape and other attributes remain the same
assert numpy_agg.shape == numpy_natural_breaks.shape
assert numpy_agg.dims == numpy_natural_breaks.dims
assert numpy_agg.attrs == numpy_natural_breaks.attrs
for coord in numpy_agg.coords:
assert np.all(numpy_agg[coord] == numpy_natural_breaks[coord])
unique_elements, counts_elements = np.unique(numpy_natural_breaks.data,
return_counts=True)
assert len(unique_elements) == k
def test_natural_breaks():
k = 5
n, m = 4, 3
agg = xr.DataArray(np.arange(n * m).reshape((n, m)), dims=['y', 'x'])
agg['y'] = np.linspace(0, n, n)
agg['x'] = np.linspace(0, m, m)
natural_breaks_agg = natural_breaks(agg, k=5)
# shape and other attributes remain the same
assert agg.shape == natural_breaks_agg.shape
assert agg.dims == natural_breaks_agg.dims
assert agg.attrs == natural_breaks_agg.attrs
for coord in agg.coords:
assert np.all(agg[coord] == natural_breaks_agg[coord])
unique_elements, counts_elements = np.unique(natural_breaks_agg.data,
return_counts=True)
assert len(unique_elements) == k
def test_natural_breaks_cpu():
k = 5
# vanilla numpy
# add crs for tests
numpy_agg_crs = _add_EPSG4326_crs_to_da(numpy_agg)
numpy_natural_breaks = natural_breaks(numpy_agg_crs, k=k)
# shape and other attributes remain the same, as well as coords, including crs
assert numpy_agg_crs.shape == numpy_natural_breaks.shape
assert numpy_agg_crs.dims == numpy_natural_breaks.dims
assert numpy_agg_crs.attrs == numpy_natural_breaks.attrs
for coord in numpy_agg_crs.coords:
assert np.all(numpy_agg_crs[coord] == numpy_natural_breaks[coord])
unique_elements, counts_elements = np.unique(numpy_natural_breaks.data,
return_counts=True)
assert len(unique_elements) == k
def test_natural_breaks_cpu_deterministic():
results = []
elevation = np.arange(100).reshape(10, 10)
agg = xr.DataArray(elevation, attrs={'res': (10.0, 10.0)})
k = 5
numIters = 3
for i in range(numIters):
# vanilla numpy
numpy_natural_breaks = natural_breaks(agg, k=k)
general_output_checks(agg, numpy_natural_breaks)
unique_elements = np.unique(numpy_natural_breaks.data[np.isfinite(
numpy_natural_breaks.data)])
assert len(unique_elements) == k
results.append(numpy_natural_breaks)
# Check that the code is deterministic.
# Multiple runs on same data should produce same results
for i in range(numIters - 1):
np.testing.assert_allclose(results[i].data,
results[i + 1].data,
equal_nan=True)
