unitx 0.16.0__tar.gz → 0.16.2__tar.gz

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

@@ -93,6 +93,38 @@ def check_arrays(values: NDArray[np.float64]) -> None:
     assert_type(median_target.value.dtype, np.dtype[np.float64])
     np.testing.assert_allclose(median_target.value, 2000)
 
+    gapped = Quantity(np.array([1.0, np.nan, 3]), si.m)
+    for operation in (
+        np.nanmean,
+        np.nanmedian,
+        np.nanstd,
+        np.nanvar,
+        np.nanmin,
+        np.nanmax,
+        np.nansum,
+    ):
+        result = cast(Quantity[Array], operation(gapped))
+        assert isinstance(result, Quantity)
+        assert result.unit == (si.m**2 if operation is np.nanvar else si.m)
+        np.testing.assert_allclose(result.value, operation(gapped.value))
+    product = cast(Quantity[Array], np.nanprod(gapped))
+    assert isinstance(product, Quantity) and product.unit == si.m**2
+    np.testing.assert_allclose(product.value, 3)
+    for operation in (np.nanargmin, np.nanargmax):
+        indices = np.empty((), dtype=np.intp)
+        assert operation(gapped, out=indices) is indices
+        assert_type(indices.dtype, np.dtype[np.intp])
+        np.testing.assert_array_equal(indices, operation(gapped.value))
+    for operation, probability in ((np.nanquantile, 0.5), (np.nanpercentile, 50)):
+        result = cast(Quantity[Array], operation(gapped, probability))
+        assert isinstance(result, Quantity) and result.unit == si.m
+        np.testing.assert_allclose(result.value, 2)
+        gapped.__array_function__(
+            operation, (Quantity,), (gapped, probability), {'out': median_target}
+        )
+        np.testing.assert_allclose(median_target.value, 200)
+    assert_type(median_target.value.dtype, np.dtype[np.float64])
+
     sample_time = Quantity(np.array([0.0, 1, 3]), si.s)
     sample_current = Quantity(np.array([0.0, 2, 6]), si.A)
     grid = Quantity(np.array([0.0, 500, 1000, 2000, 3000]), si.ms)

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

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [0.16.2] - 2026-10-25
+
+### Added
+
+- Support NumPy `nanmin`, `nanmax`, `nanargmin` and `nanargmax`, preserving
+  units or point coordinates for extrema and returning bare indices. Retain
+  NumPy's all-NaN warnings/errors and stage output writes before mutation.
+- Support `nansum` with the existing sum unit, initial and mask rules, and
+  `nanprod` with unit powers determined by selected non-NaN element counts.
+  Dimensional product slices require equal counts; dimensionless products
+  normalize to coherent values and may have different counts.
+
+## [0.16.1] - 2026-10-25
+
+### Added
+
+- Support NumPy `nanmean`, `nanmedian`, `nanstd`, `nanvar`, `nanquantile` and
+  `nanpercentile`, retaining the corresponding statistical unit and coordinate
+  rules. Omit NaN samples with NumPy's dtype, mask, weight and warning behavior;
+  preserve staged output writes, including when warnings become exceptions.
+  Weighted NaN quantiles support one integer axis or `axis=None`, with full-shape
+  weights for multidimensional samples, due to NumPy 2.1/2.5 kernel limitations.
+
 ## [0.16.0] - 2026-10-25
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unitx
-Version: 0.16.0
+Version: 0.16.2
 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.0 → unitx-0.16.2}/docs/numpy/selection.md

@@ -50,9 +50,27 @@ Empty reductions, axes, NaNs and `keepdims` follow NumPy. These reductions
 write the exact result shape to `out`; elementwise selection and clipping
 allow the ufunc output broadcasting rules.
 
