Merge pull request #19887 from BvB93/linalg

ENH: Add annotations for `np.linalg`

4 files changed, 450 insertions, 21 deletions

diff --git a/numpy/linalg/__init__.pyi b/numpy/linalg/__init__.pyi
index 7237d865d..d457f153a 100644
--- a/numpy/linalg/__init__.pyi
+++ b/numpy/linalg/__init__.pyi
@@ -1,5 +1,28 @@
 from typing import Any, List
 
+from numpy.linalg.linalg import (
+    matrix_power as matrix_power,
+    solve as solve,
+    tensorsolve as tensorsolve,
+    tensorinv as tensorinv,
+    inv as inv,
+    cholesky as cholesky,
+    eigvals as eigvals,
+    eigvalsh as eigvalsh,
+    pinv as pinv,
+    slogdet as slogdet,
+    det as det,
+    svd as svd,
+    eig as eig,
+    eigh as eigh,
+    lstsq as lstsq,
+    norm as norm,
+    qr as qr,
+    cond as cond,
+    matrix_rank as matrix_rank,
+    multi_dot as multi_dot,
+)
+
 from numpy._pytesttester import PytestTester
 
 __all__: List[str]
@@ -7,24 +30,3 @@ __path__: List[str]
 test: PytestTester
 
 class LinAlgError(Exception): ...
