dask-array 0.1.0__py3-none-any.whl

dask_array/slicing/_vindex.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import functools
+import math
+from collections import defaultdict
+from itertools import product
+from numbers import Number
+from operator import mul
+
+import numpy as np
+
+from dask._task_spec import List, Task, TaskRef
+from dask_array._expr import ArrayExpr
+from dask_array._utils import meta_from_array
+from dask_array.slicing._utils import replace_ellipsis
+from dask_array._core_utils import (
+    _get_axis,
+    _vindex_merge,
+    _vindex_slice_and_transpose,
+    interleave_none,
+    keyname,
+)
+from dask.utils import cached_cumsum, cached_max
+
+
+def _numpy_vindex(indexer, arr):
+    """Helper for vindex with single-block arrays indexed by dask arrays."""
+    return arr[indexer]
+
+
+def _vindex(x, *indexes):
+    """Point wise indexing with broadcasting.
+
+    >>> x = np.arange(56).reshape((7, 8))
+    >>> x
+    array([[ 0,  1,  2,  3,  4,  5,  6,  7],
+           [ 8,  9, 10, 11, 12, 13, 14, 15],
+           [16, 17, 18, 19, 20, 21, 22, 23],
+           [24, 25, 26, 27, 28, 29, 30, 31],
+           [32, 33, 34, 35, 36, 37, 38, 39],
+           [40, 41, 42, 43, 44, 45, 46, 47],
+           [48, 49, 50, 51, 52, 53, 54, 55]])
+
+    >>> from dask_array._collection import from_array
+    >>> d = from_array(x, chunks=(3, 4))
+    >>> result = _vindex(d, [0, 1, 6, 0], [0, 1, 0, 7])
+    >>> result.compute()
+    array([ 0,  9, 48,  7])
+    """
+
+    indexes = replace_ellipsis(x.ndim, indexes)
+
+    nonfancy_indexes = []
+    reduced_indexes = []
+    for ind in indexes:
+        if isinstance(ind, Number):
+            nonfancy_indexes.append(ind)
+        elif isinstance(ind, slice):
+            nonfancy_indexes.append(ind)
+            reduced_indexes.append(slice(None))
+        else:
+            nonfancy_indexes.append(slice(None))
+            reduced_indexes.append(ind)
+
+    nonfancy_indexes = tuple(nonfancy_indexes)
+    reduced_indexes = tuple(reduced_indexes)
+
+    x = x[nonfancy_indexes]
+
+    array_indexes = {}
+    for i, (ind, size) in enumerate(zip(reduced_indexes, x.shape)):
+        if not isinstance(ind, slice):
+            ind = np.array(ind, copy=True)
+            if ind.dtype.kind == "b":
+                raise IndexError("vindex does not support indexing with boolean arrays")
+            if ((ind >= size) | (ind < -size)).any():
+                raise IndexError(
+                    f"vindex key has entries out of bounds for indexing along axis {i} of size {size}: {ind!r}"
+                )
+            ind %= size
+            array_indexes[i] = ind
+
+    if array_indexes:
+        x = _vindex_array(x, array_indexes)
+
+    return x
+
+
+def _compute_indexer(index, chunks_along_axis):
+    """Compute Shuffle indexer by grouping consecutive indices from same input chunk.
+
+    Returns a list of lists, where each inner list contains indices that come from
+    a contiguous run accessing the same input chunk. This preserves locality for
+    patterns like np.repeat.
+    """
+    chunk_boundaries = np.cumsum((0,) + chunks_along_axis)
+    input_chunk_ids = np.searchsorted(chunk_boundaries[1:], index, side="right")
+    changes = np.concatenate([[0], np.where(np.diff(input_chunk_ids) != 0)[0] + 1, [len(index)]])
+    return [index[changes[i] : changes[i + 1]].tolist() for i in range(len(changes) - 1)]
+
+
+def _vindex_array(x, dict_indexes):
+    """Point wise indexing with only NumPy Arrays."""
+    from dask_array._new_collection import new_collection
+    from dask_array.creation import empty
+
+    try:
+        broadcast_shape = np.broadcast_shapes(*(arr.shape for arr in dict_indexes.values()))
+    except ValueError as e:
+        shapes_str = " ".join(str(a.shape) for a in dict_indexes.values())
+        raise IndexError(
+            f"shape mismatch: indexing arrays could not be broadcast together with shapes {shapes_str}"
+        ) from e
+    npoints = math.prod(broadcast_shape)
+
+    # Single-axis case: delegate to Shuffle for optimization hooks
+    if len(dict_indexes) == 1 and npoints > 0:
+        from dask_array._shuffle import _shuffle
+
+        axis = next(iter(dict_indexes.keys()))
+        index = next(iter(dict_indexes.values())).ravel()
+        indexer = _compute_indexer(index, x.chunks[axis])
+
+        result = new_collection(_shuffle(x.expr, indexer, axis, "vindex-"))
+        # Shuffle keeps axis in place; reshape for broadcast_shape along that axis
+        new_shape = list(result.shape)
+        new_shape[axis : axis + 1] = list(broadcast_shape)
+        return result.reshape(tuple(new_shape))
+
+    if npoints > 0:
+        result_1d = new_collection(VIndexArray(x.expr, dict_indexes, broadcast_shape, npoints))
+        return result_1d.reshape(broadcast_shape + result_1d.shape[1:])
+
+    # output has zero dimension - just create a new zero-shape array
+    axes = [i for i in range(x.ndim) if i in dict_indexes]
+    chunks = [c for i, c in enumerate(x.chunks) if i not in axes]
+    chunks.insert(0, (0,))
+    chunks = tuple(chunks)
+
+    result_1d = empty(tuple(map(sum, chunks)), chunks=chunks, dtype=x.dtype)
+    return result_1d.reshape(broadcast_shape + result_1d.shape[1:])
+
+
+class VIndexArray(ArrayExpr):
+    """Point-wise vectorized indexing with broadcasting.
+
+    Used for multi-axis fancy indexing where indices broadcast together.
+    Single-axis cases delegate to Shuffle for optimization hooks.
+    """
+
+    _parameters = ["array", "dict_indexes", "broadcast_shape", "npoints"]
+
+    @functools.cached_property
+    def _name(self):
+        return f"vindex-merge-{self.deterministic_token}"
+
+    @functools.cached_property
+    def _meta(self):
+        return meta_from_array(self.array._meta, ndim=len(self.chunks))
+
+    @functools.cached_property
+    def _axes(self):
+        """Axes that have array indexing."""
+        return [i for i in range(self.array.ndim) if i in self.dict_indexes]
+
+    def _subset_to_indexed_axes(self, iterable):
+        for i, elem in enumerate(iterable):
+            if i in self._axes:
+                yield elem
+
+    @functools.cached_property
+    def _max_chunk_point_dimensions(self):
+        return functools.reduce(mul, map(cached_max, self._subset_to_indexed_axes(self.array.chunks)))
+
+    @functools.cached_property
+    def chunks(self):
+        axes = self._axes
+        npoints = self.npoints
+        max_chunk_point_dimensions = self._max_chunk_point_dimensions
+
+        chunks = [c for i, c in enumerate(self.array.chunks) if i not in axes]
+
+        n_chunks, remainder = divmod(npoints, max_chunk_point_dimensions)
+        chunks.insert(
+            0,
+            (
+                (max_chunk_point_dimensions,) * n_chunks + ((remainder,) if remainder > 0 else ())
+                if npoints > 0
+                else (0,)
+            ),
+        )
+        return tuple(chunks)
+
+    def _layer(self) -> dict:
+        dict_indexes = self.dict_indexes
+        broadcast_shape = self.broadcast_shape
+        npoints = self.npoints
+        axes = self._axes
+
+        bounds2 = tuple(
+            np.array(cached_cumsum(c, initial_zero=True)) for c in self._subset_to_indexed_axes(self.array.chunks)
+        )
+        axis = _get_axis(tuple(i if i in axes else None for i in range(self.array.ndim)))
+
+        # Now compute indices of each output element within each input block
+        block_idxs = tuple(np.searchsorted(b, ind, side="right") - 1 for b, ind in zip(bounds2, dict_indexes.values()))
+        starts = (b[i] for i, b in zip(block_idxs, bounds2))
+        inblock_idxs = []
+        for idx, start in zip(dict_indexes.values(), starts):
+            # Convert unsigned integers to signed to avoid float promotion in subtraction
+            if idx.dtype.kind == "u":
+                idx = idx.astype(np.int64)
+            a = idx - start
+            if len(a) > 0:
+                dtype = np.min_scalar_type(np.max(a, axis=None))
+                inblock_idxs.append(a.astype(dtype, copy=False))
+            else:
+                inblock_idxs.append(a)
+
+        inblock_idxs = np.broadcast_arrays(*inblock_idxs)  # type: ignore[assignment]
+
+        max_chunk_point_dimensions = self._max_chunk_point_dimensions
+        n_chunks, remainder = divmod(npoints, max_chunk_point_dimensions)
+
+        other_blocks = product(*[range(len(c)) if i not in axes else [None] for i, c in enumerate(self.array.chunks)])
+
+        full_slices = [slice(None, None) if i not in axes else None for i in range(self.array.ndim)]
+
+        # The output is constructed as a new dimension and then reshaped
+        outinds = np.arange(npoints).reshape(broadcast_shape)
+        outblocks, outblock_idx = np.divmod(outinds, max_chunk_point_dimensions)
+
+        ravel_shape = (
+            n_chunks + 1,
+            *self._subset_to_indexed_axes(self.array.numblocks),
+        )
+        keys = np.ravel_multi_index([outblocks, *block_idxs], ravel_shape)
+        sortidx = np.argsort(keys, axis=None)
+        sorted_keys = keys.flat[sortidx]
+        sorted_inblock_idxs = [_.flat[sortidx] for _ in inblock_idxs]
+        sorted_outblock_idx = outblock_idx.flat[sortidx]
+        dtype = np.min_scalar_type(max_chunk_point_dimensions)
+        sorted_outblock_idx = sorted_outblock_idx.astype(dtype, copy=False)
+        flag = np.concatenate([[True], sorted_keys[1:] != sorted_keys[:-1], [True]])
+        (key_bounds,) = flag.nonzero()
+
+        slice_name = f"vindex-slice-{self.deterministic_token}"
+        dsk = {}
+
+        for okey in other_blocks:
+            merge_inputs = defaultdict(list)
+            merge_indexer = defaultdict(list)
+            for i, (start, stop) in enumerate(zip(key_bounds[:-1], key_bounds[1:], strict=True)):
+                slicer = slice(start, stop)
+                key = sorted_keys[start]
+                outblock, *input_blocks = np.unravel_index(key, ravel_shape)
+                inblock = [_[slicer] for _ in sorted_inblock_idxs]
+                k = keyname(slice_name, i, okey)
+                dsk[k] = Task(
+                    k,
+                    _vindex_slice_and_transpose,
+                    TaskRef((self.array._name,) + interleave_none(okey, input_blocks)),
+                    interleave_none(full_slices, inblock),
+                    axis,
+                )
+                merge_inputs[outblock].append(TaskRef(k))
+                merge_indexer[outblock].append(sorted_outblock_idx[slicer])
+
+            for i in merge_inputs.keys():
+                k = keyname(self._name, i, okey)
+                dsk[k] = Task(
+                    k,
+                    _vindex_merge,
+                    merge_indexer[i],
+                    List(*merge_inputs[i]),
+                )
+
+        return dsk
+
+    def __dask_keys__(self):
+        # Override to return 1D keys since we reshape after
+        return [(self._name,) + idx for idx in np.ndindex(tuple(len(c) for c in self.chunks))]

