Support more numpy functions (#2210)

* support linalg.diagonal, diag, linalg.eigvals

* support linalg.eigvalsh, linalg.matrix_norm, linalg.vector_norm

* support vander, linalg.matrix_transpose, tril, triu, linalg.lstsq

* if numpy's submodule doesn't contain a certain function, ignore it

* add tests

* vector_norm and matrix_norm only supports numpy 2.0+

* CHANGES, don't support inv for now

Author: oxygen-dioxide

CHANGES

@@ -7,6 +7,7 @@ Pint Changelog
 - Fix raising exception in `Quantity.from_tuple` with invalid units (#2199)
 - Add devcontainer.json to add GitHub Codespace support (#2208)
 - Add support for `numpy.geomspace` (#2206)
+- Add support for `linalg.diagonal`, `linalg.matrix_transpose`, `diag`, `tril`, `triu`, `linalg.eigvals`, `linalg.eigvalsh`, `linalg.matrix_norm` and `linalg.vector_norm` (#2210)
 
 
 0.25.0 (2025-08-25)

pint/facets/numpy/numpy_func.py

@@ -284,7 +284,9 @@ def implement_func(func_type, func_str, input_units=None, output_unit=None):
     if func is None:
         return
     for func_str_piece in func_str_split[1:]:
-        func = getattr(func, func_str_piece)
+        func = getattr(func, func_str_piece, None)
+        if func is None:
+            return
 
     @implements(func_str, func_type)
     def implementation(*args, **kwargs):
@@ -885,6 +887,7 @@ def implementation(*args, **kwargs):
     ("moveaxis", "a", True),
     ("around", "a", True),
     ("diagonal", "a", True),
+    ("linalg.diagonal", "x", True),
     ("mean", "a", True),
     ("ptp", "a", True),
     ("ravel", "a", True),
@@ -894,6 +897,7 @@ def implementation(*args, **kwargs):
     ("median", "a", True),
     ("nanmedian", "a", True),
     ("transpose", "a", True),
+    ("linalg.matrix_transpose", "x", True),
     ("roll", "a", True),
     ("copy", "a", True),
     ("average", "a", True),
@@ -1050,10 +1054,17 @@ def implementation(a, *args, **kwargs):
 # Handle functions with output unit defined by operation
 for func_str in (
     "sum",
+    "diag",
+    "tril",
+    "triu",
     "nansum",
     "cumsum",
     "nancumsum",
     "linalg.norm",
+    "linalg.eigvals",
+    "linalg.eigvalsh",
+    "linalg.matrix_norm",
+    "linalg.vector_norm",
 ):
     implement_func("function", func_str, input_units=None, output_unit="sum")
 for func_str in ("diff", "ediff1d", "std", "nanstd"):

pint/testsuite/test_numpy.py

@@ -139,6 +139,13 @@ def test_transpose_numpy_func(self):
             np.transpose(self.q), [[1, 3], [2, 4]] * self.ureg.m
         )
 
+    @helpers.requires_array_function_protocol()
+    @helpers.requires_numpy_at_least("2.0")
+    def test_linalg_matrix_transpose(self):
+        helpers.assert_quantity_equal(
+            np.linalg.matrix_transpose(self.q), [[1, 3], [2, 4]] * self.ureg.m
+        )
+
     @helpers.requires_array_function_protocol()
     def test_flip_numpy_func(self):
         helpers.assert_quantity_equal(
@@ -576,6 +583,25 @@ def test_exponentiation_array_exp_2(self):
         with pytest.raises(DimensionalityError):
             op.ipow(arr_cp, q_cp)
 
+    # Advanced matrix operations
+    def test_eigvals(self):
+        q = [[2, 1], [1, 2]] * self.ureg.m
+        helpers.assert_quantity_equal(np.linalg.eigvals(q), [3, 1] * self.ureg.m)
+
+    def test_eigvals_offset(self):
+        q = self.Q_([[2, 1], [1, 2]], self.ureg.degC)
+        with pytest.raises(OffsetUnitCalculusError):
+            np.linalg.eigvals(q)
+
+    def test_eigvalsh(self):
+        q = [[5 + 2j, 9 - 2j], [0 + 2j, 2 - 1j]] * self.ureg.m
+        helpers.assert_quantity_equal(np.linalg.eigvalsh(q), [1, 6] * self.ureg.m)
+
+    def test_eigvalsh_offset(self):
+        q = self.Q_([[5 + 2j, 9 - 2j], [0 + 2j, 2 - 1j]], self.ureg.degC)
+        with pytest.raises(OffsetUnitCalculusError):
+            np.linalg.eigvalsh(q)
+
 
 class TestNumpyUnclassified(TestNumpyMethods):
     def test_tolist(self):
@@ -650,6 +676,53 @@ def test_diagonal_numpy_func(self):
         q = [[1, 2, 3], [1, 2, 3], [1, 2, 3]] * self.ureg.m
         helpers.assert_quantity_equal(np.diagonal(q, offset=-1), [1, 2] * self.ureg.m)
 
+    @helpers.requires_array_function_protocol()
+    @helpers.requires_numpy_at_least("2.0")
+    def test_linalg_diagonal(self):
+        q = [[1, 2, 3], [1, 2, 3], [1, 2, 3]] * self.ureg.m
+        helpers.assert_quantity_equal(
+            np.linalg.diagonal(q, offset=-1), [1, 2] * self.ureg.m
+        )
+
+    @helpers.requires_array_function_protocol()
+    def test_tril(self):
+        q = [[1, 2, 3], [1, 2, 3], [1, 2, 3]] * self.ureg.m
+        helpers.assert_quantity_equal(
+            np.tril(q), [[1, 0, 0], [1, 2, 0], [1, 2, 3]] * self.ureg.m
+        )
+
+    @helpers.requires_array_function_protocol()
+    def test_tril_offset(self):
+        q = self.Q_([[1, 2, 3], [1, 2, 3], [1, 2, 3]], self.ureg.degC)
+        with pytest.raises(OffsetUnitCalculusError):
+            np.tril(q)
+
+    @helpers.requires_array_function_protocol()
+    def test_triu(self):
+        q = [[1, 2, 3], [1, 2, 3], [1, 2, 3]] * self.ureg.m
+        helpers.assert_quantity_equal(
+            np.triu(q), [[1, 2, 3], [0, 2, 3], [0, 0, 3]] * self.ureg.m
+        )
+
+    @helpers.requires_array_function_protocol()
+    def test_triu_offset(self):
+        q = self.Q_([[1, 2, 3], [1, 2, 3], [1, 2, 3]], self.ureg.degC)
+        with pytest.raises(OffsetUnitCalculusError):
+            np.triu(q)
+
+    @helpers.requires_array_function_protocol()
+    def test_diag(self):
+        q = [1, 2, 3] * self.ureg.m
+        helpers.assert_quantity_equal(
+            np.diag(q), [[1, 0, 0], [0, 2, 0], [0, 0, 3]] * self.ureg.m
+        )
+
+    @helpers.requires_array_function_protocol()
+    def test_diag_offset(self):
+        q = self.Q_([1, 2, 3], self.ureg.degC)
+        with pytest.raises(OffsetUnitCalculusError):
+            np.diag(q)
+
     def test_compress(self):
         helpers.assert_quantity_equal(
             self.q.compress([False, True], axis=0), [[3, 4]] * self.ureg.m
@@ -1509,6 +1582,20 @@ def test_linalg_norm(self):
         expected = [5, 13, 17] * self.ureg.m
         helpers.assert_quantity_equal(np.linalg.norm(q, axis=0), expected)
 
+    @helpers.requires_array_function_protocol()
+    @helpers.requires_numpy_at_least("2.0")
+    def test_linalg_vector_norm(self):
+        q = np.array([[3, 5, 8], [4, 12, 15]]) * self.ureg.m
+        expected = [5, 13, 17] * self.ureg.m
+        helpers.assert_quantity_equal(np.linalg.vector_norm(q, axis=0), expected)
+
+    @helpers.requires_array_function_protocol()
+    @helpers.requires_numpy_at_least("2.0")
+    def test_linalg_matrix_norm(self):
+        helpers.assert_quantity_equal(
+            np.linalg.matrix_norm(self.q, ord=1), 6 * self.ureg.m
+        )
+
     @helpers.requires_array_function_protocol()
     def test_geomspace(self):
         start = 1 * self.ureg.m