unitx 0.16.2__tar.gz → 0.16.4__tar.gz

{unitx-0.16.2 → unitx-0.16.4}/.github/consumers/arrays.py

@@ -5,12 +5,14 @@ from typing import assert_type, cast
 import numpy as np
 from numpy.typing import NDArray
 
-from unitx import LogQuantity, LogUnit, Quantity, Unit
+from unitx import AffineQuantity, LogQuantity, LogUnit, Quantity, Unit
 from unitx._numerics import Array
 from unitx.cgs import emu, esu, gaussian, hl
 from unitx.exceptions import DimensionError
 from unitx.si import si
 
+type ArrayQuantity = Quantity[Array] | AffineQuantity[Array] | LogQuantity[Array]
+
 
 def check_arrays(values: NDArray[np.float64]) -> None:
     charge = gaussian.convert(Quantity(values, si.C), gaussian.statC)
@@ -47,6 +49,55 @@ def check_arrays(values: NDArray[np.float64]) -> None:
 
     # NumPy's stubs lose the wrapper on these returns. State the supported
     # array result domain explicitly and verify the wrapper at runtime.
+    for sample in (distance, AffineQuantity(values, si.degC), level):
+        expanded = cast(ArrayQuantity, np.expand_dims(sample, (0, -1)))
+        # moveaxis/rollaxis stubs require ndarray input despite runtime dispatch.
+        moved = cast(
+            ArrayQuantity,
+            expanded.__array_function__(np.moveaxis, (type(expanded),), (expanded, 0, -1), {}),
+        )
+        swapped = cast(ArrayQuantity, np.swapaxes(moved, 0, 1))
+        rolled = cast(
+            ArrayQuantity,
+            swapped.__array_function__(np.rollaxis, (type(swapped),), (swapped, 2, 0), {}),
+        )
+        squeezed = np.squeeze(rolled)
+        result = cast(ArrayQuantity, np.ravel(squeezed))
+        assert type(result) is type(sample) and result.unit == sample.unit
+        np.testing.assert_array_equal(result.value, values)
+        assert np.shares_memory(result.value, sample.value)
+
+        for actual, expected in (
+            (np.atleast_1d(sample), np.atleast_1d(values)),
+            (np.atleast_2d(sample), np.atleast_2d(values)),
+            (np.atleast_3d(sample), np.atleast_3d(values)),
+            (np.broadcast_to(sample, (2, 3)), np.broadcast_to(values, (2, 3))),
+            (np.flip(sample), np.flip(values)),
+            (np.flipud(sample), np.flipud(values)),
+            (np.roll(sample, 1), np.roll(values, 1)),
+            (np.repeat(sample, 2), np.repeat(values, 2)),
+            (np.tile(sample, (2, 1)), np.tile(values, (2, 1))),
+            (np.copy(sample), np.copy(values)),
+        ):
+            manipulated = cast(ArrayQuantity, actual)
+            assert type(manipulated) is type(sample) and manipulated.unit == sample.unit
+            np.testing.assert_array_equal(manipulated.value, expected)
+        assert_type(np.shape(sample), tuple[int, ...])
+        assert_type(np.ndim(sample), int)
+        assert_type(np.size(sample), int)
+        assert np.shape(sample) == (3,) and np.ndim(sample) == 1 and np.size(sample) == 3
+        for operation in (np.matrix_transpose, np.linalg.matrix_transpose, np.fliplr, np.rot90):
+            manipulated = cast(ArrayQuantity, operation(np.atleast_2d(sample)))
+            assert type(manipulated) is type(sample) and manipulated.unit == sample.unit
+            np.testing.assert_array_equal(manipulated.value, operation(np.atleast_2d(values)))
+        broadcasted, bare = cast(
+            tuple[ArrayQuantity, NDArray[np.float64]],
+            np.broadcast_arrays(sample, np.ones((2, 1))),
+        )
+        assert type(broadcasted) is type(sample) and broadcasted.unit == sample.unit
+        np.testing.assert_array_equal(broadcasted.value, np.broadcast_to(values, (2, 3)))
+        np.testing.assert_array_equal(bare, np.ones((2, 3)))
+
     bounded = cast(Quantity[Array], np.clip(distance, Quantity(500, si.cm), Quantity(25, si.m)))
     assert isinstance(bounded, Quantity) and bounded.unit == si.m
     np.testing.assert_allclose(bounded.value, [5, 20, 25])