dask_array/stacking/__init__.py

@@ -0,0 +1,15 @@
+"""Stacking and concatenation functions."""
+
+from dask_array._concatenate import concatenate
+from dask_array._stack import stack
+from dask_array.stacking._block import block
+from dask_array.stacking._simple import dstack, hstack, vstack
+
+__all__ = [
+    "stack",
+    "concatenate",
+    "block",
+    "vstack",
+    "hstack",
+    "dstack",
+]

dask_array/stacking/_block.py

@@ -0,0 +1,83 @@
+"""Block operation."""
+
+from __future__ import annotations
+
+
+def block(arrays, allow_unknown_chunksizes=False):
+    """
+    Assemble an nd-array from nested lists of blocks.
+
+    Blocks in the innermost lists are concatenated along the last
+    dimension (-1), then these are concatenated along the second-last
+    dimension (-2), and so on until the outermost list is reached.
+
+    See Also
+    --------
+    numpy.block
+    """
+    # Import here to avoid circular imports
+    from dask_array._collection import asanyarray, concatenate
+    from dask_array._numpy_compat import _Recurser
+
+    def atleast_nd(x, ndim):
+        x = asanyarray(x)
+        diff = max(ndim - x.ndim, 0)
+        if diff == 0:
+            return x
+        else:
+            return x[(None,) * diff + (Ellipsis,)]
+
+    def format_index(index):
+        return "arrays" + "".join(f"[{i}]" for i in index)
+
+    rec = _Recurser(recurse_if=lambda x: type(x) is list)
+
+    # Ensure that the lists are all matched in depth
+    list_ndim = None
+    any_empty = False
+    for index, value, entering in rec.walk(arrays):
+        if type(value) is tuple:
+            raise TypeError(
+                f"{format_index(index)} is a tuple. "
+                "Only lists can be used to arrange blocks, and np.block does "
+                "not allow implicit conversion from tuple to ndarray."
+            )
+        if not entering:
+            curr_depth = len(index)
+        elif len(value) == 0:
+            curr_depth = len(index) + 1
+            any_empty = True
+        else:
+            continue
+
+        if list_ndim is not None and list_ndim != curr_depth:
+            raise ValueError(
+                f"List depths are mismatched. First element was at depth {list_ndim}, "
+                f"but there is an element at depth {curr_depth} ({format_index(index)})"
+            )
+        list_ndim = curr_depth
+
+    # Do this here so we catch depth mismatches first
+    if any_empty:
+        raise ValueError("Lists cannot be empty")
+
+    # Convert all the arrays to ndarrays
+    arrays = rec.map_reduce(arrays, f_map=asanyarray, f_reduce=list)
+
+    # Determine the maximum dimension of the elements
+    elem_ndim = rec.map_reduce(arrays, f_map=lambda xi: xi.ndim, f_reduce=max)
+    ndim = max(list_ndim, elem_ndim)
+
+    # First axis to concatenate along
+    first_axis = ndim - list_ndim
+
+    # Make all the elements the same dimension
+    arrays = rec.map_reduce(arrays, f_map=lambda xi: atleast_nd(xi, ndim), f_reduce=list)
+
+    # Concatenate innermost lists on the right, outermost on the left
+    return rec.map_reduce(
+        arrays,
+        f_reduce=lambda xs, axis: concatenate(list(xs), axis=axis, allow_unknown_chunksizes=allow_unknown_chunksizes),
+        f_kwargs=lambda axis: dict(axis=(axis + 1)),
+        axis=first_axis,
+    )