-
-def tensorsolve(a, b, axes=...): ...
-def solve(a, b): ...
-def tensorinv(a, ind=...): ...
-def inv(a): ...
-def matrix_power(a, n): ...
-def cholesky(a): ...
-def qr(a, mode=...): ...
-def eigvals(a): ...
-def eigvalsh(a, UPLO=...): ...
-def eig(a): ...
-def eigh(a, UPLO=...): ...
-def svd(a, full_matrices=..., compute_uv=..., hermitian=...): ...
-def cond(x, p=...): ...
-def matrix_rank(A, tol=..., hermitian=...): ...
-def pinv(a, rcond=..., hermitian=...): ...
-def slogdet(a): ...
-def det(a): ...
-def lstsq(a, b, rcond=...): ...
-def norm(x, ord=..., axis=..., keepdims=...): ...
-def multi_dot(arrays, *, out=...): ...
diff --git a/numpy/linalg/linalg.pyi b/numpy/linalg/linalg.pyi
new file mode 100644
index 000000000..3ce0e2229
--- /dev/null
+++ b/numpy/linalg/linalg.pyi
@@ -0,0 +1,282 @@
+from typing import (
+    Literal as L,
+    List,
+    Iterable,
+    overload,
+    TypeVar,
+    Any,
+    SupportsIndex,
+    SupportsInt,
+    Tuple,
+)
+
+from numpy import (
+    generic,
+    floating,
+    complexfloating,
+    int32,
+    float64,
+    complex128,
+)
+
+from numpy.typing import (
+    NDArray,
+    ArrayLike,
+    _ArrayLikeInt_co,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+    _ArrayLikeTD64_co,
+    _ArrayLikeObject_co,
+)
+
+_T = TypeVar("_T")
+_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
+
+_2Tuple = Tuple[_T, _T]
+_ModeKind = L["reduced", "complete", "r", "raw"]
+
+__all__: List[str]
+
+@overload
+def tensorsolve(
+    a: _ArrayLikeInt_co,
+    b: _ArrayLikeInt_co,
+    axes: None | Iterable[int] =...,
+) -> NDArray[float64]: ...
+@overload
+def tensorsolve(
+    a: _ArrayLikeFloat_co,
+    b: _ArrayLikeFloat_co,
+    axes: None | Iterable[int] =...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def tensorsolve(
+    a: _ArrayLikeComplex_co,
+    b: _ArrayLikeComplex_co,
+    axes: None | Iterable[int] =...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def solve(
+    a: _ArrayLikeInt_co,
+    b: _ArrayLikeInt_co,
+) -> NDArray[float64]: ...
+@overload
+def solve(
+    a: _ArrayLikeFloat_co,
+    b: _ArrayLikeFloat_co,
+) -> NDArray[floating[Any]]: ...
+@overload
+def solve(
+    a: _ArrayLikeComplex_co,
+    b: _ArrayLikeComplex_co,
+) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def tensorinv(
+    a: _ArrayLikeInt_co,
+    ind: int = ...,
+) -> NDArray[float64]: ...
+@overload
+def tensorinv(
+    a: _ArrayLikeFloat_co,
+    ind: int = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def tensorinv(
+    a: _ArrayLikeComplex_co,
+    ind: int = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def inv(a: _ArrayLikeInt_co) -> NDArray[float64]: ...
+@overload
+def inv(a: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ...
+@overload
+def inv(a: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+# TODO: The supported input and output dtypes are dependant on the value of `n`.
+# For example: `n < 0` always casts integer types to float64
+def matrix_power(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    n: SupportsIndex,
+) -> NDArray[Any]: ...
+
+@overload
+def cholesky(a: _ArrayLikeInt_co) -> NDArray[float64]: ...
+@overload
+def cholesky(a: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ...
+@overload
+def cholesky(a: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def qr(a: _ArrayLikeInt_co, mode: _ModeKind = ...) -> _2Tuple[NDArray[float64]]: ...
+@overload
+def qr(a: _ArrayLikeFloat_co, mode: _ModeKind = ...) -> _2Tuple[NDArray[floating[Any]]]: ...
+@overload
+def qr(a: _ArrayLikeComplex_co, mode: _ModeKind = ...) -> _2Tuple[NDArray[complexfloating[Any, Any]]]: ...
+
+@overload
+def eigvals(a: _ArrayLikeInt_co) -> NDArray[float64] | NDArray[complex128]: ...
+@overload
+def eigvals(a: _ArrayLikeFloat_co) -> NDArray[floating[Any]] | NDArray[complexfloating[Any, Any]]: ...
+@overload
+def eigvals(a: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def eigvalsh(a: _ArrayLikeInt_co, UPLO: L["L", "U", "l", "u"] = ...) -> NDArray[float64]: ...
+@overload
+def eigvalsh(a: _ArrayLikeComplex_co, UPLO: L["L", "U", "l", "u"] = ...) -> NDArray[floating[Any]]: ...
+
+@overload
+def eig(a: _ArrayLikeInt_co) -> _2Tuple[NDArray[float64]] | _2Tuple[NDArray[complex128]]: ...
+@overload
+def eig(a: _ArrayLikeFloat_co) -> _2Tuple[NDArray[floating[Any]]] | _2Tuple[NDArray[complexfloating[Any, Any]]]: ...
+@overload
+def eig(a: _ArrayLikeComplex_co) -> _2Tuple[NDArray[complexfloating[Any, Any]]]: ...
+
+@overload
+def eigh(
+    a: _ArrayLikeInt_co,
+    UPLO: L["L", "U", "l", "u"] = ...,
+) -> Tuple[NDArray[float64], NDArray[float64]]: ...
+@overload
+def eigh(
+    a: _ArrayLikeFloat_co,
+    UPLO: L["L", "U", "l", "u"] = ...,
+) -> Tuple[NDArray[floating[Any]], NDArray[floating[Any]]]: ...
+@overload
+def eigh(
+    a: _ArrayLikeComplex_co,
+    UPLO: L["L", "U", "l", "u"] = ...,
+) -> Tuple[NDArray[floating[Any]], NDArray[complexfloating[Any, Any]]]: ...
+
+@overload
+def svd(
+    a: _ArrayLikeInt_co,
+    full_matrices: bool = ...,
+    compute_uv: L[True] = ...,
+    hermitian: bool = ...,
+) -> Tuple[
+    NDArray[float64],
+    NDArray[float64],
+    NDArray[float64],
+]: ...
+@overload
+def svd(
+    a: _ArrayLikeFloat_co,
+    full_matrices: bool = ...,
+    compute_uv: L[True] = ...,
+    hermitian: bool = ...,
+) -> Tuple[
+    NDArray[floating[Any]],
+    NDArray[floating[Any]],
+    NDArray[floating[Any]],
+]: ...
+@overload
+def svd(
+    a: _ArrayLikeComplex_co,
+    full_matrices: bool = ...,
+    compute_uv: L[True] = ...,
+    hermitian: bool = ...,
+) -> Tuple[
+    NDArray[complexfloating[Any, Any]],
+    NDArray[floating[Any]],
+    NDArray[complexfloating[Any, Any]],
+]: ...
+@overload
+def svd(
+    a: _ArrayLikeInt_co,
+    full_matrices: bool = ...,
+    compute_uv: L[False] = ...,
+    hermitian: bool = ...,
+) -> NDArray[float64]: ...
+@overload
+def svd(
+    a: _ArrayLikeComplex_co,
+    full_matrices: bool = ...,
+    compute_uv: L[False] = ...,
+    hermitian: bool = ...,
+) -> NDArray[floating[Any]]: ...
+
+# TODO: Returns a scalar for 2D arrays and
+# a `(x.ndim - 2)`` dimensionl array otherwise
+def cond(x: _ArrayLikeComplex_co, p: None | float | L["fro", "nuc"] = ...) -> Any: ...
+
+# TODO: Returns `int` for <2D arrays and `intp` otherwise
+def matrix_rank(
+    A: _ArrayLikeComplex_co,
+    tol: None | _ArrayLikeFloat_co = ...,
+    hermitian: bool = ...,
+) -> Any: ...
+
+@overload
+def pinv(
+    a: _ArrayLikeInt_co,
+    rcond: _ArrayLikeFloat_co = ...,
+    hermitian: bool = ...,
+) -> NDArray[float64]: ...
+@overload
+def pinv(
+    a: _ArrayLikeFloat_co,
+    rcond: _ArrayLikeFloat_co = ...,
+    hermitian: bool = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def pinv(
+    a: _ArrayLikeComplex_co,
+    rcond: _ArrayLikeFloat_co = ...,
+    hermitian: bool = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+
+# TODO: Returns a 2-tuple of scalars for 2D arrays and
+# a 2-tuple of `(a.ndim - 2)`` dimensionl arrays otherwise
+def slogdet(a: _ArrayLikeComplex_co) -> _2Tuple[Any]: ...
+
+# TODO: Returns a 2-tuple of scalars for 2D arrays and
+# a 2-tuple of `(a.ndim - 2)`` dimensionl arrays otherwise
+def det(a: _ArrayLikeComplex_co) -> Any: ...
+
+@overload
+def lstsq(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, rcond: None | float = ...) -> Tuple[
+    NDArray[float64],
+    NDArray[float64],
+    int32,
+    NDArray[float64],
+]: ...
+@overload
+def lstsq(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, rcond: None | float = ...) -> Tuple[
+    NDArray[floating[Any]],
+    NDArray[floating[Any]],
+    int32,
+    NDArray[floating[Any]],
+]: ...
+@overload
+def lstsq(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co, rcond: None | float = ...) -> Tuple[
+    NDArray[complexfloating[Any, Any]],
+    NDArray[floating[Any]],
+    int32,
+    NDArray[floating[Any]],
+]: ...
+
+@overload
+def norm(
+    x: ArrayLike,
+    ord: None | float | L["fro", "nuc"] = ...,
+    axis: None = ...,
+    keepdims: bool = ...,
+) -> floating[Any]: ...
+@overload
+def norm(
+    x: ArrayLike,
+    ord: None | float | L["fro", "nuc"] = ...,
+    axis: SupportsInt | SupportsIndex | Tuple[int, ...] = ...,
+    keepdims: bool = ...,
+) -> Any: ...
+
+# TODO: Returns a scalar or array
+def multi_dot(
+    arrays: Iterable[_ArrayLikeComplex_co | _ArrayLikeObject_co | _ArrayLikeTD64_co],
+    *,
+    out: None | NDArray[Any] = ...,
+) -> Any: ...
diff --git a/numpy/typing/tests/data/fail/linalg.py b/numpy/typing/tests/data/fail/linalg.py
new file mode 100644
index 000000000..da9390328
--- /dev/null
+++ b/numpy/typing/tests/data/fail/linalg.py
@@ -0,0 +1,48 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64]
+AR_O: npt.NDArray[np.object_]
+AR_M: npt.NDArray[np.datetime64]
+
+np.linalg.tensorsolve(AR_O, AR_O)  # E: incompatible type
+
+np.linalg.solve(AR_O, AR_O)  # E: incompatible type
+
+np.linalg.tensorinv(AR_O)  # E: incompatible type
+
+np.linalg.inv(AR_O)  # E: incompatible type
+
+np.linalg.matrix_power(AR_M, 5)  # E: incompatible type
+
+np.linalg.cholesky(AR_O)  # E: incompatible type
+
+np.linalg.qr(AR_O)  # E: incompatible type
+np.linalg.qr(AR_f8, mode="bob")  # E: No overload variant
+
+np.linalg.eigvals(AR_O)  # E: incompatible type
+
+np.linalg.eigvalsh(AR_O)  # E: incompatible type
+np.linalg.eigvalsh(AR_O, UPLO="bob")  # E: No overload variant
+
+np.linalg.eig(AR_O)  # E: incompatible type
+
+np.linalg.eigh(AR_O)  # E: incompatible type
+np.linalg.eigh(AR_O, UPLO="bob")  # E: No overload variant
+
+np.linalg.svd(AR_O)  # E: incompatible type
+
+np.linalg.cond(AR_O)  # E: incompatible type
+np.linalg.cond(AR_f8, p="bob")  # E: incompatible type
+
+np.linalg.matrix_rank(AR_O)  # E: incompatible type
+
+np.linalg.pinv(AR_O)  # E: incompatible type
+
+np.linalg.slogdet(AR_O)  # E: incompatible type
+
+np.linalg.det(AR_O)  # E: incompatible type
+
+np.linalg.norm(AR_f8, ord="bob")  # E: No overload variant
+
+np.linalg.multi_dot([AR_M])  # E: incompatible type
diff --git a/numpy/typing/tests/data/reveal/linalg.py b/numpy/typing/tests/data/reveal/linalg.py
new file mode 100644
index 000000000..fecdc0d37
--- /dev/null
+++ b/numpy/typing/tests/data/reveal/linalg.py
@@ -0,0 +1,97 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+AR_c16: npt.NDArray[np.complex128]
+AR_O: npt.NDArray[np.object_]
+AR_m: npt.NDArray[np.timedelta64]
+AR_S: npt.NDArray[np.str_]
+
+reveal_type(np.linalg.tensorsolve(AR_i8, AR_i8))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.linalg.tensorsolve(AR_i8, AR_f8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+reveal_type(np.linalg.tensorsolve(AR_c16, AR_f8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]
+
+reveal_type(np.linalg.solve(AR_i8, AR_i8))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.linalg.solve(AR_i8, AR_f8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+reveal_type(np.linalg.solve(AR_c16, AR_f8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]
+
+reveal_type(np.linalg.tensorinv(AR_i8))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.linalg.tensorinv(AR_f8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+reveal_type(np.linalg.tensorinv(AR_c16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]
+
+reveal_type(np.linalg.inv(AR_i8))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.linalg.inv(AR_f8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+reveal_type(np.linalg.inv(AR_c16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]
+
+reveal_type(np.linalg.matrix_power(AR_i8, -1))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
+reveal_type(np.linalg.matrix_power(AR_f8, 0))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
+reveal_type(np.linalg.matrix_power(AR_c16, 1))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
+reveal_type(np.linalg.matrix_power(AR_O, 2))  # E: numpy.ndarray[Any, numpy.dtype[Any]]
+
+reveal_type(np.linalg.cholesky(AR_i8))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.linalg.cholesky(AR_f8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+reveal_type(np.linalg.cholesky(AR_c16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]
+
+reveal_type(np.linalg.qr(AR_i8))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[{float64}]], numpy.ndarray[Any, numpy.dtype[{float64}]]]
+reveal_type(np.linalg.qr(AR_f8))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]], numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]]
+reveal_type(np.linalg.qr(AR_c16))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]], numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]]
+
+reveal_type(np.linalg.eigvals(AR_i8))  # E: Union[numpy.ndarray[Any, numpy.dtype[{float64}]], numpy.ndarray[Any, numpy.dtype[{complex128}]]]
+reveal_type(np.linalg.eigvals(AR_f8))  # E: Union[numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]], numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]]
+reveal_type(np.linalg.eigvals(AR_c16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]
+
+reveal_type(np.linalg.eigvalsh(AR_i8))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.linalg.eigvalsh(AR_f8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+reveal_type(np.linalg.eigvalsh(AR_c16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+
+reveal_type(np.linalg.eig(AR_i8))  # E: Union[Tuple[numpy.ndarray[Any, numpy.dtype[{float64}]], numpy.ndarray[Any, numpy.dtype[{float64}]]], Tuple[numpy.ndarray[Any, numpy.dtype[{complex128}]], numpy.ndarray[Any, numpy.dtype[{complex128}]]]]
+reveal_type(np.linalg.eig(AR_f8))  # E: Union[Tuple[numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]], numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]], Tuple[numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]], numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]]]
+reveal_type(np.linalg.eig(AR_c16))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]], numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]]
+
+reveal_type(np.linalg.eigh(AR_i8))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[{float64}]], numpy.ndarray[Any, numpy.dtype[{float64}]]]
+reveal_type(np.linalg.eigh(AR_f8))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]], numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]]
+reveal_type(np.linalg.eigh(AR_c16))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]], numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]]
+
+reveal_type(np.linalg.svd(AR_i8))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[{float64}]], numpy.ndarray[Any, numpy.dtype[{float64}]], numpy.ndarray[Any, numpy.dtype[{float64}]]]
+reveal_type(np.linalg.svd(AR_f8))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]], numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]], numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]]
+reveal_type(np.linalg.svd(AR_c16))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]], numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]], numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]]
+reveal_type(np.linalg.svd(AR_i8, compute_uv=False))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.linalg.svd(AR_f8, compute_uv=False))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+reveal_type(np.linalg.svd(AR_c16, compute_uv=False))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+
+reveal_type(np.linalg.cond(AR_i8))  # E: Any
+reveal_type(np.linalg.cond(AR_f8))  # E: Any
+reveal_type(np.linalg.cond(AR_c16))  # E: Any
+
+reveal_type(np.linalg.matrix_rank(AR_i8))  # E: Any
+reveal_type(np.linalg.matrix_rank(AR_f8))  # E: Any
+reveal_type(np.linalg.matrix_rank(AR_c16))  # E: Any
+
+reveal_type(np.linalg.pinv(AR_i8))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(np.linalg.pinv(AR_f8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]
+reveal_type(np.linalg.pinv(AR_c16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]]
+
+reveal_type(np.linalg.slogdet(AR_i8))  # E: Tuple[Any, Any]
+reveal_type(np.linalg.slogdet(AR_f8))  # E: Tuple[Any, Any]
+reveal_type(np.linalg.slogdet(AR_c16))  # E: Tuple[Any, Any]
+
+reveal_type(np.linalg.det(AR_i8))  # E: Any
+reveal_type(np.linalg.det(AR_f8))  # E: Any
+reveal_type(np.linalg.det(AR_c16))  # E: Any
+
+reveal_type(np.linalg.lstsq(AR_i8, AR_i8))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[{float64}]], numpy.ndarray[Any, numpy.dtype[{float64}]], {int32}, numpy.ndarray[Any, numpy.dtype[{float64}]]]
+reveal_type(np.linalg.lstsq(AR_i8, AR_f8))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]], numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]], {int32}, numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]]
+reveal_type(np.linalg.lstsq(AR_f8, AR_c16))  # E: Tuple[numpy.ndarray[Any, numpy.dtype[numpy.complexfloating[Any, Any]]], numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]], {int32}, numpy.ndarray[Any, numpy.dtype[numpy.floating[Any]]]]
+
+reveal_type(np.linalg.norm(AR_i8))  # E: numpy.floating[Any]
+reveal_type(np.linalg.norm(AR_f8))  # E: numpy.floating[Any]
+reveal_type(np.linalg.norm(AR_c16))  # E: numpy.floating[Any]
+reveal_type(np.linalg.norm(AR_S))  # E: numpy.floating[Any]
+reveal_type(np.linalg.norm(AR_f8, axis=0))  # E: Any
+
+reveal_type(np.linalg.multi_dot([AR_i8, AR_i8]))  # E: Any
+reveal_type(np.linalg.multi_dot([AR_i8, AR_f8]))  # E: Any
+reveal_type(np.linalg.multi_dot([AR_f8, AR_c16]))  # E: Any
+reveal_type(np.linalg.multi_dot([AR_O, AR_O]))  # E: Any
+reveal_type(np.linalg.multi_dot([AR_m, AR_m]))  # E: Any