{unitx-0.16.2 → unitx-0.16.4}/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [0.16.4] - 2026-10-25
+
+### Added
+
+- Support NumPy `atleast_1d/2d/3d`, `broadcast_to`, `broadcast_arrays`,
+  `matrix_transpose` (including `linalg.matrix_transpose`), `flip/fliplr/flipud`,
+  `rot90`, `roll`, `repeat`, `tile` and `copy`. Preserve complete units or point
+  coordinates, NumPy's views/copies, writeability and warnings. Multiple inputs
+  retain their own units or coordinates independently; bare inputs stay bare.
+- Support NumPy `shape`, `ndim` and `size` as bare array metadata, including
+  scalar quantities. Document and verify the existing `permute_dims` alias.
+
+## [0.16.3] - 2026-10-25
+
+### Added
+
+- Support NumPy `squeeze`, `expand_dims`, `moveaxis`, `swapaxes`, `rollaxis`
+  and `ravel`, preserving complete units or point coordinates. Retain NumPy's
+  axis rules, dtype, shared views, read-only storage and necessary copies.
+
 ## [0.16.2] - 2026-10-25
 
 ### Added

{unitx-0.16.2 → unitx-0.16.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unitx
-Version: 0.16.2
+Version: 0.16.4
 Summary: Physical units, quantities, and unit conversion with exact unit algebra, type hints, and NumPy integration.
 Project-URL: Homepage, https://github.com/DaitTHU/unitx
 Project-URL: Documentation, https://daitthu.github.io/unitx/

{unitx-0.16.2 → unitx-0.16.4}/docs/numpy.md

@@ -38,8 +38,8 @@ use `np.asarray(q.value_in(target_unit))`.
 
 Construction, unit-only multiplication/division, and an identity conversion
 preserve the magnitude object. Factor/SymbolicConstant operands change the
-exact unit scale. Indexing, iteration, `.T`, reshape, and transpose follow
-NumPy's scalar/view/copy rules; `.flatten(order='C')` copies. Zero-dimensional
+exact unit scale. Indexing, iteration, `.T`, and the supported shape transformations
+follow NumPy's scalar/view/copy rules; `.flatten(order='C')` copies. Zero-dimensional
 arrays cannot be iterated. `.shape`, `.ndim`, `.dtype`, and `.size` are available
 for NumPy magnitudes. Python scalars do not acquire array attributes. Exposed
 values and views may share writable storage.
@@ -115,6 +115,15 @@ functions, including exp/log. Python scalar numerical semantics remain native.
 | NumPy function | Unit/result rule | Supported options |
 | --- | --- | --- |
 | reshape, transpose | Preserve unit | shape/order/copy; axes |
+| squeeze, expand_dims | Preserve unit or point coordinate | axis |
+| moveaxis, swapaxes, rollaxis | Preserve unit or point coordinate | source/destination; axis1/axis2; axis/start |
+| ravel | Preserve unit or point coordinate | order: C, F, A, K |
+| matrix_transpose, linalg.matrix_transpose | Swap the last two axes; preserve unit or point coordinate | At least two dimensions; transpose's permute_dims alias is also supported |
+| atleast_1d, atleast_2d, atleast_3d | Preserve each input's unit or point coordinate independently | One or more positional numeric scalars/ndarrays, quantities or points |
+| broadcast_to, broadcast_arrays | Preserve each input's unit or point coordinate independently | shape, subok; broadcasting does not align units |
+| flip, fliplr, flipud, rot90, roll | Preserve unit or point coordinate | axis; k/axes for rot90; shift/axis for roll |
+| repeat, tile, copy | Preserve unit or point coordinate | repeats/axis; reps; order/subok for copy |
+| shape, ndim, size | Bare shape tuple or integer | size accepts axis |
 | concatenate, stack | Convert to first Quantity's unit; bare arrays remain dimensionless | axis, dtype, casting, out; dtype and out are mutually exclusive |
 | sum, nansum | Preserve unit | axis, dtype, keepdims, initial, where, out |
 | mean, nanmean | Preserve unit or point coordinate | axis, dtype, keepdims, where, out |
@@ -146,6 +155,73 @@ Indexed assignment and augmented arithmetic on ndarrays follow the fixed-target
 rules below. Python and NumPy scalar magnitudes retain ordinary result/rebinding
 behavior for augmented arithmetic.
 
+## Shape transformations
+
+`squeeze`, `expand_dims`, `moveaxis`, `swapaxes`, `rollaxis`, and `ravel`
+operate on magnitudes without conversion. Like reshape and transpose, they
+retain the complete unit or point coordinate and return the same family:
+Quantity, AffineQuantity, or LogQuantity. Only the NumPy function forms are
+supported; these functions have no `out` option.
+
+Axis rules and errors follow NumPy, including negative and tuple axes where
+supported. Squeezing an ndarray whose axes all have length one produces a
+zero-dimensional ndarray magnitude. Views share storage and its writeability
+with the input.
+`ravel` returns a contiguous one-dimensional magnitude, copying only when needed;
+it can copy a noncontiguous input even when reshape could return a view.
+Its C/F/A/K orders follow NumPy. Prefer `moveaxis` for new code; `rollaxis` is
+also supported for compatibility with existing NumPy code.
+
+`matrix_transpose` and `linalg.matrix_transpose` swap the last two axes of an
+array with at least two dimensions. `permute_dims` is NumPy's alias of
+`transpose` and supports the same axes argument.
+
+`atleast_1d/2d/3d` and `broadcast_arrays` accept multiple positional inputs.
+Each Quantity or point retains its own complete unit or coordinate; bare
+numeric scalars/ndarrays produce bare ndarrays. Inputs may have different
+dimensions or coordinate families because these functions only rearrange
+storage. Bare list/tuple inputs and unsupported array types remain unsupported.
+One input to `atleast_*` returns one result; multiple inputs return NumPy's
+sequence container. `broadcast_arrays` always returns a sequence, even for one
+input. Shape incompatibilities follow NumPy.
+
+`broadcast_to` returns a read-only view. `broadcast_arrays` retains NumPy's
+view flags and warnings; broadcast elements may alias the same storage, so
+use `copy` before writing. `flip`, `fliplr`, `flipud`, and `rot90` retain
+NumPy's views, including negative strides. `roll`, `repeat`, and `tile` follow
+NumPy's allocation rules. `copy(order='K', subok=False)` creates independent,
+writable storage, including when the source is read-only. `subok` on copy and
+broadcasting is forwarded to NumPy for the plain supported magnitudes; it does
+not enable ndarray subclasses.
+
+`shape`, `ndim`, and `size` inspect the magnitude and return bare metadata,
+including for scalar quantities. All these function forms preserve the wrapper
+family when returning unit-bearing values and have no `out` option.
+
+```python
+import numpy as np
+from unitx import Quantity
+
+samples = Quantity(np.arange(6).reshape(1, 2, 3), 'cm')
+matrix = np.squeeze(samples, axis=0)
+assert matrix.shape == (2, 3)
+assert np.moveaxis(matrix, 0, -1).shape == (3, 2)
+assert matrix.unit == samples.unit
+assert np.shares_memory(matrix.value, samples.value)
+
+times = Quantity(np.array([0.0, 1.0, 2.0]), 's')
+distance_grid, time_grid = np.broadcast_arrays(matrix, times)
+assert distance_grid.unit == matrix.unit and time_grid.unit == times.unit
+assert time_grid.shape == (2, 3)
+readonly = np.broadcast_to(times, (2, 3))
+assert not readonly.value.flags.writeable
+independent = np.copy(readonly)
+assert independent.value.flags.writeable
+assert not np.shares_memory(independent.value, times.value)
+assert np.shape(np.flip(independent, axis=-1)) == (2, 3)
+assert np.ndim(independent) == 2 and np.size(independent, axis=0) == 2
+```
+
 ## Selection and clipping
 
 See [selection and clipping](numpy/selection.md) for `where`, `clip`,

{unitx-0.16.2 → unitx-0.16.4}/docs/typing.md

@@ -94,11 +94,17 @@ ufunc stubs preserve the wrapper at every intermediate call. For an explicit
 numerical boundary, use `np.expm1(np.asarray(q.value_in(si.one)))` after
 checking dimensions and normalizing the scale.
 
-The same NumPy stub limitation applies to `where`, `clip`,
+The same NumPy stub limitation applies to the supported shape transformations,
+broadcasting, rearrangement, repetition and copying,
+`where`, `clip`,
 `minimum/maximum`, `average`, `quantile`, `percentile`, the supported `nan*`
 statistics, and `interp`: runtime results
 preserve the documented Quantity/point wrappers, but NumPy may annotate them
 as ndarrays or Any. NumPy's `out` annotations also accept only ndarrays.
+The `moveaxis` and `rollaxis` input annotations likewise require ndarrays
+and can reject a Quantity/point argument during static checking, despite
+working at runtime. Their installed type consumers check the dispatch protocol
+directly; runtime tests use ordinary NumPy calls.
 Runtime support and installed-consumer checks cover
 these calls; unitx does not replace NumPy's stubs.
 

{unitx-0.16.2 → unitx-0.16.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'hatchling.build'
 
 [project]
 name = 'unitx'
-version = '0.16.2'
+version = '0.16.4'
 description = 'Physical units, quantities, and unit conversion with exact unit algebra, type hints, and NumPy integration.'
 readme = 'README.md'
 requires-python = '>=3.12'

{unitx-0.16.2 → unitx-0.16.4}/src/unitx/_numerics/numpy.py

@@ -598,12 +598,12 @@ def dispatch_function(
         return _clip(*args, **kwargs)
     if func is np.interp:
         return _interp(*args, **kwargs)
+    if func in (np.atleast_1d, np.atleast_2d, np.atleast_3d, np.broadcast_arrays):
+        return _multiple_arrays(func, *args, **kwargs)
     if args and isinstance(args[0], (Quantity, _Point)) and isinstance(args[0].unit, _Coordinate):
-        if func not in (
+        if func not in _ARRAY_FUNCTIONS and func not in (
             np.isclose,
             np.allclose,
-            np.reshape,
-            np.transpose,
             np.argmin,
             np.argmax,
             np.nanargmin,
@@ -754,6 +754,56 @@ def _transpose(q: Any, axes: Any = None) -> Any:
     return _wrap(np.transpose(q.value, axes), q.unit)
 
 
+def _squeeze(q: Any, axis: Any = None) -> Any:
+    return _wrap(np.squeeze(q.value, axis=axis), q.unit)
+
+
+def _expand_dims(q: Any, axis: Any) -> Any:
+    return _wrap(np.expand_dims(q.value, axis), q.unit)
+
+
+def _moveaxis(q: Any, source: Any, destination: Any) -> Any:
+    return _wrap(np.moveaxis(q.value, source, destination), q.unit)
+
+
+def _swapaxes(q: Any, axis1: Any, axis2: Any) -> Any:
+    return _wrap(np.swapaxes(q.value, axis1, axis2), q.unit)
+
+
+def _rollaxis(q: Any, axis: Any, start: Any = 0) -> Any:
+    return _wrap(np.rollaxis(q.value, axis, start), q.unit)
+
+
+def _ravel(q: Any, order: Literal['C', 'F', 'A', 'K'] = 'C') -> Any:
+    return _wrap(np.ravel(q.value, order=order), q.unit)
+
+
+def _array_transform(func: Any, q: Any, *args: Any, **kwargs: Any) -> Any:
+    """Transform storage without changing values, units or coordinates."""
+    return _wrap(func(q.value, *args, **kwargs), q.unit)
+
+
+def _array_metadata(func: Any, q: Any, *args: Any, **kwargs: Any) -> Any:
+    return func(q.value, *args, **kwargs)
+
+
+def _multiple_arrays(func: Any, *arrays: Any, **kwargs: Any) -> Any:
+    """Rearrange each operand independently, retaining bare and wrapped inputs."""
+    if not all(_is_supported_operand(x) for x in arrays):
+        return NotImplemented
+    values = tuple(
+        x.value if isinstance(x, (Quantity, _Point)) else _numeric_value(x) for x in arrays
+    )
+    result = func(*values, **kwargs)
+    if func is not np.broadcast_arrays and len(arrays) == 1:
+        source = arrays[0]
+        return _wrap(result, source.unit) if isinstance(source, (Quantity, _Point)) else result
+    return type(result)(
+        _wrap(raw, source.unit) if isinstance(source, (Quantity, _Point)) else raw
+        for raw, source in zip(result, arrays)
+    )
+
+
 def _interp(
     x: Any, xp: Any, fp: Any, left: Any = None, right: Any = None, period: Any = None
 ) -> Any:
@@ -1213,9 +1263,33 @@ def _extremum(
     return _write_output(_wrap(func(q.value, **kwargs), q.unit), out)
 
 
-_QUANTITY_FUNCTIONS = {
+_ARRAY_FUNCTIONS = {
     np.reshape: _reshape,
     np.transpose: _transpose,
+    np.squeeze: _squeeze,
+    np.expand_dims: _expand_dims,
+    np.moveaxis: _moveaxis,
+    np.swapaxes: _swapaxes,
+    np.rollaxis: _rollaxis,
+    np.ravel: _ravel,
+    np.matrix_transpose: partial(_array_transform, np.matrix_transpose),
+    np.linalg.matrix_transpose: partial(_array_transform, np.linalg.matrix_transpose),
+    np.broadcast_to: partial(_array_transform, np.broadcast_to),
+    np.flip: partial(_array_transform, np.flip),
+    np.fliplr: partial(_array_transform, np.fliplr),
+    np.flipud: partial(_array_transform, np.flipud),
+    np.rot90: partial(_array_transform, np.rot90),
+    np.roll: partial(_array_transform, np.roll),
+    np.repeat: partial(_array_transform, np.repeat),
+    np.tile: partial(_array_transform, np.tile),
+    np.copy: partial(_array_transform, np.copy),
+    np.shape: partial(_array_metadata, np.shape),
+    np.ndim: partial(_array_metadata, np.ndim),
+    np.size: partial(_array_metadata, np.size),
+}
+
+_QUANTITY_FUNCTIONS = {
+    **_ARRAY_FUNCTIONS,
     np.argmin: partial(_argmin_max, np.argmin),
     np.argmax: partial(_argmin_max, np.argmax),
     np.nanargmin: partial(_argmin_max, np.nanargmin),

unitx-0.16.4/tests/test_numpy_array_manipulation.py

@@ -0,0 +1,306 @@
+"""Array manipulation preserves each operand's unit and native storage rules."""
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Callable
+from typing import Any
+
+import pytest
+
+from unitx import AffineQuantity, LogQuantity, Quantity, Unit
+from unitx._numerics import Array
+from unitx.factor import Factor, pi
+
+np = pytest.importorskip('numpy')
+
+ArrayQuantity = Quantity[Array] | AffineQuantity[Array] | LogQuantity[Array]
+
+_TRANSFORMS = [
+    (np.matrix_transpose, (), {}),
+    (np.linalg.matrix_transpose, (), {}),
+    (np.permute_dims, (), {'axes': (1, 0)}),
+    (np.broadcast_to, ((4, 2, 3),), {'subok': True}),
+    (np.flip, (), {}),
+    (np.flip, (), {'axis': (0, -1)}),
+    (np.fliplr, (), {}),
+    (np.flipud, (), {}),
+    (np.rot90, (), {'k': -1, 'axes': (1, 0)}),
+    (np.rot90, (2,), {}),
+    (np.roll, (2,), {}),
+    (np.roll, (), {'shift': (1, -2), 'axis': (0, -1)}),
+    (np.repeat, (2,), {}),
+    (np.repeat, (), {'repeats': [0, 2, 1], 'axis': -1}),
+    (np.tile, ((2, 1, 3),), {}),
+    (np.copy, (), {}),
+]
+
+
+@pytest.fixture(params=['linear', 'affine', 'logarithmic'])
+def sample(request: pytest.FixtureRequest) -> ArrayQuantity:
+    values = np.arange(12, dtype=np.int16).reshape(2, 6)[:, ::2]
+    if request.param == 'linear':
+        return Quantity(values, Factor(2) * pi * Unit('cm'))
+    if request.param == 'affine':
+        return AffineQuantity(values, 'degC')
+    return LogQuantity(values, 'dBm')
+
+
+def _writeable_flag(value: Any) -> tuple[bool, tuple[tuple[type[Warning], str], ...]]:
+    # NumPy may warn when inspecting a broadcast view's writeability. Verify
+    # that wrapping retains those warnings instead of filtering them globally.
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter('always')
+        writeable = value.flags.writeable
+    return writeable, tuple((item.category, str(item.message)) for item in caught)
+
+
+def _check_result(result: Any, expected: Any, source: ArrayQuantity) -> None:
+    assert type(result) is type(source) and result.unit == source.unit
+    assert type(result.value) is type(expected)
+    assert result.value.dtype == expected.dtype
+    assert result.value.shape == expected.shape
+    assert result.value.strides == expected.strides
+    assert _writeable_flag(result.value) == _writeable_flag(expected)
+    assert np.shares_memory(result.value, source.value) == np.shares_memory(expected, source.value)
+    np.testing.assert_array_equal(result.value, expected)
+
+
+@pytest.mark.parametrize('operation,args,kwargs', _TRANSFORMS)
+@pytest.mark.parametrize('readonly', [False, True])
+def test_numpy_array_transform_storage(
+    sample: ArrayQuantity,
+    operation: Callable[..., Any],
+    args: tuple[object, ...],
+    kwargs: dict[str, object],
+    readonly: bool,
+) -> None:
+    sample.value.flags.writeable = not readonly
+    before = sample.value.copy()
+    expected = operation(sample.value, *args, **kwargs)
+    _check_result(operation(sample, *args, **kwargs), expected, sample)
+    np.testing.assert_array_equal(sample.value, before)
+
+
+@pytest.mark.parametrize(
+    'operation,args',
+    [
+        (np.matrix_transpose, ()),
+        (np.flip, ()),
+        (np.roll, (2,)),
+        (np.repeat, (0,)),
+        (np.tile, ((2, 1),)),
+        (np.copy, ()),
+        (np.broadcast_to, ((2, 0, 3),)),
+    ],
+)
+def test_numpy_array_transform_empty(
+    sample: ArrayQuantity, operation: Callable[..., Any], args: tuple[object, ...]
+) -> None:
+    q = type(sample)(np.empty((0, 3), dtype=np.float32), sample.unit)
+    _check_result(operation(q, *args), operation(q.value, *args), q)
+
+
+@pytest.mark.parametrize(
+    'operation,args',
+    [
+        (np.flip, ()),
+        (np.roll, (2,)),
+        (np.repeat, (3,)),
+        (np.tile, ((2, 1),)),
+        (np.copy, ()),
+        (np.broadcast_to, ((2, 3),)),
+        (np.atleast_1d, ()),
+        (np.atleast_2d, ()),
+        (np.atleast_3d, ()),
+    ],
+)
+@pytest.mark.parametrize('value', [2, np.float32(2), np.array(2, dtype=np.int16)])
+def test_numpy_array_transform_scalar(
+    sample: ArrayQuantity, operation: Callable[..., Any], args: tuple[object, ...], value: Any
+) -> None:
+    q = type(sample)(value, sample.unit)
+    _check_result(operation(q, *args), operation(value, *args), q)
+
+
+@pytest.mark.parametrize('operation', [np.atleast_1d, np.atleast_2d, np.atleast_3d])
+def test_numpy_atleast_single(sample: ArrayQuantity, operation: Callable[..., Any]) -> None:
+    _check_result(operation(sample), operation(sample.value), sample)
+
+
+@pytest.mark.parametrize(
+    'operation', [np.atleast_1d, np.atleast_2d, np.atleast_3d, np.broadcast_arrays]
+)
+@pytest.mark.parametrize('bare_first', [False, True])
+def test_numpy_multiple_arrays_independent_units(
+    operation: Callable[..., Any], bare_first: bool
+) -> None:
+    distance = Quantity(np.array([1, 2, 3]), Factor(2) * pi * Unit('cm'))
+    temperature = AffineQuantity(np.array([[10.0], [20]]), 'degC')
+    level = LogQuantity(np.array(30.0), 'dBm')
+    bare = np.array([4.0, 5, 6])
+    arrays = (
+        (bare, distance, temperature, level, 2)
+        if bare_first
+        else (distance, temperature, level, bare, 2)
+    )
+    values = tuple(
+        x.value if isinstance(x, (Quantity, AffineQuantity, LogQuantity)) else x for x in arrays
+    )
+    expected = operation(*values)
+    result = operation(*arrays)
+    assert type(result) is type(expected) and len(result) == len(arrays)
+    for actual, raw, source in zip(result, expected, arrays):
+        if isinstance(source, (Quantity, AffineQuantity, LogQuantity)):
+            _check_result(actual, raw, source)
+        else:
+            assert type(actual) is type(raw) and actual.dtype == raw.dtype
+            np.testing.assert_array_equal(actual, raw)
+
+
+@pytest.mark.parametrize('subok', [False, True])
+def test_numpy_broadcast_arrays_single(sample: ArrayQuantity, subok: bool) -> None:
+    expected = np.broadcast_arrays(sample.value, subok=subok)
+    result = np.broadcast_arrays(sample, subok=subok)
+    assert type(result) is type(expected) and len(result) == 1
+    _check_result(result[0], expected[0], sample)
+
+
+def test_numpy_broadcast_to_readonly(sample: ArrayQuantity) -> None:
+    result = np.broadcast_to(sample, (4, 2, 3))
+    assert np.shares_memory(result.value, sample.value)
+    with pytest.raises(ValueError, match='read-only'):
+        result[0, 0, 0] = type(sample)(1, sample.unit)
+
+
+@pytest.mark.parametrize(
+    'operation',
+    [
+        np.flip,
+        np.fliplr,
+        np.flipud,
+        np.rot90,
+        np.matrix_transpose,
+        np.linalg.matrix_transpose,
+        np.atleast_1d,
+        np.atleast_2d,
+        np.atleast_3d,
+    ],
+)
+def test_numpy_array_transform_shared_write(
+    sample: ArrayQuantity, operation: Callable[..., Any]
+) -> None:
+    result = operation(sample)
+    assert np.shares_memory(result.value, sample.value)
+    result.value[...] = 42
+    np.testing.assert_array_equal(sample.value, np.full(sample.shape, 42))
+
+
+@pytest.mark.parametrize('order', ['C', 'F', 'A', 'K'])
+@pytest.mark.parametrize('layout', ['C', 'F', 'transpose', 'strided', 'negative'])
+def test_numpy_copy_order(sample: ArrayQuantity, order: str, layout: str) -> None:
+    value = np.arange(12, dtype=np.int16).reshape(3, 4)
+    if layout == 'F':
+        value = np.asfortranarray(value)
+    elif layout == 'transpose':
+        value = value.T
+    elif layout == 'strided':
+        value = value[:, ::2]
+    elif layout == 'negative':
+        value = value[:, ::-1]
+    value.flags.writeable = False
+    q = type(sample)(value, sample.unit)
+    result = np.copy(q, order=order, subok=True)
+    _check_result(result, np.copy(value, order=order, subok=True), q)
+    assert result.value.flags.writeable and not np.shares_memory(result.value, value)
+    result.value[...] = -1
+    assert np.all(value >= 0)
+
+
+@pytest.mark.parametrize('value', [2, np.float32(2), np.array(2), np.empty((2, 0, 3))])
+def test_numpy_array_metadata(sample: ArrayQuantity, value: Any) -> None:
+    q = type(sample)(value, sample.unit)
+    assert np.shape(q) == np.shape(value)
+    assert np.ndim(q) == np.ndim(value)
+    assert np.size(q) == np.size(value)
+    assert type(np.shape(q)) is tuple
+    assert type(np.ndim(q)) is int
+    assert type(np.size(q)) is int
+    if np.ndim(value):
+        assert np.size(q, axis=-1) == np.size(value, axis=-1)
+        assert np.size(q, 0) == np.size(value, 0)
+
+
+@pytest.mark.parametrize(
+    'operation,args,error',
+    [
+        (np.broadcast_to, ((3, 2),), ValueError),
+        (np.flip, (3,), np.exceptions.AxisError),
+        (np.rot90, (1, (0, 0)), ValueError),
+        (np.roll, (1, 3), np.exceptions.AxisError),
+        (np.repeat, (-1,), ValueError),
+        (np.repeat, ([1, 2], -1), ValueError),
+        (np.tile, ((-1, 2),), ValueError),
+        (np.copy, ('invalid',), ValueError),
+        (np.size, (3,), IndexError),
+    ],
+)
+def test_numpy_array_transform_invalid(
+    sample: ArrayQuantity,
+    operation: Callable[..., Any],
+    args: tuple[object, ...],
+    error: type[Exception],
+) -> None:
+    before = sample.value.copy()
+    with pytest.raises(error):
+        operation(sample, *args)
+    np.testing.assert_array_equal(sample.value, before)
+
+
+@pytest.mark.parametrize('operation', [np.matrix_transpose, np.linalg.matrix_transpose, np.fliplr])
+def test_numpy_matrix_transform_invalid_rank(
+    sample: ArrayQuantity, operation: Callable[..., Any]
+) -> None:
+    q = type(sample)(np.array([1, 2]), sample.unit)
+    with pytest.raises(ValueError):
+        operation(q)
+
+
+def test_numpy_broadcast_arrays_invalid_shape(sample: ArrayQuantity) -> None:
+    with pytest.raises(ValueError, match='shape mismatch'):
+        np.broadcast_arrays(sample, np.ones(4))
+
+
+@pytest.mark.parametrize(
+    'operation', [np.atleast_1d, np.atleast_2d, np.atleast_3d, np.broadcast_arrays]
+)
+@pytest.mark.parametrize(
+    'value', [[1, 2, 3], np.array([object()], dtype=object), np.ma.array([1, 2, 3])]
+)
+def test_numpy_multiple_arrays_invalid_operand(
+    sample: ArrayQuantity, operation: Callable[..., Any], value: Any
+) -> None:
+    with pytest.raises(TypeError):
+        operation(sample, value)
+
+
+@pytest.mark.parametrize('operation,args,kwargs', _TRANSFORMS)
+def test_numpy_array_transform_invalid_keyword(
+    sample: ArrayQuantity,
+    operation: Callable[..., Any],
+    args: tuple[object, ...],
+    kwargs: dict[str, object],
+) -> None:
+    with pytest.raises(TypeError, match='unexpected keyword'):
+        operation(sample, *args, **kwargs, out=sample)
+
+
+@pytest.mark.parametrize(
+    'operation',
+    [np.atleast_1d, np.atleast_2d, np.atleast_3d, np.broadcast_arrays, np.shape, np.ndim, np.size],
+)
+def test_numpy_array_function_invalid_keyword(
+    sample: ArrayQuantity, operation: Callable[..., Any]
+) -> None:
+    with pytest.raises(TypeError, match='unexpected keyword'):
+        operation(sample, out=sample)