dask_array/stacking/_simple.py

@@ -0,0 +1,58 @@
+"""Simple stacking operations: vstack, hstack, dstack."""
+
+from __future__ import annotations
+
+
+def vstack(tup, allow_unknown_chunksizes=False):
+    """Stack arrays in sequence vertically (row wise).
+
+    See Also
+    --------
+    numpy.vstack
+    """
+    # Import here to avoid circular imports
+    from dask_array._collection import Array, concatenate
+    from dask_array.manipulation._expand import atleast_2d
+
+    if isinstance(tup, Array):
+        raise NotImplementedError("``vstack`` expects a sequence of arrays as the first argument")
+
+    tup = tuple(atleast_2d(x) for x in tup)
+    return concatenate(tup, axis=0, allow_unknown_chunksizes=allow_unknown_chunksizes)
+
+
+def hstack(tup, allow_unknown_chunksizes=False):
+    """Stack arrays in sequence horizontally (column wise).
+
+    See Also
+    --------
+    numpy.hstack
+    """
+    # Import here to avoid circular imports
+    from dask_array._collection import Array, concatenate
+
+    if isinstance(tup, Array):
+        raise NotImplementedError("``hstack`` expects a sequence of arrays as the first argument")
+
+    if all(x.ndim == 1 for x in tup):
+        return concatenate(tup, axis=0, allow_unknown_chunksizes=allow_unknown_chunksizes)
+    else:
+        return concatenate(tup, axis=1, allow_unknown_chunksizes=allow_unknown_chunksizes)
+
+
+def dstack(tup, allow_unknown_chunksizes=False):
+    """Stack arrays in sequence depth wise (along third axis).
+
+    See Also
+    --------
+    numpy.dstack
+    """
+    # Import here to avoid circular imports
+    from dask_array._collection import Array, concatenate
+    from dask_array.manipulation._expand import atleast_3d
+
+    if isinstance(tup, Array):
+        raise NotImplementedError("``dstack`` expects a sequence of arrays as the first argument")
+
+    tup = tuple(atleast_3d(x) for x in tup)
+    return concatenate(tup, axis=2, allow_unknown_chunksizes=allow_unknown_chunksizes)