+`np.nanmin/max` share the same unit, point, mask, initial and output rules,
+while omitting NaNs. An all-NaN slice returns NaN and emits RuntimeWarning;
+an empty reduction still needs an initial value. A warning promoted to an
+exception leaves `out` unchanged.
+
+`np.argmin/argmax` and `np.nanargmin/nanargmax` return bare indices and accept
+one integer axis or `axis=None`, `keepdims`, and a bare integer ndarray `out`
+of exactly the result shape. They also accept affine and logarithmic points
+and operate on stored readings. The NaN variants omit NaNs and raise
+ValueError for all-NaN slices before writing `out`. NumPy's caveat remains:
+`nanargmin` results cannot be trusted for slices containing only NaNs and
+positive infinity; the corresponding `nanargmax` case is NaNs and negative
+infinity. unitx delegates these numerical choices to NumPy.
+
 See NumPy's [where](https://numpy.org/doc/stable/reference/generated/numpy.where.html),
 [clip](https://numpy.org/doc/stable/reference/generated/numpy.clip.html) and
 [minimum](https://numpy.org/doc/stable/reference/generated/numpy.minimum.html)
 references for the underlying numerical behavior.
+See also [nanmin](https://numpy.org/doc/stable/reference/generated/numpy.nanmin.html),
+[nanargmin](https://numpy.org/doc/stable/reference/generated/numpy.nanargmin.html)
+and [nanargmax](https://numpy.org/doc/stable/reference/generated/numpy.nanargmax.html)
+for NaN and infinity behavior.
 
 [NumPy overview and support matrix](../numpy.md) · [Documentation index](../README.md)

{unitx-0.16.0 → unitx-0.16.2}/docs/numpy/statistics.md

@@ -106,7 +106,8 @@ with the additional single-unit and explicit-output rules described here.
 their first, positional argument. Results retain its complete unit, including
 an exact extra scale or a scaled dimensionless unit. AffineQuantity and
 LogQuantity points are unsupported; convert explicitly before using these
-functions. The `nan*` variants remain unsupported.
+functions. `nanquantile` and `nanpercentile` share these boundaries and omit
+NaN samples as described [below](#nan-statistics).
 
 Weights and the `q` parameter must be dimensionless: use bare numeric scalars,
 plain numeric ndarrays, numeric lists/tuples, or dimensionless Quantities.
@@ -188,4 +189,87 @@ See [NumPy average](https://numpy.org/doc/stable/reference/generated/numpy.avera
 for the numerical definitions. unitx adds the unit, parameter and output rules
 described here and uses the installed NumPy kernel.
 
+## NaN statistics
+
+`nansum` omits NaN samples and otherwise shares `sum`'s unit, `axis`, `dtype`,
+`keepdims`, `where`, scalar `initial` and staged `out` rules. All-NaN, empty
+and fully masked slices return zero in the input unit, or the converted
+initial when supplied. Affine and logarithmic point sums remain undefined.
+
+`nanprod` shares `prod`'s options and initial-unit rules. For dimensional
+input U, its unit is `U**N * initial.unit`, where N counts elements selected
+by `where` that are **not NaN**. Zero and infinity still count. All result
+slices must have equal N, even when a zero initial makes their magnitudes
+equal; otherwise DimensionError is raised before writing `out`. All-NaN,
+empty and fully masked slices have N = 0, with value 1 and unit `Unit()`
+before applying initial. When the output has no elements, use `prod`'s
+nominal-extent convention. Dimensionless inputs normalize to coherent values
+first, so unequal non-NaN counts are allowed. Point products remain undefined.
+NaN initial values are passed through to NumPy; they are not omitted.
+
+`nanmean`, `nanmedian`, `nanstd`, `nanvar`, `nanquantile`, and `nanpercentile`
+omit NaN samples. Their units, supported options, parameter normalization and
+staged `out` writes match the corresponding functions above. Sample units,
+including exact extra scales and scaled dimensionless units, stay unchanged;
+`nanvar` squares the complete input unit.
+
+`nanmean` and `nanmedian` also accept AffineQuantity and LogQuantity points,
+returning points in the same coordinate. `nanstd` returns the coordinate's
+full difference unit, and `nanvar` its square. Logarithmic point statistics
+operate on stored readings; convert to physical quantities explicitly for
+power or amplitude statistics. `nanquantile` and `nanpercentile` accept only
+linear Quantities, following quantile and percentile.
+
+`nanmean`, `nanstd`, and `nanvar` accept bare boolean `where` masks; NaN samples
+are omitted from the selected elements. For `nanstd` and `nanvar`, N in
+`N - ddof` is the selected non-NaN count. Precomputed `mean`, `correction` and
+`initial` remain unsupported. `nanmedian`, `nanquantile` and `nanpercentile`
+reject `overwrite_input=True`, and do not accept `where` or `dtype`.
+Weighted NaN quantiles require `method="inverted_cdf"`; a NaN sample and its
+associated weight are omitted together. Weights themselves are not cleaned.
+Weighted NaN quantiles accept one integer axis or `axis=None`; tuple axes
+are unsupported. For multidimensional samples, supply weights with the full
+sample shape; reduced-axis weight shapes are rejected. NumPy 2.1 mishandles
+weighted tuple axes, and NumPy 2.1 and 2.5's NaN kernels do not reliably handle
+reduced-axis weights. Broadcast weights explicitly to the full sample shape
+before calling. One-dimensional samples accept a matching weight vector as
+usual. Unweighted NaN quantiles and ordinary quantile/percentile retain tuple
+axis support; ordinary quantile/percentile also retain reduced-axis weights.
+
+NumPy determines dtype, complex-sample support, Inf behavior, empty/all-NaN
+results and RuntimeWarnings. unitx does not suppress these warnings. If a
+warning is promoted to an exception, the staged output target stays unchanged.
+Ordinary statistics continue to propagate NaNs.
+
+```python
+gapped = Quantity(np.array([[1.0, np.nan, 3], [np.nan, 5, 7]]), 'm')
+means = np.nanmean(gapped, axis=1)
+assert means.unit == gapped.unit
+np.testing.assert_allclose(means.value, [2, 6])
+variances = np.nanvar(gapped, axis=1, ddof=1)
+assert variances.unit == Unit('m2')
+np.testing.assert_allclose(variances.value, [2, 2])
+medians = np.nanpercentile(gapped, 50, axis=1)
+np.testing.assert_allclose(medians.value, [2, 6])
+totals = np.nansum(gapped, axis=1)
+assert totals.unit == Unit('m')
+np.testing.assert_array_equal(totals.value, [4, 12])
+areas = np.nanprod(gapped, axis=1)
+assert areas.unit == Unit('m2')
+np.testing.assert_array_equal(areas.value, [3, 35])
+minima = np.nanmin(gapped, axis=1)
+assert minima.unit == Unit('m')
+np.testing.assert_array_equal(minima.value, [1, 5])
+np.testing.assert_array_equal(np.nanargmax(gapped, axis=1), [2, 2])
+```
+
+See [NumPy nanmean](https://numpy.org/doc/stable/reference/generated/numpy.nanmean.html),
+[nanstd](https://numpy.org/doc/stable/reference/generated/numpy.nanstd.html) and
+[nanquantile](https://numpy.org/doc/stable/reference/generated/numpy.nanquantile.html)
+for the numerical definitions and warnings.
+The [nansum](https://numpy.org/doc/stable/reference/generated/numpy.nansum.html)
+and [nanprod](https://numpy.org/doc/stable/reference/generated/numpy.nanprod.html)
+kernels determine NaN identities and accumulator behavior, with unitx's
+additional single-unit rules above.
+
 [NumPy overview and support matrix](../numpy.md) · [Documentation index](../README.md)

{unitx-0.16.0 → unitx-0.16.2}/docs/numpy/writes.md

@@ -125,7 +125,7 @@ length target. `Unit` factors participate in the conversion. Every numeric
 result, including a coherent or scaled dimensionless result, requires a Quantity
 target; writing it to a bare ndarray would discard its unit. Boolean predicates
 and comparisons instead accept only a bare boolean ndarray output.
-`argmin` and `argmax` accept only a bare integer ndarray output, with the
+`argmin`, `argmax`, `nanargmin` and `nanargmax` accept only a bare integer ndarray output, with the
 same exact shape requirement as other function outputs.
 
 Final casting uses `casting='same_kind'` by default, or the explicitly requested

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

@@ -116,18 +116,18 @@ functions, including exp/log. Python scalar numerical semantics remain native.
 | --- | --- | --- |
 | reshape, transpose | Preserve unit | shape/order/copy; axes |
 | concatenate, stack | Convert to first Quantity's unit; bare arrays remain dimensionless | axis, dtype, casting, out; dtype and out are mutually exclusive |
-| sum | Preserve unit | axis, dtype, keepdims, initial, where, out |
-| mean | Preserve unit | axis, dtype, keepdims, where, out |
-| min/amin, max/amax | Preserve unit or point coordinate | axis, keepdims, initial, where, out |
+| sum, nansum | Preserve unit | axis, dtype, keepdims, initial, where, out |
+| mean, nanmean | Preserve unit or point coordinate | axis, dtype, keepdims, where, out |
+| min/amin/nanmin, max/amax/nanmax | Preserve unit or point coordinate | axis, keepdims, initial, where, out |
 | where | Select between compatible quantities or points | condition, x, y, all positional; no out |
 | clip | Preserve input unit or point coordinate | a_min/a_max or min/max, out; ufunc call options |
-| prod | Product unit rules below | axis, dtype, keepdims, initial, where, out |
-| median | Preserve unit | axis, keepdims, out; overwrite_input=False |
-| std, var | Preserve unit / square unit | axis, dtype, ddof, keepdims, where, out |
+| prod, nanprod | Product unit rules below; nanprod counts selected non-NaN elements | axis, dtype, keepdims, initial, where, out |
+| median, nanmedian | Preserve unit or point coordinate | axis, keepdims, out; overwrite_input=False |
+| std/nanstd, var/nanvar | Difference unit / square difference unit | axis, dtype, ddof, keepdims, where, out |
 | average | Preserve sample unit; returned weight sum is a dimensionless Quantity | axis, weights, returned, keepdims; linear Quantity only |
-| quantile, percentile | Preserve sample unit; dimensionless q and weights | axis, out, method, keepdims, weights; overwrite_input=False; linear Quantity only |
+| quantile, percentile, nanquantile, nanpercentile | Preserve sample unit; dimensionless q and weights | axis, out, method, keepdims, weights; overwrite_input=False; linear Quantity only |
 | cumsum | Preserve unit | axis, dtype, out |
-| argmin, argmax | Bare indices | axis, keepdims, out |
+| argmin/nanargmin, argmax/nanargmax | Bare indices | axis, keepdims, out |
 | interp | Align x to xp's unit; retain fp's unit | finite strictly increasing 1-D xp; scalar left/right, period=None; no out |
 | trapezoid | Multiply ordinate and coordinate units | x, scalar dx, axis; no out |
 | diff | Preserve input unit | n, axis, prepend, append; no out |
@@ -138,8 +138,9 @@ Supply the first magnitude argument positionally; concatenate/stack take a
 sequence. Options follow each supported signature, including positional out
 checks. Function and reduction outputs follow the rules below;
 overwrite_input=True is rejected. Reduction/statistical `where` is supported
-for sum, mean, std, var, add.reduce, prod, multiply.reduce, and min/max; `initial` is
-supported for sum/add.reduce, prod/multiply.reduce, and min/max. Precomputed `mean`,
+for sum/nansum, mean/nanmean, std/nanstd, var/nanvar, add.reduce, prod/nanprod,
+multiply.reduce, and min/max/nanmin/nanmax; `initial` is supported for
+sum/nansum/add.reduce, prod/nanprod/multiply.reduce, and min/max/nanmin/nanmax. Precomputed `mean`,
 `correction`, and other unsupported keywords raise TypeError.
 Indexed assignment and augmented arithmetic on ndarrays follow the fixed-target
 rules below. Python and NumPy scalar magnitudes retain ordinary result/rebinding
@@ -149,6 +150,7 @@ behavior for augmented arithmetic.
 
 See [selection and clipping](numpy/selection.md) for `where`, `clip`,
 `minimum/maximum`, and `min/max`, including coordinate and bound rules.
+The NaN extrema and index functions share those coordinate rules and omit NaNs.
 
 ## Indexed assignment and augmented arithmetic
 
@@ -164,6 +166,8 @@ See [integration, differences and gradients](numpy/calculus.md) for
 
 See [reductions and statistics](numpy/statistics.md#masked-sums-and-statistics)
 for sum, mean, standard deviation, variance, initial values and input masks.
+The [NaN statistics](numpy/statistics.md#nan-statistics) omit NaN samples using
+the same unit and output rules as their ordinary counterparts.
 
 ## Product reductions
 

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

@@ -95,7 +95,8 @@ 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`,
-`minimum/maximum`, `average`, `quantile`, `percentile`, and `interp`: runtime results
+`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.
 Runtime support and installed-consumer checks cover

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

@@ -4,7 +4,7 @@ build-backend = 'hatchling.build'
 
 [project]
 name = 'unitx'
-version = '0.16.0'
+version = '0.16.2'
 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.0 → unitx-0.16.2}/src/unitx/_numerics/numpy.py

@@ -403,7 +403,7 @@ def _dispatch_ufunc(
         }:
             return NotImplemented
         handler = _sum if ufunc is np.add else _prod
-        return handler(inputs[0], **{'axis': 0, **kwargs})
+        return handler(ufunc.reduce, inputs[0], **{'axis': 0, **kwargs})
     if method == 'accumulate' and ufunc is np.add:
         if kwargs.keys() - {'axis', 'dtype'}:
             return NotImplemented
@@ -606,14 +606,22 @@ def dispatch_function(
             np.transpose,
             np.argmin,
             np.argmax,
+            np.nanargmin,
+            np.nanargmax,
             np.median,
             np.mean,
             np.std,
             np.var,
+            np.nanmedian,
+            np.nanmean,
+            np.nanstd,
+            np.nanvar,
             np.min,
             np.max,
             np.amin,
             np.amax,
+            np.nanmin,
+            np.nanmax,
         ):
             raise TypeError(
                 'This NumPy function is undefined for affine points; convert explicitly.'
@@ -854,11 +862,17 @@ def _argmin_max(
 
 
 def _median(
-    q: Any, axis: Any = None, out: Any = None, overwrite_input: bool = False, keepdims: bool = False
+    func: Any,
+    q: Any,
+    axis: Any = None,
+    out: Any = None,
+    overwrite_input: bool = False,
+    keepdims: bool = False,
 ) -> Any:
     if overwrite_input:
-        raise TypeError('overwrite_input is not supported for Quantity.')
-    return _write_output(_wrap(np.median(q.value, axis=axis, keepdims=keepdims), q.unit), out)
+        error_message = 'overwrite_input is not supported for Quantity.'
+        raise TypeError(error_message)
+    return _write_output(_wrap(func(q.value, axis=axis, keepdims=keepdims), q.unit), out)
 
 
 def _cumsum(q: Any, axis: Any = None, dtype: Any = None, out: Any = None) -> Any:
@@ -867,6 +881,7 @@ def _cumsum(q: Any, axis: Any = None, dtype: Any = None, out: Any = None) -> Any
 
 
 def _mean(
+    func: Any,
     q: Any,
     axis: Any = None,
     dtype: Any = None,
@@ -877,7 +892,7 @@ def _mean(
 ) -> Any:
     _validate_dtype(dtype)
     _validate_where({'where': where})
-    result = _wrap(np.mean(q.value, axis=axis, dtype=dtype, keepdims=keepdims, where=where), q.unit)
+    result = _wrap(func(q.value, axis=axis, dtype=dtype, keepdims=keepdims, where=where), q.unit)
     return _write_output(result, out)
 
 
@@ -931,15 +946,26 @@ def _quantile(
         error_message = 'overwrite_input is not supported for Quantity.'
         raise TypeError(error_message)
     q = _statistic_parameter(q, 'q')
+    value = _numeric_value(a.value)
     if weights is not None:
         weights = _statistic_parameter(weights, 'weights')
-    result = func(
-        _numeric_value(a.value), q, axis=axis, method=method, keepdims=keepdims, weights=weights
-    )
+        if func in (np.nanquantile, np.nanpercentile):
+            # NumPy 2.1 mishandles tuple axes with weights; its NaN kernels
+            # also index reduced-axis weights without broadcasting in 2.1/2.5.
+            if isinstance(axis, tuple):
+                error_message = 'Weighted NaN quantiles require one integer axis or axis=None.'
+                raise TypeError(error_message)
+            if np.ndim(value) > 1 and axis is not None and np.shape(weights) != np.shape(value):
+                error_message = (
+                    'NaN quantiles require full-shape weights for multidimensional samples.'
+                )
+                raise ValueError(error_message)
+    result = func(value, q, axis=axis, method=method, keepdims=keepdims, weights=weights)
     return _write_output(Quantity(result, a.unit), out)
 
 
 def _sum(
+    func: Any,
     q: Any,
     axis: Any = None,
     dtype: Any = None,
@@ -954,33 +980,34 @@ def _sum(
     initial_value = None
     if initial is not None:
         if not _is_supported_operand(initial):
-            raise TypeError('initial must be a numeric scalar or scalar Quantity.')
+            error_message = 'initial must be a numeric scalar or scalar Quantity.'
+            raise TypeError(error_message)
         initial_value, initial_unit = _linear_parts(initial)
         if np.ndim(initial_value) != 0:
-            raise TypeError('initial must be a numeric scalar or scalar Quantity.')
+            error_message = 'initial must be a numeric scalar or scalar Quantity.'
+            raise TypeError(error_message)
         if not compatible(initial_unit, unit):
             # Bare zero is the additive identity in any dimension. A Quantity
             # zero still has its declared dimension and must be compatible.
             if isinstance(initial, (Quantity, _Point)) or initial != 0:
-                raise DimensionError('initial has an incompatible dimension.')
+                error_message = 'initial has an incompatible dimension.'
+                raise DimensionError(error_message)
         else:
             initial_value = scale_magnitude(initial_value, initial_unit.factor / unit.factor)
     result = _wrap(
-        np.add.reduce(
-            value, axis=axis, dtype=dtype, keepdims=keepdims, initial=initial_value, where=where
-        ),
+        func(value, axis=axis, dtype=dtype, keepdims=keepdims, initial=initial_value, where=where),
         unit,
     )
     return _write_output(result, out)
 
 
 def _prod(
+    func: Any,
     q: Any,
     axis: Any = None,
     dtype: Any = None,
     out: Any = None,
     keepdims: bool = False,
-    *,
     initial: Any = 1,
     where: Any = True,
 ) -> Any:
@@ -989,10 +1016,12 @@ def _prod(
     initial_value, initial_unit = None, Unit()
     if initial is not None:
         if not _is_supported_operand(initial):
-            raise TypeError('initial must be a numeric scalar or scalar Quantity.')
+            error_message = 'initial must be a numeric scalar or scalar Quantity.'
+            raise TypeError(error_message)
         initial_value, initial_unit = _linear_parts(initial)
         if np.ndim(initial_value) != 0:
-            raise TypeError('initial must be a numeric scalar or scalar Quantity.')
+            error_message = 'initial must be a numeric scalar or scalar Quantity.'
+            raise TypeError(error_message)
 
     value, unit = _linear_parts(q)
     mask = np.broadcast_to(where, np.shape(value))
@@ -1000,7 +1029,7 @@ def _prod(
     if unit.dimension == DIMENSIONLESS:
         value = scale_magnitude(value, unit.factor, where=mask)
         unit = Unit()
-    result = np.multiply.reduce(
+    result = func(
         value, axis=axis, dtype=dtype, keepdims=keepdims, initial=initial_value, where=where
     )
     if unit.dimension != DIMENSIONLESS:
@@ -1008,16 +1037,17 @@ def _prod(
         axes = range(len(shape)) if axis is None else axis if isinstance(axis, tuple) else (axis,)
         # NumPy has already validated axes, including its scalar 0/-1 special case.
         count = math.prod(shape[i] for i in axes) if shape else 1
+        if func is np.nanprod:
+            mask = mask & ~np.isnan(value)
         if np.ndim(where) == 0:
             count = count if bool(where) else 0
-        else:
+        if np.ndim(where) != 0 or func is np.nanprod:
             counts = np.sum(mask, axis=axis)
             if np.size(counts):
                 count = int(np.asarray(counts).flat[0])
                 if np.any(counts != count):
-                    raise DimensionError(
-                        'Product reductions require equal element counts per result.'
-                    )
+                    error_message = 'Product reductions require equal element counts per result.'
+                    raise DimensionError(error_message)
             # With no output elements, retain the nominal reduction extent.
         unit = unit**count
     assert isinstance(unit, Unit) and isinstance(initial_unit, Unit)
@@ -1038,7 +1068,7 @@ def _std_var(
     _validate_dtype(dtype)
     _validate_where({'where': where})
     delta = q.unit.delta_unit if isinstance(q.unit, _Coordinate) else q.unit
-    unit = delta**2 if func is np.var else delta
+    unit = delta**2 if func in (np.var, np.nanvar) else delta
     result = _wrap(
         func(q.value, axis=axis, dtype=dtype, ddof=ddof, keepdims=keepdims, where=where), unit
     )
@@ -1170,7 +1200,6 @@ def _extremum(
     axis: Any = None,
     out: Any = None,
     keepdims: bool = False,
-    *,
     initial: Any = _UNSET,
     where: Any = True,
 ) -> Any:
@@ -1189,18 +1218,30 @@ _QUANTITY_FUNCTIONS = {
     np.transpose: _transpose,
     np.argmin: partial(_argmin_max, np.argmin),
     np.argmax: partial(_argmin_max, np.argmax),
-    np.median: _median,
+    np.nanargmin: partial(_argmin_max, np.nanargmin),
+    np.nanargmax: partial(_argmin_max, np.nanargmax),
+    np.median: partial(_median, np.median),
+    np.nanmedian: partial(_median, np.nanmedian),
     np.cumsum: _cumsum,
-    np.prod: _prod,
+    np.prod: partial(_prod, np.multiply.reduce),
+    np.nanprod: partial(_prod, np.nanprod),
     np.std: partial(_std_var, np.std),
     np.var: partial(_std_var, np.var),
-    np.sum: _sum,
-    np.mean: _mean,
+    np.nanstd: partial(_std_var, np.nanstd),
+    np.nanvar: partial(_std_var, np.nanvar),
+    np.sum: partial(_sum, np.add.reduce),
+    np.nansum: partial(_sum, np.nansum),
+    np.mean: partial(_mean, np.mean),
+    np.nanmean: partial(_mean, np.nanmean),
     np.average: _average,
     np.quantile: partial(_quantile, np.quantile),
     np.percentile: partial(_quantile, np.percentile),
+    np.nanquantile: partial(_quantile, np.nanquantile),
+    np.nanpercentile: partial(_quantile, np.nanpercentile),
     np.min: partial(_extremum, np.min),
     np.max: partial(_extremum, np.max),
     np.amin: partial(_extremum, np.amin),
     np.amax: partial(_extremum, np.amax),
+    np.nanmin: partial(_extremum, np.nanmin),
+    np.nanmax: partial(_extremum, np.nanmax),
 }

{unitx-0.16.0 → unitx-0.16.2}/tests/numpy_typing/check_numpy.py

@@ -119,17 +119,27 @@ def output_contracts(a: npt.NDArray[np.float64]) -> None:
     scalar_target = Quantity(np.empty(()), 'cm')
     q.__array_ufunc__(np.add, 'reduce', q, out=(scalar_target,))
     q.__array_function__(np.sum, (Quantity,), (q,), {'out': scalar_target})
-    for operation in (np.quantile, np.percentile):
+    for operation in (np.quantile, np.percentile, np.nanquantile, np.nanpercentile):
         q.__array_function__(operation, (Quantity,), (q, 0.5), {'out': scalar_target})
     mask = np.array([True, False, True])
     q.__array_ufunc__(
         np.add, 'reduce', q, out=(scalar_target,), where=mask, initial=Quantity(2, 'cm')
     )
-    for operation in (np.sum, np.mean, np.std):
+    for operation in (np.sum, np.nansum, np.mean, np.std, np.nanmean, np.nanstd):
         q.__array_function__(operation, (Quantity,), (q,), {'where': mask, 'out': scalar_target})
-    q.__array_function__(
-        np.var, (Quantity,), (q,), {'where': mask, 'out': Quantity(np.empty(()), 'm2')}
-    )
+    for operation in (np.nanmin, np.nanmax):
+        q.__array_function__(
+            operation, (Quantity,), (q,), {'initial': Quantity(0, 'cm'), 'out': scalar_target}
+        )
+    for operation in (np.nanargmin, np.nanargmax):
+        indices = np.empty((), dtype=np.intp)
+        q.__array_function__(operation, (Quantity,), (q,), {'out': indices})
+        assert_type(indices.dtype, np.dtype[np.intp])
+    q.__array_function__(np.nanmedian, (Quantity,), (q,), {'out': scalar_target})
+    for operation in (np.var, np.nanvar):
+        q.__array_function__(
+            operation, (Quantity,), (q,), {'where': mask, 'out': Quantity(np.empty(()), 'm2')}
+        )
     q.__array_function__(np.diff, (Quantity,), (q,), {'prepend': Quantity(2, 'cm')})
     q.__array_function__(np.gradient, (Quantity,), (q, Quantity(2, 's')), {'axis': 0})
     product_target = Quantity(np.empty(()), 'm2')
@@ -142,6 +152,7 @@ def output_contracts(a: npt.NDArray[np.float64]) -> None:
         (q,),
         {'initial': Quantity(2, 's'), 'out': Quantity(np.empty(()), 'm2 s')},
     )
+    q.__array_function__(np.nanprod, (Quantity,), (q,), {'where': mask, 'out': product_target})
     assert_type(product_target.value.dtype, np.dtype[np.float64])
     assert_type(scalar_target.value.dtype, np.dtype[np.float64])
     assert_type(widened.value, Array)

{unitx-0.16.0 → unitx-0.16.2}/tests/test_numpy_affine.py

@@ -71,8 +71,10 @@ def test_numpy_add_sub_and_comparison() -> None:
     'func',
     [
         np.sum,
+        np.nansum,
         np.cumsum,
         np.prod,
+        np.nanprod,
         np.exp,
         np.log,
         np.sin,