dask_array/templates/array.html.j2

@@ -0,0 +1,48 @@
+<style>
+.dask-array-repr .dask-table-header { color: var(--jp-ui-font-color2, #78716c); }
+.dask-array-repr .dask-table-label { color: var(--jp-ui-font-color3, #a8a29e); }
+.dask-array-repr .dask-table-data { color: var(--jp-ui-font-color1, #1c1917); }
+.dask-array-repr .dask-table-border { border-top: 1px solid var(--jp-border-color2, #e7e5e4); }
+</style>
+<details class="dask-array-repr" style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;">
+    <summary style="cursor: pointer; list-style: none;">
+        <table style="border-collapse: separate; border-spacing: 0; display: inline-table;">
+            <tr>
+                <td style="vertical-align: top;">
+                    <table style="border-collapse: collapse; font-size: 14px;">
+                        <thead>
+                            <tr>
+                                <td style="padding: 6px 12px;"></td>
+                                <th class="dask-table-header" style="padding: 6px 12px; text-align: right; font-weight: 400;">Array</th>
+                                <th class="dask-table-header" style="padding: 6px 12px; text-align: right; font-weight: 400;">Chunk</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {% if nbytes %}
+                            <tr>
+                                <th class="dask-table-label dask-table-border" style="padding: 6px 12px; text-align: left; font-weight: 400;">Bytes</th>
+                                <td class="dask-table-data dask-table-border" style="padding: 6px 12px; text-align: right; font-weight: 600;">{{ nbytes }}</td>
+                                <td class="dask-table-data dask-table-border" style="padding: 6px 12px; text-align: right; font-weight: 600;">{{ cbytes }}</td>
+                            </tr>
+                            {% endif %}
+                            <tr>
+                                <th class="dask-table-label dask-table-border" style="padding: 6px 12px; text-align: left; font-weight: 400;">Shape</th>
+                                <td class="dask-table-data dask-table-border" style="padding: 6px 12px; text-align: right; font-weight: 600;">{{ array.shape }}</td>
+                                <td class="dask-table-data dask-table-border" style="padding: 6px 12px; text-align: right; font-weight: 600;">{{ array.chunksize }}</td>
+                            </tr>
+                            <tr>
+                                <th class="dask-table-label dask-table-border" style="padding: 6px 12px; text-align: left; font-weight: 400;">Nodes</th>
+                                <td class="dask-table-data dask-table-border" style="padding: 6px 12px; text-align: right; font-weight: 600;">{{ n_expr }}</td>
+                                <td class="dask-table-border" style="padding: 6px 12px;"></td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </td>
+                <td style="vertical-align: middle; padding-left: 24px;">
+                {{ grid }}
+                </td>
+            </tr>
+        </table>
+    </summary>
+    <div style="padding: 12px 0;">{{ expr_flow }}</div>
+</details>

dask_array/tests/conftest.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import pytest
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--runslow",
+        action="store_true",
+        default=False,
+        help="run tests marked slow",
+    )
+
+
+def pytest_collection_modifyitems(config, items):
+    if config.getoption("--runslow"):
+        return
+
+    skip_slow = pytest.mark.skip(reason="need --runslow option to run")
+    for item in items:
+        if "slow" in item.keywords:
+            item.add_marker(skip_slow)

dask_array/tests/test_api.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import numpy as np
+
+import dask_array as da
+
+
+def test_top_level_compatibility_exports():
+    assert da.newaxis is None
+    assert np.isnan(da.nan)
+    assert da.inf == np.inf
+    assert da.pi == np.pi
+    assert da.float64 is np.float64
+    assert da.int64 is np.int64
+
+    assert callable(da.compute)
+    assert callable(da.optimize)
+    assert callable(da.register_chunk_type)
+    assert callable(da.to_hdf5)
+    assert callable(da.from_tiledb)
+    assert callable(da.to_tiledb)
+
+
+def test_top_level_optimize_collection():
+    x = da.arange(6, chunks=3) + 1
+
+    result = da.optimize(x)
+
+    assert isinstance(result, da.Array)
+    np.testing.assert_array_equal(result.compute(), np.arange(6) + 1)
+
+
+def test_random_star_exports_legacy_wrappers():
+    namespace = {}
+    exec("from dask_array.random import *", namespace)
+
+    assert callable(namespace["normal"])
+    assert callable(namespace["random"])
+    assert callable(namespace["randint"])
+    assert callable(namespace["standard_normal"])

dask_array/tests/test_binary_op_chunks.py

@@ -0,0 +1,107 @@
+"""Tests for coarse_blockdim: preferring larger chunks in binary operations.
+
+When combining arrays with different chunk granularities, we prefer coarser
+chunks (fewer blocks) when boundaries align. This reduces task overhead.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+import pytest
+
+import dask_array as da
+from dask_array._test_utils import assert_eq
+
+
+def total_chunks(arr):
+    """Total number of chunks across all dimensions."""
+    return math.prod(arr.numblocks)
+
+
+class TestCoarseChunkPreference:
+    """Tests for preferring coarser chunks when boundaries align."""
+
+    def test_shuffle_indexed_array(self):
+        """Main use case: xarray groupby pattern.
+
+        Binary op between array with nice chunks and shuffle-indexed array
+        (which has per-element chunks) should preserve the nice chunks.
+        """
+        # Original data: 10 chunks of size 12
+        arr = da.random.random((120, 20, 30), chunks=(12, 20, 30))
+
+        # Aggregated data indexed to match original shape
+        n_groups = 4
+        mean_arr = da.random.random((n_groups, 20, 30), chunks=(1, 20, 30))
+        indexer = np.tile(np.arange(n_groups), 30)
+        indexed_mean = mean_arr[indexer, ...]
+
+        result = arr - indexed_mean
+
+        # Should preserve arr's chunk count, not explode to 120
+        assert total_chunks(result) <= total_chunks(arr) * 2
+        assert_eq(result, arr.compute() - indexed_mean.compute())
+
+    def test_aligned_1d(self):
+        """1D: (20,20) + (10,10,10,10) -> (20,20)"""
+        coarse = da.ones(40, chunks=20)
+        fine = da.ones(40, chunks=10)
+
+        result = coarse + fine
+
+        assert result.chunks == ((20, 20),)
+
+    def test_aligned_2d(self):
+        """2D: coarse chunks preferred in both dimensions."""
+        coarse = da.ones((40, 40), chunks=(20, 20))
+        fine = da.ones((40, 40), chunks=(10, 10))
+
+        result = coarse + fine
+
+        assert result.chunks == ((20, 20), (20, 20))
+        assert total_chunks(result) == 4  # not 16
+
+    def test_multiples_align(self):
+        """Chunk sizes that are multiples align: (30,30) + (10,...) -> (30,30)"""
+        coarse = da.ones(60, chunks=30)
+        fine = da.ones(60, chunks=10)
+
+        result = coarse + fine
+
+        assert result.chunks == ((30, 30),)
+
+
+class TestFallbackToCommonBlockdim:
+    """Tests for falling back when boundaries don't align."""
+
+    def test_misaligned_boundaries(self):
+        """(15,15) vs (10,20): boundary 15 not in {10}, must subdivide."""
+        a = da.ones(30, chunks=(15, 15))
+        b = da.ones(30, chunks=(10, 20))
+
+        result = a + b
+
+        # Neither input's chunks work; uses finest common divisor
+        assert result.chunks != ((15, 15),)
+        assert result.chunks != ((10, 20),)
+
+    def test_non_divisible(self):
+        """(12,12) vs (8,8,8): boundary 12 not in {8,16}, must subdivide."""
+        a = da.ones(24, chunks=12)
+        b = da.ones(24, chunks=8)
+
+        result = a + b
+
+        # More chunks than either input
+        assert len(result.chunks[0]) > 2
+
+    def test_classic_uneven(self):
+        """(4,6) vs (6,4): different boundaries, uses (4,2,4)."""
+        a = da.arange(10, chunks=((4, 6),))
+        b = da.ones(10, chunks=((6, 4),))
+
+        result = a + b
+
+        assert result.chunks == ((4, 2, 4),)