diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ae0346aa..dfc4dd66 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -60,12 +60,12 @@ jobs: src/numpy-stubs/_core/shape_base.pyi src/numpy-stubs/_core/strings.pyi src/numpy-stubs/_core/umath.pyi - src/numpy-stubs/_typing - src/numpy-stubs/char - src/numpy-stubs/core - src/numpy-stubs/distutils - src/numpy-stubs/f2py - src/numpy-stubs/fft + src/numpy-stubs/_typing/ + src/numpy-stubs/char/ + src/numpy-stubs/core/ + src/numpy-stubs/distutils/ + src/numpy-stubs/f2py/ + src/numpy-stubs/fft/ src/numpy-stubs/lib/__init__.pyi src/numpy-stubs/lib/_array_utils_impl.pyi src/numpy-stubs/lib/_arraypad_impl.pyi @@ -86,12 +86,13 @@ jobs: src/numpy-stubs/lib/scimath.pyi src/numpy-stubs/lib/stride_tricks.pyi src/numpy-stubs/lib/user_array.pyi - src/numpy-stubs/matrixlib - src/numpy-stubs/random - src/numpy-stubs/rec - src/numpy-stubs/strings - src/numpy-stubs/testing - src/numpy-stubs/typing + src/numpy-stubs/linalg/ + src/numpy-stubs/matrixlib/ + src/numpy-stubs/random/ + src/numpy-stubs/rec/ + src/numpy-stubs/strings/ + src/numpy-stubs/testing/ + src/numpy-stubs/typing/ src/numpy-stubs/__config__.pyi src/numpy-stubs/_array_api_info.pyi src/numpy-stubs/_configtool.pyi @@ -123,12 +124,12 @@ jobs: src/numpy-stubs/_core/shape_base.pyi src/numpy-stubs/_core/strings.pyi src/numpy-stubs/_core/umath.pyi - src/numpy-stubs/_typing - src/numpy-stubs/char - src/numpy-stubs/core - src/numpy-stubs/distutils - src/numpy-stubs/f2py - src/numpy-stubs/fft + src/numpy-stubs/_typing/ + src/numpy-stubs/char/ + src/numpy-stubs/core/ + src/numpy-stubs/distutils/ + src/numpy-stubs/f2py/ + src/numpy-stubs/fft/ src/numpy-stubs/lib/__init__.pyi src/numpy-stubs/lib/_array_utils_impl.pyi src/numpy-stubs/lib/_arraypad_impl.pyi @@ -149,12 +150,13 @@ jobs: src/numpy-stubs/lib/scimath.pyi src/numpy-stubs/lib/stride_tricks.pyi src/numpy-stubs/lib/user_array.pyi - src/numpy-stubs/matrixlib - src/numpy-stubs/random - src/numpy-stubs/rec - src/numpy-stubs/strings - src/numpy-stubs/testing - src/numpy-stubs/typing + src/numpy-stubs/linalg/ + src/numpy-stubs/matrixlib/ + src/numpy-stubs/random/ + src/numpy-stubs/rec/ + src/numpy-stubs/strings/ + src/numpy-stubs/testing/ + src/numpy-stubs/typing/ src/numpy-stubs/__config__.pyi src/numpy-stubs/_array_api_info.pyi src/numpy-stubs/_configtool.pyi diff --git a/src/_numtype/__init__.pyi b/src/_numtype/__init__.pyi index 4d09f7da..0d6544e6 100644 --- a/src/_numtype/__init__.pyi +++ b/src/_numtype/__init__.pyi @@ -9,7 +9,7 @@ import ipaddress as ip import uuid from collections.abc import Sequence from typing import Any, ClassVar, TypeAlias, final, type_check_only -from typing_extensions import Protocol, TypeAliasType, TypeVar, Unpack +from typing_extensions import Never, Protocol, TypeAliasType, TypeVar, Unpack import numpy as np from numpy._typing import _64Bit @@ -19,10 +19,10 @@ from numpy._typing import _64Bit _T = TypeVar("_T", default=Any) _T_co = TypeVar("_T_co", covariant=True) -_ShapeT_co = TypeVar("_ShapeT_co", bound=tuple[int, ...], default=Any, covariant=True) +_ShapeT_co = TypeVar("_ShapeT_co", bound=tuple[int, ...], default=tuple[int, ...], covariant=True) _ScalarT = TypeVar("_ScalarT", bound=np.generic, default=Any) _ScalarT_co = TypeVar("_ScalarT_co", bound=np.generic, default=Any, covariant=True) -_ToT = TypeVar("_ToT", default=_ScalarT) +_ToT = TypeVar("_ToT", default=Never) ### # Type constraints (bijective type mappings) @@ -137,8 +137,8 @@ _PyObject: TypeAlias = ( # anything immutable that results in an `object_` dtyp | ip.IPv6Address ) -_ToArray_nd: TypeAlias = CanArray[_ScalarT] | _ToT | Sequence_nd[_ToT | _ScalarT] | Sequence_nd[CanArray[_ScalarT]] -_ToArray_0d = TypeAliasType("_ToArray_0d", _ToT | CanArray[_ScalarT, tuple[()]], type_params=(_ScalarT, _ToT)) +_ToArray_nd: TypeAlias = _ScalarT | _ToT | CanArray[_ScalarT] | Sequence_nd[_ToT | _ScalarT] | Sequence_nd[CanArray[_ScalarT]] +_ToArray_0d: TypeAlias = _ScalarT | _ToT | CanArray[_ScalarT, tuple[()]] # don't require matching shape-types by default _ToArray_1d: TypeAlias = CanArraySized[_ScalarT] | Sequence[_ToArray_0d[_ScalarT, _ToT]] @@ -586,7 +586,8 @@ ToStr_1nd = TypeAliasType("ToStr_1nd", _ToArray_1nd[_ToStr, Is[str]]) ToStr_2nd = TypeAliasType("ToStr_2nd", _ToArray_2nd[_ToStr, Is[str]]) ToStr_3nd = TypeAliasType("ToStr_3nd", _ToArray_3nd[_ToStr, Is[str]]) -ToCharacter_nd = TypeAliasType("ToCharacter_nd", _ToArray_nd[np.character, _PyCharacter]) +# the `bytes | str` work around a pyright false positive bug within nested sequences +ToCharacter_nd = TypeAliasType("ToCharacter_nd", _ToArray_nd[np.character, bytes | str]) ToCharacter_0d = TypeAliasType("ToCharacter_0d", _ToArray_0d[np.character, _PyCharacter]) ToCharacter_1d = TypeAliasType("ToCharacter_1d", _ToArray_1d[np.character, _PyCharacter]) ToCharacter_2d = TypeAliasType("ToCharacter_2d", _ToArray_2d[np.character, _PyCharacter]) @@ -594,9 +595,9 @@ ToCharacter_3d = TypeAliasType("ToCharacter_3d", _ToArray_3d[np.character, _PyCh ToCharacter_1ds = TypeAliasType("ToCharacter_1ds", _ToArray_1ds[np.character, _PyCharacter]) ToCharacter_2ds = TypeAliasType("ToCharacter_2ds", _ToArray_2ds[np.character, _PyCharacter]) ToCharacter_3ds = TypeAliasType("ToCharacter_3ds", _ToArray_3ds[np.character, _PyCharacter]) -ToCharacter_1nd = TypeAliasType("ToCharacter_1nd", _ToArray_1nd[np.character, _PyCharacter]) -ToCharacter_2nd = TypeAliasType("ToCharacter_2nd", _ToArray_2nd[np.character, _PyCharacter]) -ToCharacter_3nd = TypeAliasType("ToCharacter_3nd", _ToArray_3nd[np.character, _PyCharacter]) +ToCharacter_1nd = TypeAliasType("ToCharacter_1nd", _ToArray_1nd[np.character, bytes | str]) +ToCharacter_2nd = TypeAliasType("ToCharacter_2nd", _ToArray_2nd[np.character, bytes | str]) +ToCharacter_3nd = TypeAliasType("ToCharacter_3nd", _ToArray_3nd[np.character, bytes | str]) # python object ToObject_nd = TypeAliasType("ToObject_nd", _ToArray_nd[np.object_, _PyObject]) diff --git a/src/numpy-stubs/linalg/__init__.pyi b/src/numpy-stubs/linalg/__init__.pyi index fe1ce3e4..dbe9becf 100644 --- a/src/numpy-stubs/linalg/__init__.pyi +++ b/src/numpy-stubs/linalg/__init__.pyi @@ -1,7 +1,5 @@ -from numpy._core.fromnumeric import matrix_transpose -from numpy._core.numeric import tensordot, vecdot - from ._linalg import ( + LinAlgError, cholesky, cond, cross, @@ -17,6 +15,7 @@ from ._linalg import ( matrix_norm, matrix_power, matrix_rank, + matrix_transpose, multi_dot, norm, outer, @@ -26,9 +25,11 @@ from ._linalg import ( solve, svd, svdvals, + tensordot, tensorinv, tensorsolve, trace, + vecdot, vector_norm, ) @@ -66,5 +67,3 @@ __all__ = [ "vecdot", "vector_norm", ] - -class LinAlgError(ValueError): ... diff --git a/src/numpy-stubs/linalg/_linalg.pyi b/src/numpy-stubs/linalg/_linalg.pyi index 481c1b9f..3633cefd 100644 --- a/src/numpy-stubs/linalg/_linalg.pyi +++ b/src/numpy-stubs/linalg/_linalg.pyi @@ -1,33 +1,103 @@ -from collections.abc import Iterable -from typing import ( - Any, - Literal as L, - NamedTuple, - SupportsIndex, - SupportsInt, - TypeAlias, - overload, -) +from collections.abc import Iterable, Sequence +from typing import Any, Generic, Literal as L, NamedTuple, SupportsIndex as CanIndex, SupportsInt, TypeAlias, overload from typing_extensions import TypeVar import numpy as np -from numpy import vecdot # noqa: ICN003 -from numpy._core.fromnumeric import matrix_transpose -from numpy._core.numeric import tensordot -from numpy._typing import ( - ArrayLike, - DTypeLike, - NDArray, - _ArrayLikeBool_co, - _ArrayLikeComplex_co, - _ArrayLikeFloat_co, - _ArrayLikeInt_co, - _ArrayLikeObject_co, - _ArrayLikeTD64_co, - _ArrayLikeUInt_co, - _ArrayLikeUnknown, +from _numtype import ( + Array, + Array_2d, + AtLeast2D, + CanArraySized, + CoBool_1nd, + CoComplex64_1nd, + CoComplex128_0d, + CoComplex128_1d, + CoComplex128_1ds, + CoComplex128_1nd, + CoComplex128_2ds, + CoComplex128_3nd, + CoComplex128_nd, + CoFloat64_1d, + CoFloat64_1ds, + CoFloat64_1nd, + CoFloating_1ds, + CoFloating_1nd, + CoIntP_1d, + CoIntP_1ds, + CoIntP_1nd, + CoInteger_1d, + CoInteger_1ds, + CoInteger_1nd, + CoNumber_1ds, + CoNumber_1nd, + CoNumber_2ds, + CoNumber_2nd, + CoNumber_3nd, + CoTimeDelta_1d, + Is, + Sequence_2d, + Sequence_2nd, + Sequence_3nd, + Sequence_nd, + ToAny_1nd, + ToBool_1d, + ToBool_1ds, + ToBool_1nd, + ToBool_2nd, + ToCFloating_1ds, + ToCFloating_1nd, + ToCFloating_2nd, + ToCharacter_1nd, + ToComplex64_1d, + ToComplex64_1nd, + ToComplex64_2ds, + ToComplex64_3nd, + ToComplex128_1d, + ToComplex128_1ds, + ToComplex128_1nd, + ToComplex128_2ds, + ToComplex128_2nd, + ToComplex128_3nd, + ToFloat16_1nd, + ToFloat16_2ds, + ToFloat16_3nd, + ToFloat32_1d, + ToFloat32_1nd, + ToFloat32_2ds, + ToFloat32_3nd, + ToFloat64_1d, + ToFloat64_1ds, + ToFloat64_1nd, + ToFloat64_2nd, + ToFloating_1ds, + ToFloating_1nd, + ToFloating_2nd, + ToFloating_nd, + ToIntP_1d, + ToIntP_1ds, + ToIntP_1nd, + ToIntP_2nd, + ToInteger_1d, + ToInteger_1ds, + ToInteger_1nd, + ToInteger_2nd, + ToNumber_1d, + ToObject_0d, + ToObject_1d, + ToObject_1nd, + ToTimeDelta_1d, + ToTimeDelta_1nd, + ToUInteger_1nd, + _ToArray_1d, + _ToArray_1ds, + _ToArray_1nd, + _ToArray_2ds, + _ToArray_2nd, + _ToArray_3nd, ) -from numpy.linalg import LinAlgError +from numpy._core.fromnumeric import matrix_transpose +from numpy._core.numeric import tensordot, vecdot +from numpy._typing import DTypeLike, _32Bit, _64Bit, _DTypeLike as _ToDType __all__ = [ "LinAlgError", @@ -64,317 +134,886 @@ __all__ = [ "vector_norm", ] +### + +_SafeFloating: TypeAlias = np.float32 | np.float64 +_SafeInexact: TypeAlias = _SafeFloating | np.complex64 | np.complex128 + _T = TypeVar("_T") +_ArrayT = TypeVar("_ArrayT", bound=Array[Any]) +_Shape2T = TypeVar("_Shape2T", bound=AtLeast2D) + +_ScalarT = TypeVar("_ScalarT", bound=np.generic) +_IntegerT = TypeVar("_IntegerT", bound=np.integer) +_FloatingT = TypeVar("_FloatingT", bound=np.floating) +_NumberT = TypeVar("_NumberT", bound=np.number) + +_FloatingT_co = TypeVar("_FloatingT_co", bound=np.floating, default=np.floating, covariant=True) +_InexactT_co = TypeVar("_InexactT_co", bound=np.inexact, default=np.inexact, covariant=True) + +_FloatingNDT_co = TypeVar("_FloatingNDT_co", bound=np.floating | Array[np.floating], default=Any, covariant=True) +_InexactNDT_co = TypeVar("_InexactNDT_co", bound=np.inexact | Array[np.inexact], default=Any, covariant=True) + +_AnyNumberT = TypeVar( + "_AnyNumberT", + np.int_, + np.int8, + np.int16, + np.int32, + np.int64, + np.uint, + np.uint8, + np.uint16, + np.uint32, + np.uint64, + np.float16, + np.float32, + np.float64, + np.longdouble, + np.complex64, + np.complex128, + np.clongdouble, +) + +_False: TypeAlias = L[False] +_True: TypeAlias = L[True] _2Tuple: TypeAlias = tuple[_T, _T] -_ModeKind: TypeAlias = L["reduced", "complete", "r", "raw"] +_ToInt: TypeAlias = SupportsInt | CanIndex + +_Ax2: TypeAlias = _ToInt | _2Tuple[_ToInt] +_Axes: TypeAlias = Iterable[int] + +_ArrayOrScalar: TypeAlias = _ScalarT | Array[_ScalarT] +_Ord: TypeAlias = L[1, -1, 2, -2, "fro", "nuc"] | float +_UPLO: TypeAlias = L["L", "U", "l", "u"] -class EigResult(NamedTuple): - eigenvalues: NDArray[Any] - eigenvectors: NDArray[Any] +_ToArray_2nd_ish: TypeAlias = CanArraySized[_ScalarT] | Sequence[Sequence_nd[_ScalarT]] | Sequence_nd[CanArraySized[_ScalarT]] -class EighResult(NamedTuple): - eigenvalues: NDArray[Any] - eigenvectors: NDArray[Any] +_ToFloat64_1nd: TypeAlias = _ToArray_1nd[np.floating[_64Bit] | np.integer | np.bool, float] +_ToFloat64_2ds: TypeAlias = _ToArray_2ds[np.floating[_64Bit] | np.integer | np.bool, float] +_ToFloat64_3nd: TypeAlias = _ToArray_3nd[np.floating[_64Bit] | np.integer | np.bool, float] -class QRResult(NamedTuple): - Q: NDArray[Any] - R: NDArray[Any] +_ToInexact32_1nd: TypeAlias = _ToArray_1nd[np.inexact[_32Bit]] +_ToInexact32_2ds: TypeAlias = _ToArray_2ds[np.inexact[_32Bit]] +_ToInexact32_3nd: TypeAlias = _ToArray_3nd[np.inexact[_32Bit]] -class SlogdetResult(NamedTuple): - # TODO: `sign` and `logabsdet` are scalars for input 2D arrays and - # a `(x.ndim - 2)`` dimensionl arrays otherwise - sign: Any - logabsdet: Any +_ToInexact64_1nd: TypeAlias = _ToArray_1nd[np.inexact[_64Bit] | np.integer | np.bool, complex] +_ToInexact64_2ds: TypeAlias = _ToArray_2ds[np.inexact[_64Bit] | np.integer | np.bool, complex] +_ToInexact64_3nd: TypeAlias = _ToArray_3nd[np.inexact[_64Bit] | np.integer | np.bool, complex] -class SVDResult(NamedTuple): - U: NDArray[Any] - S: NDArray[Any] - Vh: NDArray[Any] +_ToInexactLD_1nd: TypeAlias = _ToArray_1nd[np.longdouble | np.clongdouble] +_ToInexactLD_2ds: TypeAlias = _ToArray_2ds[np.longdouble | np.clongdouble] +_ToInexactLD_3nd: TypeAlias = _ToArray_3nd[np.longdouble | np.clongdouble] + +_ToUnsafe64_1nd: TypeAlias = _ToArray_1nd[np.inexact[_64Bit] | np.integer | np.bool | np.character, complex | bytes | str] +_ToUnsafe64_2ds: TypeAlias = _ToArray_2ds[np.inexact[_64Bit] | np.integer | np.bool | np.character, complex | bytes | str] +_ToUnsafe64_3nd: TypeAlias = _ToArray_3nd[np.inexact[_64Bit] | np.integer | np.bool | np.character, complex | bytes | str] + +_Array_2nd: TypeAlias = Array[_ScalarT, AtLeast2D] + +_LstSqResult: TypeAlias = tuple[Array[_ScalarT], Array[_FloatingT], np.int32, Array[_FloatingT]] + +### + +class EigResult(NamedTuple, Generic[_InexactT_co]): + eigenvalues: Array[_InexactT_co] + eigenvectors: _Array_2nd[_InexactT_co] + +class EighResult(NamedTuple, Generic[_FloatingT_co, _InexactT_co]): + eigenvalues: Array[_FloatingT_co] + eigenvectors: _Array_2nd[_InexactT_co] + +class QRResult(NamedTuple, Generic[_InexactT_co]): + Q: _Array_2nd[_InexactT_co] + R: _Array_2nd[_InexactT_co] + +class SVDResult(NamedTuple, Generic[_FloatingT_co, _InexactT_co]): + U: _Array_2nd[_InexactT_co] + S: Array[_FloatingT_co] + Vh: _Array_2nd[_InexactT_co] + +class SlogdetResult(NamedTuple, Generic[_FloatingNDT_co, _InexactNDT_co]): + sign: _InexactNDT_co + logabsdet: _FloatingNDT_co + +class LinAlgError(ValueError): ... + +# keep in sync with `solve` +@overload +def tensorsolve(a: _ToFloat64_1nd, b: CoFloat64_1nd, axes: _Axes | None = None) -> Array[np.float64]: ... # type: ignore[overload-overlap] +@overload +def tensorsolve(a: CoFloat64_1nd, b: _ToFloat64_1nd, axes: _Axes | None = None) -> Array[np.float64]: ... # type: ignore[overload-overlap] +@overload +def tensorsolve(a: ToComplex128_1nd, b: CoComplex128_1nd, axes: _Axes | None = None) -> Array[np.complex128]: ... # type: ignore[overload-overlap] +@overload +def tensorsolve(a: CoComplex128_1nd, b: ToComplex128_1nd, axes: _Axes | None = None) -> Array[np.complex128]: ... # type: ignore[overload-overlap] +@overload +def tensorsolve(a: ToFloat32_1nd, b: ToFloat32_1nd, axes: _Axes | None = None) -> Array[np.float32]: ... # type: ignore[overload-overlap] +@overload +def tensorsolve(a: ToComplex64_1nd, b: ToComplex64_1nd, axes: _Axes | None = None) -> Array[np.complex64]: ... # type: ignore[overload-overlap] +@overload +def tensorsolve(a: CoFloat64_1nd, b: CoFloat64_1nd, axes: _Axes | None = None) -> Array[np.floating]: ... +@overload +def tensorsolve(a: CoComplex128_1nd, b: CoComplex128_1nd, axes: _Axes | None = None) -> Array[np.inexact]: ... + +# keep in sync with `tensorsolve` +@overload +def solve(a: _ToFloat64_1nd, b: CoFloat64_1nd) -> Array[np.float64]: ... # type: ignore[overload-overlap] +@overload +def solve(a: CoFloat64_1nd, b: _ToFloat64_1nd) -> Array[np.float64]: ... # type: ignore[overload-overlap] +@overload +def solve(a: ToComplex128_1nd, b: CoComplex128_1nd) -> Array[np.complex128]: ... # type: ignore[overload-overlap] +@overload +def solve(a: CoComplex128_1nd, b: ToComplex128_1nd) -> Array[np.complex128]: ... # type: ignore[overload-overlap] +@overload +def solve(a: ToFloat32_1nd, b: ToFloat32_1nd) -> Array[np.float32]: ... # type: ignore[overload-overlap] +@overload +def solve(a: ToComplex64_1nd, b: ToComplex64_1nd) -> Array[np.complex64]: ... # type: ignore[overload-overlap] +@overload +def solve(a: CoFloat64_1nd, b: CoFloat64_1nd) -> Array[np.floating]: ... +@overload +def solve(a: CoComplex128_1nd, b: CoComplex128_1nd) -> Array[np.inexact]: ... + +# keep in sync with `inv` +@overload +def tensorinv(a: _ToFloat64_1nd, ind: int = 2) -> _Array_2nd[np.float64]: ... # type: ignore[overload-overlap] +@overload +def tensorinv(a: ToComplex128_1nd, ind: int = 2) -> _Array_2nd[np.complex128]: ... # type: ignore[overload-overlap] +@overload +def tensorinv(a: ToFloat32_1nd, ind: int = 2) -> _Array_2nd[np.float32]: ... # type: ignore[overload-overlap] +@overload +def tensorinv(a: ToComplex64_1nd, ind: int = 2) -> _Array_2nd[np.complex64]: ... # type: ignore[overload-overlap] +@overload +def tensorinv(a: CoFloat64_1nd, ind: int = 2) -> _Array_2nd[np.floating]: ... +@overload +def tensorinv(a: CoComplex128_1nd, ind: int = 2) -> _Array_2nd[np.inexact]: ... + +# keep in sync with `tensorinv` +@overload +def inv(a: _ToFloat64_1nd) -> _Array_2nd[np.float64]: ... # type: ignore[overload-overlap] +@overload +def inv(a: ToComplex128_1nd) -> _Array_2nd[np.complex128]: ... # type: ignore[overload-overlap] +@overload +def inv(a: ToFloat32_1nd) -> _Array_2nd[np.float32]: ... # type: ignore[overload-overlap] +@overload +def inv(a: ToComplex64_1nd) -> _Array_2nd[np.complex64]: ... # type: ignore[overload-overlap] +@overload +def inv(a: CoFloat64_1nd) -> _Array_2nd[np.floating]: ... +@overload +def inv(a: CoComplex128_1nd) -> _Array_2nd[np.inexact]: ... +# +@overload +def pinv( # type: ignore[overload-overlap] + a: _ToFloat64_1nd, + rcond: ToFloating_nd | None = None, + hermitian: bool = False, + *, + rtol: ToFloating_nd | None = None, +) -> _Array_2nd[np.float64]: ... +@overload +def pinv( # type: ignore[overload-overlap] + a: ToComplex128_1nd, + rcond: ToFloating_nd | None = None, + hermitian: bool = False, + *, + rtol: ToFloating_nd | None = None, +) -> _Array_2nd[np.complex128]: ... @overload -def tensorsolve(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, axes: Iterable[int] | None = ...) -> NDArray[np.float64]: ... +def pinv( # type: ignore[overload-overlap] + a: ToFloat32_1nd, + rcond: ToFloating_nd | None = None, + hermitian: bool = False, + *, + rtol: ToFloating_nd | None = None, +) -> _Array_2nd[np.float32]: ... @overload -def tensorsolve(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, axes: Iterable[int] | None = ...) -> NDArray[np.floating]: ... +def pinv( # type: ignore[overload-overlap] + a: ToComplex64_1nd, + rcond: ToFloating_nd | None = None, + hermitian: bool = False, + *, + rtol: ToFloating_nd | None = None, +) -> _Array_2nd[np.complex64]: ... @overload -def tensorsolve( - a: _ArrayLikeComplex_co, - b: _ArrayLikeComplex_co, - axes: Iterable[int] | None = ..., -) -> NDArray[np.complexfloating]: ... +def pinv( + a: CoFloat64_1nd, + rcond: ToFloating_nd | None = None, + hermitian: bool = False, + *, + rtol: ToFloating_nd | None = None, +) -> _Array_2nd[np.floating]: ... +@overload +def pinv( + a: CoComplex128_1nd, + rcond: ToFloating_nd | None = None, + hermitian: bool = False, + *, + rtol: ToFloating_nd | None = None, +) -> _Array_2nd[np.inexact]: ... + +_PosInt: TypeAlias = L[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] +_NegInt: TypeAlias = L[-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16] # @overload -def solve(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co) -> NDArray[np.float64]: ... +def matrix_power(a: CanArraySized[_NumberT, _Shape2T], n: _PosInt) -> Array[_NumberT, _Shape2T]: ... # type: ignore[overload-overlap] +@overload +def matrix_power(a: CoBool_1nd, n: _PosInt) -> _Array_2nd[np.bool]: ... # type: ignore[overload-overlap] +@overload +def matrix_power(a: ToIntP_1nd, n: _PosInt) -> _Array_2nd[np.intp]: ... # type: ignore[overload-overlap] +@overload +def matrix_power(a: CoInteger_1nd, n: _NegInt) -> _Array_2nd[np.float64]: ... # type: ignore[overload-overlap] +@overload +def matrix_power(a: ToFloat64_1nd, n: CanIndex) -> _Array_2nd[np.float64]: ... # type: ignore[overload-overlap] +@overload +def matrix_power(a: ToComplex128_1nd, n: CanIndex) -> _Array_2nd[np.complex128]: ... # type: ignore[overload-overlap] @overload -def solve(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co) -> NDArray[np.floating]: ... +def matrix_power(a: ToFloat32_1nd, n: CanIndex) -> _Array_2nd[np.float32]: ... # type: ignore[overload-overlap] @overload -def solve(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co) -> NDArray[np.complexfloating]: ... +def matrix_power(a: ToComplex64_1nd, n: CanIndex) -> _Array_2nd[np.complex64]: ... # type: ignore[overload-overlap] +@overload +def matrix_power(a: ToObject_1nd, n: CanIndex) -> _Array_2nd[np.object_]: ... # type: ignore[overload-overlap] +@overload +def matrix_power(a: ToUInteger_1nd, n: _PosInt) -> _Array_2nd[np.unsignedinteger]: ... +@overload +def matrix_power(a: ToInteger_1nd, n: _PosInt) -> _Array_2nd[np.integer]: ... +@overload +def matrix_power(a: CoComplex128_1nd, n: _NegInt) -> _Array_2nd[np.inexact]: ... +@overload +def matrix_power(a: CoNumber_1nd | ToObject_1nd, n: CanIndex) -> _Array_2nd[Any]: ... # @overload -def tensorinv(a: _ArrayLikeInt_co, ind: int = ...) -> NDArray[np.float64]: ... +def cholesky(a: _ToFloat64_1nd) -> _Array_2nd[np.float64]: ... # type: ignore[overload-overlap] +@overload +def cholesky(a: ToComplex128_1nd) -> _Array_2nd[np.complex128]: ... # type: ignore[overload-overlap] @overload -def tensorinv(a: _ArrayLikeFloat_co, ind: int = ...) -> NDArray[np.floating]: ... +def cholesky(a: ToFloat32_1nd) -> _Array_2nd[np.float32]: ... # type: ignore[overload-overlap] @overload -def tensorinv(a: _ArrayLikeComplex_co, ind: int = ...) -> NDArray[np.complexfloating]: ... +def cholesky(a: ToComplex64_1nd) -> _Array_2nd[np.complex64]: ... # type: ignore[overload-overlap] +@overload +def cholesky(a: CoFloat64_1nd) -> _Array_2nd[np.floating]: ... +@overload +def cholesky(a: CoComplex128_1nd) -> _Array_2nd[np.inexact]: ... # @overload -def inv(a: _ArrayLikeInt_co) -> NDArray[np.float64]: ... +def outer(x1: _ToArray_1d[_IntegerT], x2: _ToArray_1d[_IntegerT], /) -> Array_2d[_IntegerT]: ... # type: ignore[overload-overlap] +@overload +def outer(x1: ToBool_1d, x2: ToBool_1d, /) -> Array_2d[np.bool]: ... # type: ignore[overload-overlap] +@overload +def outer(x1: ToIntP_1d, x2: CoIntP_1d, /) -> Array_2d[np.intp]: ... # type: ignore[overload-overlap] +@overload +def outer(x1: CoIntP_1d, x2: ToIntP_1d, /) -> Array_2d[np.intp]: ... # type: ignore[overload-overlap] +@overload +def outer(x1: ToFloat64_1d, x2: CoFloat64_1d, /) -> Array_2d[np.float64]: ... # type: ignore[overload-overlap] +@overload +def outer(x1: CoFloat64_1d, x2: ToFloat64_1d, /) -> Array_2d[np.float64]: ... # type: ignore[overload-overlap] +@overload +def outer(x1: ToComplex128_1d, x2: CoComplex128_1d, /) -> Array_2d[np.complex128]: ... # type: ignore[overload-overlap] +@overload +def outer(x1: CoComplex128_1d, x2: ToComplex128_1d, /) -> Array_2d[np.complex128]: ... # type: ignore[overload-overlap] +@overload +def outer(x1: ToTimeDelta_1d, x2: CoTimeDelta_1d, /) -> Array_2d[np.timedelta64]: ... # type: ignore[overload-overlap] +@overload +def outer(x1: CoTimeDelta_1d, x2: ToTimeDelta_1d, /) -> Array_2d[np.timedelta64]: ... # type: ignore[overload-overlap] +@overload +def outer(x1: ToFloat32_1d, x2: ToFloat32_1d, /) -> Array_2d[np.float32]: ... # type: ignore[overload-overlap] +@overload +def outer(x1: ToComplex64_1d, x2: ToComplex64_1d, /) -> Array_2d[np.complex64]: ... # type: ignore[overload-overlap] @overload -def inv(a: _ArrayLikeFloat_co) -> NDArray[np.floating]: ... +def outer(x1: ToObject_1d, x2: ToObject_1d, /) -> Array_2d[np.object_]: ... @overload -def inv(a: _ArrayLikeComplex_co) -> NDArray[np.complexfloating]: ... +def outer(x1: ToInteger_1d, x2: CoInteger_1d, /) -> Array_2d[np.integer]: ... +@overload +def outer(x1: CoInteger_1d, x2: ToInteger_1d, /) -> Array_2d[np.integer]: ... +@overload +def outer(x1: ToNumber_1d, x2: ToNumber_1d, /) -> Array_2d[Any]: ... -# TODO: The supported input and output dtypes are dependent on the value of `n`. -# For example: `n < 0` always casts integer types to np.float64 -def matrix_power(a: _ArrayLikeComplex_co | _ArrayLikeObject_co, n: SupportsIndex) -> NDArray[Any]: ... +# @overload -def cholesky(a: _ArrayLikeInt_co) -> NDArray[np.float64]: ... +def multi_dot(arrays: Iterable[_ToArray_1ds[_AnyNumberT]], *, out: None = None) -> _AnyNumberT: ... # type: ignore[overload-overlap] @overload -def cholesky(a: _ArrayLikeFloat_co) -> NDArray[np.floating]: ... +def multi_dot(arrays: Iterable[_ToArray_2nd[_AnyNumberT]], *, out: None = None) -> Array[_AnyNumberT]: ... # type: ignore[overload-overlap] @overload -def cholesky(a: _ArrayLikeComplex_co) -> NDArray[np.complexfloating]: ... +def multi_dot(arrays: Iterable[Sequence[bool]], *, out: None = None) -> np.bool: ... @overload -def outer(x1: _ArrayLikeUnknown, x2: _ArrayLikeUnknown) -> NDArray[Any]: ... +def multi_dot(arrays: Iterable[Sequence_2nd[bool]], *, out: None = None) -> Array[np.bool]: ... @overload -def outer(x1: _ArrayLikeBool_co, x2: _ArrayLikeBool_co) -> NDArray[np.bool]: ... +def multi_dot(arrays: Iterable[Sequence[Is[int]]], *, out: None = None) -> np.intp: ... @overload -def outer(x1: _ArrayLikeUInt_co, x2: _ArrayLikeUInt_co) -> NDArray[np.unsignedinteger]: ... +def multi_dot(arrays: Iterable[Sequence_2nd[Is[int]]], *, out: None = None) -> Array[np.intp]: ... @overload -def outer(x1: _ArrayLikeInt_co, x2: _ArrayLikeInt_co) -> NDArray[np.signedinteger]: ... +def multi_dot(arrays: Iterable[Sequence[Is[float]]], *, out: None = None) -> np.float64: ... @overload -def outer(x1: _ArrayLikeFloat_co, x2: _ArrayLikeFloat_co) -> NDArray[np.floating]: ... +def multi_dot(arrays: Iterable[Sequence_2nd[Is[float]]], *, out: None = None) -> Array[np.float64]: ... @overload -def outer(x1: _ArrayLikeComplex_co, x2: _ArrayLikeComplex_co) -> NDArray[np.complexfloating]: ... +def multi_dot(arrays: Iterable[Sequence[Is[complex]]], *, out: None = None) -> np.complex128: ... @overload -def outer(x1: _ArrayLikeTD64_co, x2: _ArrayLikeTD64_co, out: None = ...) -> NDArray[np.timedelta64]: ... +def multi_dot(arrays: Iterable[Sequence_2nd[Is[complex]]], *, out: None = None) -> Array[np.complex128]: ... @overload -def outer(x1: _ArrayLikeObject_co, x2: _ArrayLikeObject_co) -> NDArray[np.object_]: ... +def multi_dot(arrays: Iterable[CoNumber_1nd], *, out: _ArrayT) -> _ArrayT: ... @overload -def outer( - x1: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co, - x2: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co, -) -> NDArray[Any]: ... +def multi_dot(arrays: Iterable[CoNumber_1nd | ToTimeDelta_1nd | ToObject_1nd], *, out: None = None) -> Any: ... + +# pyright false positive in case of typevar constraints @overload -def qr(a: _ArrayLikeInt_co, mode: _ModeKind = ...) -> QRResult: ... +def cross( # type: ignore[overload-overlap] # pyright: ignore[reportOverlappingOverload] + x1: _ToArray_1nd[_AnyNumberT], + x2: _ToArray_1nd[_AnyNumberT], + /, + *, + axis: int = -1, +) -> Array[_AnyNumberT]: ... @overload -def qr(a: _ArrayLikeFloat_co, mode: _ModeKind = ...) -> QRResult: ... +def cross(x1: CoBool_1nd, x2: CoBool_1nd, /, *, axis: int = -1) -> Array[np.bool]: ... @overload -def qr(a: _ArrayLikeComplex_co, mode: _ModeKind = ...) -> QRResult: ... +def cross(x1: ToIntP_1nd, x2: CoIntP_1nd, /, *, axis: int = -1) -> Array[np.intp]: ... @overload -def eigvals(a: _ArrayLikeInt_co) -> NDArray[np.float64] | NDArray[np.complex128]: ... +def cross(x1: CoIntP_1nd, x2: ToIntP_1nd, /, *, axis: int = -1) -> Array[np.intp]: ... @overload -def eigvals(a: _ArrayLikeFloat_co) -> NDArray[np.floating] | NDArray[np.complexfloating]: ... +def cross(x1: ToFloat64_1nd, x2: CoFloat64_1nd, /, *, axis: int = -1) -> Array[np.float64]: ... @overload -def eigvals(a: _ArrayLikeComplex_co) -> NDArray[np.complexfloating]: ... +def cross(x1: CoFloat64_1nd, x2: ToFloat64_1nd, /, *, axis: int = -1) -> Array[np.float64]: ... @overload -def eigvalsh(a: _ArrayLikeInt_co, UPLO: L["L", "U", "l", "u"] = ...) -> NDArray[np.float64]: ... +def cross(x1: ToComplex128_1nd, x2: CoComplex128_1nd, /, *, axis: int = -1) -> Array[np.complex128]: ... @overload -def eigvalsh(a: _ArrayLikeComplex_co, UPLO: L["L", "U", "l", "u"] = ...) -> NDArray[np.floating]: ... +def cross(x1: CoComplex128_1nd, x2: ToComplex128_1nd, /, *, axis: int = -1) -> Array[np.complex128]: ... @overload -def eig(a: _ArrayLikeInt_co) -> EigResult: ... +def cross(x1: ToInteger_1nd, x2: CoInteger_1nd, /, *, axis: int = -1) -> Array[np.integer]: ... @overload -def eig(a: _ArrayLikeFloat_co) -> EigResult: ... +def cross(x1: CoInteger_1nd, x2: ToInteger_1nd, /, *, axis: int = -1) -> Array[np.integer]: ... @overload -def eig(a: _ArrayLikeComplex_co) -> EigResult: ... +def cross(x1: ToFloating_1nd, x2: CoFloating_1nd, /, *, axis: int = -1) -> Array[np.floating]: ... @overload -def eigh(a: _ArrayLikeInt_co, UPLO: L["L", "U", "l", "u"] = ...) -> EighResult: ... +def cross(x1: CoFloating_1nd, x2: ToFloating_1nd, /, *, axis: int = -1) -> Array[np.floating]: ... @overload -def eigh(a: _ArrayLikeFloat_co, UPLO: L["L", "U", "l", "u"] = ...) -> EighResult: ... +def cross(x1: ToCFloating_1nd, x2: CoNumber_1nd, /, *, axis: int = -1) -> Array[np.complexfloating]: ... @overload -def eigh(a: _ArrayLikeComplex_co, UPLO: L["L", "U", "l", "u"] = ...) -> EighResult: ... +def cross(x1: CoNumber_1nd, x2: ToCFloating_1nd, /, *, axis: int = -1) -> Array[np.complexfloating]: ... @overload -def svd(a: _ArrayLikeInt_co, full_matrices: bool = ..., compute_uv: L[True] = ..., hermitian: bool = ...) -> SVDResult: ... +def cross(x1: CoNumber_1nd, x2: CoNumber_1nd, /, *, axis: int = -1) -> Array[Any]: ... + +# pyright false positive in case of typevar constraints @overload -def svd(a: _ArrayLikeFloat_co, full_matrices: bool = ..., compute_uv: L[True] = ..., hermitian: bool = ...) -> SVDResult: ... +def matmul(x1: _ToArray_1ds[_AnyNumberT], x2: _ToArray_1ds[_AnyNumberT], /) -> _AnyNumberT: ... # type: ignore[overload-overlap] # pyright: ignore[reportOverlappingOverload] @overload -def svd(a: _ArrayLikeComplex_co, full_matrices: bool = ..., compute_uv: L[True] = ..., hermitian: bool = ...) -> SVDResult: ... +def matmul(x1: _ToArray_2nd[_AnyNumberT], x2: _ToArray_1nd[_AnyNumberT], /) -> Array[_AnyNumberT]: ... # type: ignore[overload-overlap] # pyright: ignore[reportOverlappingOverload] @overload -def svd( - a: _ArrayLikeInt_co, - full_matrices: bool = ..., - compute_uv: L[False] = ..., - hermitian: bool = ..., -) -> NDArray[np.float64]: ... +def matmul(x1: _ToArray_1nd[_AnyNumberT], x2: _ToArray_2nd[_AnyNumberT], /) -> Array[_AnyNumberT]: ... # type: ignore[overload-overlap] # pyright: ignore[reportOverlappingOverload] +@overload +def matmul(x1: ToBool_1ds, x2: ToBool_1ds, /) -> np.bool: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: ToBool_2nd, x2: ToBool_1nd, /) -> Array[np.bool]: ... +@overload +def matmul(x1: ToBool_1nd, x2: ToBool_2nd, /) -> Array[np.bool]: ... +@overload +def matmul(x1: ToIntP_1ds, x2: CoIntP_1ds, /) -> np.intp: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: CoIntP_1ds, x2: ToIntP_1ds, /) -> np.intp: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: ToIntP_2nd, x2: CoIntP_1nd, /) -> Array[np.intp]: ... @overload +def matmul(x1: CoIntP_1nd, x2: ToIntP_2nd, /) -> Array[np.intp]: ... +@overload +def matmul(x1: ToFloat64_1ds, x2: CoFloat64_1ds, /) -> np.float64: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: CoFloat64_1ds, x2: ToFloat64_1ds, /) -> np.float64: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: ToFloat64_2nd, x2: CoFloat64_1nd, /) -> Array[np.float64]: ... +@overload +def matmul(x1: CoFloat64_1nd, x2: ToFloat64_2nd, /) -> Array[np.float64]: ... +@overload +def matmul(x1: ToComplex128_1ds, x2: CoComplex128_1ds, /) -> np.complex128: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: CoComplex128_1ds, x2: ToComplex128_1ds, /) -> np.complex128: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: ToComplex128_2nd, x2: CoComplex128_1nd, /) -> Array[np.complex128]: ... +@overload +def matmul(x1: CoComplex128_1nd, x2: ToComplex128_2nd, /) -> Array[np.complex128]: ... +@overload +def matmul(x1: ToInteger_1ds, x2: CoInteger_1ds, /) -> np.integer: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: CoInteger_1ds, x2: ToInteger_1ds, /) -> np.integer: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: ToInteger_2nd, x2: CoInteger_1nd, /) -> Array[np.integer]: ... +@overload +def matmul(x1: CoInteger_1nd, x2: ToInteger_2nd, /) -> Array[np.integer]: ... +@overload +def matmul(x1: ToFloating_1ds, x2: CoFloating_1ds, /) -> np.floating: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: CoFloating_1ds, x2: ToFloating_1ds, /) -> np.floating: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: ToFloating_2nd, x2: CoFloating_1nd, /) -> Array[np.floating]: ... +@overload +def matmul(x1: CoFloating_1nd, x2: ToFloating_2nd, /) -> Array[np.floating]: ... +@overload +def matmul(x1: ToCFloating_1ds, x2: CoNumber_1ds, /) -> np.complexfloating: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: CoNumber_1ds, x2: ToCFloating_1ds, /) -> np.complexfloating: ... # type: ignore[overload-overlap] +@overload +def matmul(x1: ToCFloating_2nd, x2: CoNumber_1nd, /) -> Array[np.complexfloating]: ... +@overload +def matmul(x1: CoNumber_1nd, x2: ToCFloating_2nd, /) -> Array[np.complexfloating]: ... +@overload +def matmul(x1: CoNumber_2nd, x2: CoNumber_1nd, /) -> Array[Any]: ... +@overload +def matmul(x1: CoNumber_1nd, x2: CoNumber_2nd, /) -> Array[Any]: ... +@overload +def matmul(x1: CoNumber_1nd, x2: CoNumber_1nd, /) -> Any: ... + +# +@overload # float64 +def eig(a: _ToFloat64_1nd) -> EigResult[np.float64] | EigResult[np.complex128]: ... # type: ignore[overload-overlap] +@overload # complex128 +def eig(a: ToComplex128_1nd) -> EigResult[np.complex128]: ... # type: ignore[overload-overlap] +@overload # complex64 +def eig(a: ToComplex64_1nd) -> EigResult[np.complex64]: ... +@overload # float32 +def eig(a: ToFloat32_1nd) -> EigResult[np.float32] | EigResult[np.complex64]: ... +@overload # +complex128 +def eig(a: CoComplex128_1nd) -> EigResult: ... + +# +@overload # float64 +def eigvals(a: _ToFloat64_1nd) -> Array[np.float64] | Array[np.complex128]: ... # type: ignore[overload-overlap] +@overload # complex128 +def eigvals(a: ToComplex128_1nd) -> Array[np.complex128]: ... # type: ignore[overload-overlap] +@overload # complex64 +def eigvals(a: ToComplex64_1nd) -> Array[np.complex64]: ... +@overload # float32 +def eigvals(a: ToFloat32_1nd) -> Array[np.float32] | Array[np.complex64]: ... +@overload # +complex128 +def eigvals(a: CoComplex128_1nd) -> Array[np.inexact]: ... + +# +@overload # float64 +def eigh(a: _ToFloat64_1nd, UPLO: _UPLO = "L") -> EighResult[np.float64, np.float64]: ... # type: ignore[overload-overlap] +@overload # complex128 +def eigh(a: ToComplex128_1nd, UPLO: _UPLO = "L") -> EighResult[np.float64, np.complex128]: ... # type: ignore[overload-overlap] +@overload # float32 +def eigh(a: ToFloat32_1nd, UPLO: _UPLO = "L") -> EighResult[np.float32, np.float32]: ... # type: ignore[overload-overlap] +@overload # complex64 +def eigh(a: ToComplex64_1nd, UPLO: _UPLO = "L") -> EighResult[np.float32, np.complex64]: ... +@overload # +complex128 +def eigh(a: CoComplex128_1nd, UPLO: _UPLO = "L") -> EighResult: ... + +# +@overload # float64 | complex128 +def eigvalsh(a: _ToInexact64_1nd, UPLO: _UPLO = "L") -> Array[np.float64]: ... +@overload # float32 | complex64 +def eigvalsh(a: _ToInexact32_1nd, UPLO: _UPLO = "L") -> Array[np.float32]: ... +@overload # +complex128 +def eigvalsh(a: CoComplex128_1nd, UPLO: _UPLO = "L") -> Array[np.floating]: ... + +# +@overload # float64, reduced|complete +def qr(a: _ToFloat64_1nd, mode: L["reduced", "complete"] = "reduced") -> QRResult[np.float64]: ... # type: ignore[overload-overlap] +@overload # float64, raw +def qr(a: _ToFloat64_1nd, mode: L["raw"]) -> _2Tuple[_Array_2nd[np.float64]]: ... # type: ignore[overload-overlap] +@overload # float64, r +def qr(a: _ToFloat64_1nd, mode: L["r"]) -> _Array_2nd[np.float64]: ... # type: ignore[overload-overlap] +@overload # complex128, reduced|complete +def qr(a: ToComplex128_1nd, mode: L["reduced", "complete"] = "reduced") -> QRResult[np.complex128]: ... # type: ignore[overload-overlap] +@overload # complex128, raw +def qr(a: ToComplex128_1nd, mode: L["raw"]) -> _2Tuple[_Array_2nd[np.complex128]]: ... # type: ignore[overload-overlap] +@overload # complex128, r +def qr(a: ToComplex128_1nd, mode: L["r"]) -> _Array_2nd[np.complex128]: ... # type: ignore[overload-overlap] +@overload # float32, reduced|complete +def qr(a: ToFloat32_1nd, mode: L["reduced", "complete"] = "reduced") -> QRResult[np.float32]: ... # type: ignore[overload-overlap] +@overload # float32, raw +def qr(a: ToFloat32_1nd, mode: L["raw"]) -> _2Tuple[_Array_2nd[np.float32]]: ... # type: ignore[overload-overlap] +@overload # float32, r +def qr(a: ToFloat32_1nd, mode: L["r"]) -> _Array_2nd[np.float32]: ... # type: ignore[overload-overlap] +@overload # complex64, reduced|complete +def qr(a: ToComplex64_1nd, mode: L["reduced", "complete"] = "reduced") -> QRResult[np.complex64]: ... +@overload # complex64, raw +def qr(a: ToComplex64_1nd, mode: L["raw"]) -> _2Tuple[_Array_2nd[np.complex64]]: ... +@overload # complex64, r +def qr(a: ToComplex64_1nd, mode: L["r"]) -> _Array_2nd[np.complex64]: ... +@overload # +complex128, reduced|complete +def qr(a: CoComplex128_1nd, mode: L["reduced", "complete"] = "reduced") -> QRResult[np.inexact]: ... +@overload # +complex128, raw +def qr(a: CoComplex128_1nd, mode: L["raw"]) -> _2Tuple[_Array_2nd[np.inexact]]: ... +@overload # +complex128, r +def qr(a: CoComplex128_1nd, mode: L["r"]) -> _Array_2nd[np.inexact]: ... + +# +@overload # float64 | complex128, compute_uv=False (positional) +def svd( + a: _ToInexact64_1nd, + full_matrices: bool, + compute_uv: _False, + hermitian: bool = False, +) -> Array[np.float64]: ... +@overload # float64 | complex128, compute_uv=False (keyword) +def svd( + a: _ToInexact64_1nd, + full_matrices: bool = True, + *, + compute_uv: _False, + hermitian: bool = False, +) -> Array[np.float64]: ... +@overload # float64, compute_uv=True +def svd( # type: ignore[overload-overlap] + a: _ToFloat64_1nd, + full_matrices: bool = True, + compute_uv: _True = True, + hermitian: bool = False, +) -> SVDResult[np.float64, np.float64]: ... +@overload # complex128, compute_uv=True +def svd( # type: ignore[overload-overlap] + a: ToComplex128_1nd, + full_matrices: bool = True, + compute_uv: _True = True, + hermitian: bool = False, +) -> SVDResult[np.float64, np.complex128]: ... +@overload # float32, compute_uv=True +def svd( # type: ignore[overload-overlap] + a: ToFloat32_1nd, + full_matrices: bool = True, + compute_uv: _True = True, + hermitian: bool = False, +) -> SVDResult[np.float32, np.float32]: ... +@overload # float32 | complex64, compute_uv=False (positional) +def svd( + a: _ToInexact32_1nd, + full_matrices: bool, + compute_uv: _False, + hermitian: bool = False, +) -> Array[np.float32]: ... +@overload # float32 | complex64, compute_uv=False (keyword) +def svd( + a: _ToInexact32_1nd, + full_matrices: bool = True, + *, + compute_uv: _False, + hermitian: bool = False, +) -> Array[np.float32]: ... +@overload # complex64, compute_uv=True +def svd( + a: ToComplex64_1nd, + full_matrices: bool = True, + compute_uv: _True = True, + hermitian: bool = False, +) -> SVDResult[np.float32, np.complex64]: ... +@overload # +complex128, compute_uv=True +def svd( + a: CoComplex128_1nd, + full_matrices: bool = True, + compute_uv: _True = True, + hermitian: bool = False, +) -> SVDResult: ... +@overload # +complex128, compute_uv=False (positional) +def svd( + a: CoComplex128_1nd, + full_matrices: bool, + compute_uv: _False, + hermitian: bool = False, +) -> Array[np.floating]: ... +@overload # +complex128, compute_uv=False (keyword) def svd( - a: _ArrayLikeComplex_co, - full_matrices: bool = ..., - compute_uv: L[False] = ..., - hermitian: bool = ..., -) -> NDArray[np.floating]: ... -def svdvals(x: _ArrayLikeInt_co | _ArrayLikeFloat_co | _ArrayLikeComplex_co) -> NDArray[np.floating]: ... - -# TODO: Returns a scalar for 2D arrays and -# a `(x.ndim - 2)`` dimensionl array otherwise -def cond(x: _ArrayLikeComplex_co, p: float | L["fro", "nuc"] | None = ...) -> Any: ... - -# TODO: Returns `int` for <2D arrays and `intp` otherwise + a: CoComplex128_1nd, + full_matrices: bool = True, + *, + compute_uv: _False, + hermitian: bool = False, +) -> Array[np.floating]: ... + +# +@overload # float64 | complex128 +def svdvals(x: _ToInexact64_1nd, /) -> Array[np.float64]: ... +@overload # floaat32 | complex64 +def svdvals(x: _ToInexact32_1nd, /) -> Array[np.float32]: ... +@overload # +complex128 +def svdvals(x: CoComplex128_1nd, /) -> Array[np.floating]: ... + +# +@overload # <2d +complex128 +def matrix_rank( + A: CoComplex128_0d | CoComplex128_1ds, + tol: ToFloating_nd | None = None, + hermitian: bool = False, + *, + rtol: ToFloating_nd | None = None, +) -> L[0, 1]: ... +@overload # 2d +complex128 +def matrix_rank( # type: ignore[overload-overlap] + A: CoComplex128_2ds, + tol: ToFloating_nd | None = None, + hermitian: bool = False, + *, + rtol: ToFloating_nd | None = None, +) -> np.intp: ... +@overload # >2d +complex128 def matrix_rank( - A: _ArrayLikeComplex_co, - tol: _ArrayLikeFloat_co | None = ..., - hermitian: bool = ..., + A: CoComplex128_3nd, + tol: ToFloating_nd | None = None, + hermitian: bool = False, *, - rtol: _ArrayLikeFloat_co | None = ..., + rtol: ToFloating_nd | None = None, +) -> Array[np.intp]: ... +@overload # nd +complex128 +def matrix_rank( + A: CoComplex128_nd, + tol: ToFloating_nd | None = None, + hermitian: bool = False, + *, + rtol: ToFloating_nd | None = None, ) -> Any: ... + +# +@overload # 2d float64 | complex128 +def cond(x: _ToInexact64_2ds, p: _Ord | None = None) -> np.float64: ... # type: ignore[overload-overlap] +@overload # 2d float32 | complex64 +def cond(x: _ToInexact32_2ds, p: _Ord | None = None) -> np.float32: ... # type: ignore[overload-overlap] +@overload # 2d +complex128 +def cond(x: CoComplex128_2ds, p: _Ord | None = None) -> np.floating: ... # type: ignore[overload-overlap] +@overload # >2d float64 | complex128 +def cond(x: _ToInexact64_3nd, p: _Ord | None = None) -> Array[np.float64]: ... +@overload # >2d float32 | complex64 +def cond(x: _ToInexact32_3nd, p: _Ord | None = None) -> Array[np.float32]: ... +@overload # >2d +complex128 +def cond(x: CoComplex128_3nd, p: _Ord | None = None) -> Array[np.floating]: ... +@overload # +complex128 +def cond(x: CoComplex128_1nd, p: _Ord | None = None) -> Any: ... + +# keep in sync with `det` +@overload # 2d float64 +def slogdet(a: _ToFloat64_2ds) -> SlogdetResult[np.float64, np.float64]: ... # type: ignore[overload-overlap] +@overload # 2d float32 +def slogdet(a: ToFloat32_2ds) -> SlogdetResult[np.float32, np.float32]: ... # type: ignore[overload-overlap] +@overload # 2d complex128 +def slogdet(a: ToComplex128_2ds) -> SlogdetResult[np.float64, np.complex128]: ... # type: ignore[overload-overlap] +@overload # 2d complex64 +def slogdet(a: ToComplex64_2ds) -> SlogdetResult[np.float32, np.complex64]: ... # type: ignore[overload-overlap] +@overload # >2d float64 +def slogdet(a: _ToFloat64_3nd) -> SlogdetResult[Array[np.float64], Array[np.float64]]: ... # type: ignore[overload-overlap] +@overload # >2d float32 +def slogdet(a: ToFloat32_3nd) -> SlogdetResult[Array[np.float32], Array[np.float32]]: ... # type: ignore[overload-overlap] +@overload # >2d complex128 +def slogdet(a: ToComplex128_3nd) -> SlogdetResult[Array[np.float64], Array[np.complex128]]: ... +@overload # >2d complex64 +def slogdet(a: ToComplex64_3nd) -> SlogdetResult[Array[np.float32], Array[np.complex64]]: ... +@overload # +complex128 +def slogdet(a: CoComplex128_1nd) -> SlogdetResult[Any, Any]: ... + +# +@overload # 2d float64 +def det(a: _ToFloat64_2ds) -> np.float64: ... # type: ignore[overload-overlap] +@overload # 2d float32 +def det(a: ToFloat32_2ds) -> np.float32: ... # type: ignore[overload-overlap] +@overload # 2d complex128 +def det(a: ToComplex128_2ds) -> np.complex128: ... # type: ignore[overload-overlap] +@overload # 2d complex64 +def det(a: ToComplex64_2ds) -> np.complex64: ... # type: ignore[overload-overlap] +@overload # >2d float64 +def det(a: _ToFloat64_3nd) -> Array[np.float64]: ... # type: ignore[overload-overlap] +@overload # >2d float32 +def det(a: ToFloat32_3nd) -> Array[np.float32]: ... # type: ignore[overload-overlap] +@overload # >2d complex128 +def det(a: ToComplex128_3nd) -> Array[np.complex128]: ... +@overload # >2d complex64 +def det(a: ToComplex64_3nd) -> Array[np.complex64]: ... +@overload # +complex128 +def det(a: CoComplex128_1nd) -> Any: ... + +# +@overload # float64, +float64 +def lstsq(a: _ToFloat64_1nd, b: CoFloat64_1nd, rcond: float | None = None) -> _LstSqResult[np.float64, np.float64]: ... # type: ignore[overload-overlap] +@overload # +float64, float64 +def lstsq(a: CoFloat64_1nd, b: _ToFloat64_1nd, rcond: float | None = None) -> _LstSqResult[np.float64, np.float64]: ... # type: ignore[overload-overlap] +@overload # float32, float32 +def lstsq(a: ToFloat32_1nd, b: ToFloat32_1nd, rcond: float | None = None) -> _LstSqResult[np.float32, np.float32]: ... # type: ignore[overload-overlap] +@overload # complex128, +complex128 +def lstsq( # type: ignore[overload-overlap] + a: ToComplex128_1nd, + b: CoComplex128_1nd, + rcond: float | None = None, +) -> _LstSqResult[np.complex128, np.float64]: ... +@overload # +complex128, complex128 +def lstsq( # type: ignore[overload-overlap] + a: CoComplex128_1nd, + b: ToComplex128_1nd, + rcond: float | None = None, +) -> _LstSqResult[np.complex128, np.float64]: ... +@overload # complex64, complex64 +def lstsq( + a: ToComplex64_1nd, + b: CoComplex64_1nd, + rcond: float | None = None, +) -> _LstSqResult[np.complex64, np.float32]: ... +@overload # +complex128, +complex128 +def lstsq( + a: CoComplex128_1nd, + b: CoComplex128_1nd, + rcond: float | None = None, +) -> _LstSqResult[np.inexact, np.floating]: ... + +# +@overload # float64 | complex128 | character, axis=None, keepdims=False +def norm(x: _ToUnsafe64_1nd, ord: _Ord | None = None, axis: None = None, keepdims: _False = False) -> np.float64: ... +@overload # float64 | complex128 | character, keepdims=True (keyword) +def norm(x: _ToUnsafe64_1nd, ord: _Ord | None = None, axis: _Ax2 | None = None, *, keepdims: _True) -> _Array_2nd[np.float64]: ... # type: ignore[overload-overlap] +@overload # float64 | complex128 | character, axis= (positional) +def norm(x: _ToUnsafe64_1nd, ord: _Ord | None, axis: _Ax2, keepdims: bool = False) -> Array[np.float64]: ... # type: ignore[overload-overlap] +@overload # float64 | complex128 | character, axis= (keyword) +def norm(x: _ToUnsafe64_1nd, ord: _Ord | None = None, *, axis: _Ax2, keepdims: bool = False) -> Array[np.float64]: ... # type: ignore[overload-overlap] +@overload # float16, axis=None, keepdims=False +def norm(x: ToFloat16_1nd, ord: _Ord | None = None, axis: None = None, keepdims: _False = False) -> np.float16: ... +@overload # float16, keepdims=True (keyword) +def norm(x: ToFloat16_1nd, ord: _Ord | None = None, axis: _Ax2 | None = None, *, keepdims: _True) -> _Array_2nd[np.float16]: ... +@overload # float16, axis= (keyword) +def norm(x: ToFloat16_1nd, ord: _Ord | None = None, *, axis: _Ax2, keepdims: bool = False) -> Array[np.float16]: ... # type: ignore[overload-overlap] +@overload # float32 | complex64, axis=None, keepdims=False +def norm(x: _ToInexact32_1nd, ord: _Ord | None = None, axis: None = None, keepdims: _False = False) -> np.float32: ... +@overload # float32 | complex64, keepdims=True (keyword) +def norm( + x: _ToInexact32_1nd, ord: _Ord | None = None, axis: _Ax2 | None = None, *, keepdims: _True +) -> _Array_2nd[np.float32]: ... +@overload # float32 | complex64, axis= (positional) +def norm(x: _ToInexact32_1nd, ord: _Ord | None, axis: _Ax2, keepdims: bool = False) -> Array[np.float32]: ... # type: ignore[overload-overlap] +@overload # float32 | complex64, axis= (keyword) +def norm(x: _ToInexact32_1nd, ord: _Ord | None = None, *, axis: _Ax2, keepdims: bool = False) -> Array[np.float32]: ... # type: ignore[overload-overlap] +@overload # longdouble | clongdouble, axis=None, keepdims=False +def norm(x: _ToInexactLD_1nd, ord: _Ord | None = None, axis: None = None, keepdims: _False = False) -> np.longdouble: ... +@overload # longdouble | clongdouble, keepdims=True (keyword) +def norm( + x: _ToInexactLD_1nd, ord: _Ord | None = None, axis: _Ax2 | None = None, *, keepdims: _True +) -> _Array_2nd[np.longdouble]: ... +@overload # longdouble | clongdouble, axis= (positional) +def norm(x: _ToInexactLD_1nd, ord: _Ord | None, axis: _Ax2, keepdims: bool = False) -> Array[np.longdouble]: ... # type: ignore[overload-overlap] +@overload # longdouble | clongdouble, axis= (keyword) +def norm(x: _ToInexactLD_1nd, ord: _Ord | None = None, *, axis: _Ax2, keepdims: bool = False) -> Array[np.longdouble]: ... # type: ignore[overload-overlap] +@overload # +number, axis=None, keepdims=False +def norm(x: CoNumber_1nd, ord: _Ord | None = None, axis: None = None, keepdims: _False = False) -> np.floating: ... +@overload # +number, keepdims=True +def norm(x: CoNumber_1nd, ord: _Ord | None = None, axis: _Ax2 | None = None, *, keepdims: _True) -> _Array_2nd[np.floating]: ... +@overload # +number, axis= (positional) +def norm(x: CoNumber_1nd, ord: _Ord | None, axis: _Ax2, keepdims: bool = False) -> Array[np.floating]: ... +@overload # +number, axis= (keyword) +def norm(x: CoNumber_1nd, ord: _Ord | None = None, *, axis: _Ax2, keepdims: bool = False) -> Array[np.floating]: ... +@overload # +number +def norm(x: CoNumber_1nd, ord: _Ord | None = None, axis: _Ax2 | None = None, keepdims: bool = False) -> Any: ... + +# +@overload # 2d float64 | complex128 | character +def matrix_norm(x: _ToUnsafe64_2ds, /, *, keepdims: bool = False, ord: _Ord = "fro") -> np.float64: ... # type: ignore[overload-overlap] +@overload # nd float64 | complex128 | character, keepdims=True +def matrix_norm(x: _ToUnsafe64_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array_2nd[np.float64]: ... # type: ignore[overload-overlap] +@overload # >2d float64 | complex128 | character +def matrix_norm(x: _ToUnsafe64_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> Array[np.float64]: ... # type: ignore[overload-overlap] +@overload # 2d float16 +def matrix_norm(x: ToFloat16_2ds, /, *, keepdims: bool = False, ord: _Ord = "fro") -> np.float16: ... # type: ignore[overload-overlap] +@overload # nd float16, keepdims=True +def matrix_norm(x: ToFloat16_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array_2nd[np.float16]: ... # type: ignore[overload-overlap] +@overload # >2d float16 +def matrix_norm(x: ToFloat16_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> Array[np.float16]: ... # type: ignore[overload-overlap] +@overload # 2d float32 | complex64, keepdims=True +def matrix_norm(x: _ToInexact32_2ds, /, *, keepdims: bool = False, ord: _Ord = "fro") -> np.float32: ... # type: ignore[overload-overlap] +@overload # nd float32 | complex64, keepdims=True +def matrix_norm(x: _ToInexact32_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array_2nd[np.float32]: ... # type: ignore[overload-overlap] +@overload # >2d float32 | complex64 +def matrix_norm(x: _ToInexact32_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> Array[np.float32]: ... # type: ignore[overload-overlap] +@overload # 2d longdouble | clongdouble +def matrix_norm(x: _ToInexactLD_2ds, /, *, keepdims: bool = False, ord: _Ord = "fro") -> np.longdouble: ... # type: ignore[overload-overlap] +@overload # nd longdouble | clongdouble, keepdims=True +def matrix_norm(x: _ToInexactLD_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array_2nd[np.longdouble]: ... +@overload # >2d longdouble | clongdouble +def matrix_norm(x: _ToInexactLD_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> Array[np.longdouble]: ... +@overload # 2d +number +def matrix_norm(x: CoNumber_2ds, /, *, keepdims: bool = False, ord: _Ord = "fro") -> np.floating: ... # type: ignore[overload-overlap] +@overload # nd +number, keepdims=True +def matrix_norm(x: CoNumber_1nd, /, *, keepdims: _True, ord: _Ord = "fro") -> _Array_2nd[np.floating]: ... +@overload # >2d +number +def matrix_norm(x: CoNumber_3nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> Array[np.floating]: ... +@overload # nd +number +def matrix_norm(x: CoNumber_1nd | ToCharacter_1nd, /, *, keepdims: bool = False, ord: _Ord = "fro") -> Any: ... + +# +@overload # float64 | complex128 | character, axis=None, keepdims=False +def vector_norm(x: _ToUnsafe64_1nd, /, *, axis: None = None, keepdims: _False = False, ord: float = 2) -> np.float64: ... +@overload # float64 | complex128 | character, keepdims=True +def vector_norm(x: _ToUnsafe64_1nd, /, *, axis: _Ax2 | None = None, keepdims: _True, ord: float = 2) -> Array[np.float64]: ... # type: ignore[overload-overlap] +@overload # float64 | complex128 | character, axis= +def vector_norm(x: _ToUnsafe64_1nd, /, *, axis: _Ax2, keepdims: bool = False, ord: float = 2) -> Array[np.float64]: ... # type: ignore[overload-overlap] +@overload # float16, axis=None, keepdims=False +def vector_norm(x: ToFloat16_1nd, /, *, axis: None = None, keepdims: _False = False, ord: float = 2) -> np.float16: ... +@overload # float16, keepdims=True +def vector_norm(x: ToFloat16_1nd, /, *, axis: _Ax2 | None = None, keepdims: _True, ord: float = 2) -> Array[np.float16]: ... +@overload # float16, axis= +def vector_norm(x: ToFloat16_1nd, /, *, axis: _Ax2, keepdims: bool = False, ord: float = 2) -> Array[np.float16]: ... +@overload # float32 | complex64, axis=None, keepdims=False +def vector_norm(x: _ToInexact32_1nd, /, *, axis: None = None, keepdims: _False = False, ord: float = 2) -> np.float32: ... +@overload # float32 | complex64, keepdims=True +def vector_norm(x: _ToInexact32_1nd, /, *, axis: _Ax2 | None = None, keepdims: _True, ord: float = 2) -> Array[np.float32]: ... +@overload # float32 | complex64, axis= +def vector_norm(x: _ToInexact32_1nd, /, *, axis: _Ax2, keepdims: bool = False, ord: float = 2) -> Array[np.float32]: ... +@overload # longdouble | clongdouble, axis=None, keepdims=False +def vector_norm(x: _ToInexactLD_1nd, /, *, axis: None = None, keepdims: _False = False, ord: float = 2) -> np.longdouble: ... +@overload # longdouble | clongdouble, keepdims=True +def vector_norm(x: _ToInexactLD_1nd, /, *, axis: _Ax2 | None = None, keepdims: _True, ord: float = 2) -> Array[np.longdouble]: ... +@overload # longdouble | clongdouble, axis= +def vector_norm(x: _ToInexactLD_1nd, /, *, axis: _Ax2, keepdims: bool = False, ord: float = 2) -> Array[np.longdouble]: ... +@overload # +number, axis=None, keepdims=False +def vector_norm(x: CoNumber_1nd, /, *, axis: None = None, keepdims: _False = False, ord: float = 2) -> np.floating: ... +@overload # +number, keepdims=True +def vector_norm(x: CoNumber_1nd, /, *, axis: _Ax2 | None = None, keepdims: _True, ord: float = 2) -> Array[np.floating]: ... +@overload # +number, axis= +def vector_norm(x: CoNumber_1nd, /, *, axis: _Ax2, keepdims: bool = False, ord: float = 2) -> Array[np.floating]: ... +@overload # +number +def vector_norm(x: CoNumber_1nd, /, *, axis: _Ax2 | None = None, keepdims: bool = False, ord: float = 2) -> Any: ... + +# @overload -def pinv( - a: _ArrayLikeInt_co, - rcond: _ArrayLikeFloat_co = ..., - hermitian: bool = ..., -) -> NDArray[np.float64]: ... +def diagonal(x: Sequence_2nd[ToObject_0d], /, *, offset: CanIndex = 0) -> Array[np.object_]: ... @overload -def pinv( - a: _ArrayLikeFloat_co, - rcond: _ArrayLikeFloat_co = ..., - hermitian: bool = ..., -) -> NDArray[np.floating]: ... +def diagonal(x: _ToArray_2ds[_ScalarT], /, *, offset: CanIndex = 0) -> Array[_ScalarT, tuple[int]]: ... @overload -def pinv( - a: _ArrayLikeComplex_co, - rcond: _ArrayLikeFloat_co = ..., - hermitian: bool = ..., -) -> NDArray[np.complexfloating]: ... - -# 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) -> SlogdetResult: ... +def diagonal(x: _ToArray_2nd_ish[_ScalarT], /, *, offset: CanIndex = 0) -> Array[_ScalarT]: ... +@overload +def diagonal(x: Sequence_2nd[bool], /, *, offset: CanIndex = 0) -> Array[np.bool]: ... +@overload +def diagonal(x: Sequence_2nd[Is[int]], /, *, offset: CanIndex = 0) -> Array[np.int_]: ... +@overload +def diagonal(x: Sequence_2nd[Is[float]], /, *, offset: CanIndex = 0) -> Array[np.float64]: ... +@overload +def diagonal(x: Sequence_2nd[Is[complex]], /, *, offset: CanIndex = 0) -> Array[np.complex128]: ... +@overload +def diagonal(x: Sequence_2nd[Is[bytes]], /, *, offset: CanIndex = 0) -> Array[np.bytes_]: ... +@overload +def diagonal(x: Sequence_2nd[Is[str]], /, *, offset: CanIndex = 0) -> Array[np.str_]: ... +@overload +def diagonal(x: ToAny_1nd, /, *, offset: CanIndex = 0) -> Array[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: float | None = ..., -) -> tuple[ - NDArray[np.float64], - NDArray[np.float64], - np.int32, - NDArray[np.float64], -]: ... +def trace(x: _ToArray_2ds[_ScalarT], /, *, offset: CanIndex = 0, dtype: None = None) -> _ScalarT: ... # type: ignore[overload-overlap] @overload -def lstsq( - a: _ArrayLikeFloat_co, - b: _ArrayLikeFloat_co, - rcond: float | None = ..., -) -> tuple[ - NDArray[np.floating], - NDArray[np.floating], - np.int32, - NDArray[np.floating], -]: ... +def trace(x: _ToArray_3nd[_ScalarT], /, *, offset: CanIndex = 0, dtype: None = None) -> Array[_ScalarT]: ... # type: ignore[overload-overlap] @overload -def lstsq( - a: _ArrayLikeComplex_co, - b: _ArrayLikeComplex_co, - rcond: float | None = ..., -) -> tuple[ - NDArray[np.complexfloating], - NDArray[np.floating], - np.int32, - NDArray[np.floating], -]: ... +def trace(x: Sequence_2d[bool], /, *, offset: CanIndex = 0, dtype: None = None) -> np.bool: ... @overload -def norm( - x: ArrayLike, - ord: float | L["fro", "nuc"] | None = ..., - axis: None = ..., - keepdims: bool = ..., -) -> np.floating: ... +def trace(x: Sequence_3nd[bool], /, *, offset: CanIndex = 0, dtype: None = None) -> Array[np.bool]: ... @overload -def norm( - x: ArrayLike, - ord: float | L["fro", "nuc"] | None = ..., - axis: SupportsInt | SupportsIndex | tuple[int, ...] = ..., - keepdims: bool = ..., -) -> Any: ... +def trace(x: Sequence_2d[Is[int]], /, *, offset: CanIndex = 0, dtype: None = None) -> np.int_: ... @overload -def matrix_norm( - x: ArrayLike, - ord: float | L["fro", "nuc"] | None = ..., - keepdims: bool = ..., -) -> np.floating: ... +def trace(x: Sequence_3nd[Is[int]], /, *, offset: CanIndex = 0, dtype: None = None) -> Array[np.int_]: ... @overload -def matrix_norm( - x: ArrayLike, - ord: float | L["fro", "nuc"] | None = ..., - keepdims: bool = ..., -) -> Any: ... +def trace(x: Sequence_2d[Is[float]], /, *, offset: CanIndex = 0, dtype: None = None) -> np.float64: ... @overload -def vector_norm( - x: ArrayLike, - axis: None = ..., - ord: float | None = ..., - keepdims: bool = ..., -) -> np.floating: ... -@overload -def vector_norm( - x: ArrayLike, - axis: SupportsInt | SupportsIndex | tuple[int, ...] = ..., - ord: float | None = ..., - keepdims: bool = ..., -) -> Any: ... - -# TODO: Returns a scalar or array -def multi_dot( - arrays: Iterable[_ArrayLikeComplex_co | _ArrayLikeObject_co | _ArrayLikeTD64_co], - *, - out: NDArray[Any] | None = ..., -) -> Any: ... -def diagonal( - x: ArrayLike, # >= 2D array - offset: SupportsIndex = ..., -) -> NDArray[Any]: ... -def trace( - x: ArrayLike, # >= 2D array - offset: SupportsIndex = ..., - dtype: DTypeLike = ..., -) -> Any: ... +def trace(x: Sequence_3nd[Is[float]], /, *, offset: CanIndex = 0, dtype: None = None) -> Array[np.float64]: ... +@overload +def trace(x: Sequence_2d[Is[complex]], /, *, offset: CanIndex = 0, dtype: None = None) -> np.complex128: ... +@overload +def trace(x: Sequence_3nd[Is[complex]], /, *, offset: CanIndex = 0, dtype: None = None) -> Array[np.complex128]: ... +@overload +def trace(x: CoNumber_2ds, /, *, offset: CanIndex = 0, dtype: _ToDType[_ScalarT]) -> _ScalarT: ... # type: ignore[overload-overlap] +@overload +def trace(x: CoNumber_3nd, /, *, offset: CanIndex = 0, dtype: _ToDType[_ScalarT]) -> Array[_ScalarT]: ... +@overload +def trace(x: CoNumber_3nd, /, *, offset: CanIndex = 0, dtype: DTypeLike | None = None) -> Array[Any]: ... @overload -def cross( - a: _ArrayLikeUInt_co, - b: _ArrayLikeUInt_co, - axis: int = ..., -) -> NDArray[np.unsignedinteger]: ... -@overload -def cross( - a: _ArrayLikeInt_co, - b: _ArrayLikeInt_co, - axis: int = ..., -) -> NDArray[np.signedinteger]: ... -@overload -def cross( - a: _ArrayLikeFloat_co, - b: _ArrayLikeFloat_co, - axis: int = ..., -) -> NDArray[np.floating]: ... -@overload -def cross( - a: _ArrayLikeComplex_co, - b: _ArrayLikeComplex_co, - axis: int = ..., -) -> NDArray[np.complexfloating]: ... -@overload -def matmul( - x1: _ArrayLikeInt_co, - x2: _ArrayLikeInt_co, -) -> NDArray[np.signedinteger]: ... -@overload -def matmul( - x1: _ArrayLikeUInt_co, - x2: _ArrayLikeUInt_co, -) -> NDArray[np.unsignedinteger]: ... -@overload -def matmul( - x1: _ArrayLikeFloat_co, - x2: _ArrayLikeFloat_co, -) -> NDArray[np.floating]: ... -@overload -def matmul( - x1: _ArrayLikeComplex_co, - x2: _ArrayLikeComplex_co, -) -> NDArray[np.complexfloating]: ... +def trace(x: CoNumber_1nd, /, *, offset: CanIndex = 0, dtype: DTypeLike | None = None) -> Any: ... diff --git a/test/static/accept/linalg.pyi b/test/static/accept/linalg.pyi index a3464ef5..8e601042 100644 --- a/test/static/accept/linalg.pyi +++ b/test/static/accept/linalg.pyi @@ -1,10 +1,17 @@ -from typing import Any -from typing_extensions import assert_type +from typing import Any, Literal, TypeAlias +from typing_extensions import TypeVar, assert_type import numpy as np import numpy.typing as npt +from _numtype import Array, AtLeast2D from numpy.linalg._linalg import EigResult, EighResult, QRResult, SVDResult, SlogdetResult +_ScalarT = TypeVar("_ScalarT", bound=np.generic) +_Array_2d: TypeAlias = Array[_ScalarT, tuple[int, int]] +_Array_2nd: TypeAlias = Array[_ScalarT, AtLeast2D] + +### + AR_i8: npt.NDArray[np.int64] AR_f8: npt.NDArray[np.float64] AR_c16: npt.NDArray[np.complex128] @@ -13,77 +20,101 @@ AR_m: npt.NDArray[np.timedelta64] AR_S: npt.NDArray[np.str_] AR_b: npt.NDArray[np.bool] +### + assert_type(np.linalg.tensorsolve(AR_i8, AR_i8), npt.NDArray[np.float64]) -assert_type(np.linalg.tensorsolve(AR_i8, AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.linalg.tensorsolve(AR_c16, AR_f8), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.linalg.tensorsolve(AR_i8, AR_f8), npt.NDArray[np.float64]) +assert_type(np.linalg.tensorsolve(AR_c16, AR_f8), npt.NDArray[np.complex128]) assert_type(np.linalg.solve(AR_i8, AR_i8), npt.NDArray[np.float64]) -assert_type(np.linalg.solve(AR_i8, AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.linalg.solve(AR_c16, AR_f8), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.linalg.solve(AR_i8, AR_f8), npt.NDArray[np.float64]) +assert_type(np.linalg.solve(AR_c16, AR_f8), npt.NDArray[np.complex128]) -assert_type(np.linalg.tensorinv(AR_i8), npt.NDArray[np.float64]) -assert_type(np.linalg.tensorinv(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.linalg.tensorinv(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.linalg.tensorinv(AR_i8), _Array_2nd[np.float64]) +assert_type(np.linalg.tensorinv(AR_f8), _Array_2nd[np.float64]) +assert_type(np.linalg.tensorinv(AR_c16), _Array_2nd[np.complex128]) -assert_type(np.linalg.inv(AR_i8), npt.NDArray[np.float64]) -assert_type(np.linalg.inv(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.linalg.inv(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.linalg.inv(AR_i8), _Array_2nd[np.float64]) +assert_type(np.linalg.inv(AR_f8), _Array_2nd[np.float64]) +assert_type(np.linalg.inv(AR_c16), _Array_2nd[np.complex128]) -assert_type(np.linalg.matrix_power(AR_i8, -1), npt.NDArray[Any]) -assert_type(np.linalg.matrix_power(AR_f8, 0), npt.NDArray[Any]) -assert_type(np.linalg.matrix_power(AR_c16, 1), npt.NDArray[Any]) -assert_type(np.linalg.matrix_power(AR_O, 2), npt.NDArray[Any]) +assert_type(np.linalg.matrix_power(AR_i8, -1), _Array_2nd[np.float64]) +assert_type(np.linalg.matrix_power(AR_f8, 0), _Array_2nd[np.float64]) +assert_type(np.linalg.matrix_power(AR_c16, 1), _Array_2nd[np.complex128]) +assert_type(np.linalg.matrix_power(AR_O, 2), _Array_2nd[np.object_]) -assert_type(np.linalg.cholesky(AR_i8), npt.NDArray[np.float64]) -assert_type(np.linalg.cholesky(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.linalg.cholesky(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.linalg.cholesky(AR_i8), _Array_2nd[np.float64]) +assert_type(np.linalg.cholesky(AR_f8), _Array_2nd[np.float64]) +assert_type(np.linalg.cholesky(AR_c16), _Array_2nd[np.complex128]) -assert_type(np.linalg.outer(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.linalg.outer(AR_f8, AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.linalg.outer(AR_c16, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) -assert_type(np.linalg.outer(AR_b, AR_b), npt.NDArray[np.bool]) -assert_type(np.linalg.outer(AR_O, AR_O), npt.NDArray[np.object_]) -assert_type(np.linalg.outer(AR_i8, AR_m), npt.NDArray[np.timedelta64]) +assert_type(np.linalg.outer(AR_i8, AR_i8), _Array_2d[np.int64]) +assert_type(np.linalg.outer(AR_f8, AR_f8), _Array_2d[np.float64]) +assert_type(np.linalg.outer(AR_c16, AR_c16), _Array_2d[np.complex128]) +assert_type(np.linalg.outer(AR_b, AR_b), _Array_2d[np.bool]) +assert_type(np.linalg.outer(AR_O, AR_O), _Array_2d[np.object_]) +assert_type(np.linalg.outer(AR_i8, AR_m), _Array_2d[np.timedelta64]) -assert_type(np.linalg.qr(AR_i8), QRResult) -assert_type(np.linalg.qr(AR_f8), QRResult) -assert_type(np.linalg.qr(AR_c16), QRResult) +assert_type(np.linalg.qr(AR_i8), QRResult[np.float64]) +assert_type(np.linalg.qr(AR_f8), QRResult[np.float64]) +assert_type(np.linalg.qr(AR_c16), QRResult[np.complex128]) assert_type(np.linalg.eigvals(AR_i8), npt.NDArray[np.float64] | npt.NDArray[np.complex128]) -assert_type(np.linalg.eigvals(AR_f8), npt.NDArray[np.floating[Any]] | npt.NDArray[np.complexfloating[Any, Any]]) -assert_type(np.linalg.eigvals(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.linalg.eigvals(AR_f8), npt.NDArray[np.float64] | npt.NDArray[np.complex128]) +assert_type(np.linalg.eigvals(AR_c16), npt.NDArray[np.complex128]) assert_type(np.linalg.eigvalsh(AR_i8), npt.NDArray[np.float64]) -assert_type(np.linalg.eigvalsh(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.linalg.eigvalsh(AR_c16), npt.NDArray[np.floating[Any]]) +assert_type(np.linalg.eigvalsh(AR_f8), npt.NDArray[np.float64]) +assert_type(np.linalg.eigvalsh(AR_c16), npt.NDArray[np.float64]) -assert_type(np.linalg.eig(AR_i8), EigResult) -assert_type(np.linalg.eig(AR_f8), EigResult) -assert_type(np.linalg.eig(AR_c16), EigResult) +assert_type(np.linalg.eig(AR_i8), EigResult[np.float64] | EigResult[np.complex128]) +assert_type(np.linalg.eig(AR_f8), EigResult[np.float64] | EigResult[np.complex128]) +assert_type(np.linalg.eig(AR_c16), EigResult[np.complex128]) -assert_type(np.linalg.eigh(AR_i8), EighResult) -assert_type(np.linalg.eigh(AR_f8), EighResult) -assert_type(np.linalg.eigh(AR_c16), EighResult) +assert_type(np.linalg.eigh(AR_i8), EighResult[np.float64, np.float64]) +assert_type(np.linalg.eigh(AR_f8), EighResult[np.float64, np.float64]) +assert_type(np.linalg.eigh(AR_c16), EighResult[np.float64, np.complex128]) -assert_type(np.linalg.svd(AR_i8), SVDResult) -assert_type(np.linalg.svd(AR_f8), SVDResult) -assert_type(np.linalg.svd(AR_c16), SVDResult) +assert_type(np.linalg.svd(AR_i8), SVDResult[np.float64, np.float64]) +assert_type(np.linalg.svd(AR_f8), SVDResult[np.float64, np.float64]) +assert_type(np.linalg.svd(AR_c16), SVDResult[np.float64, np.complex128]) assert_type(np.linalg.svd(AR_i8, compute_uv=False), npt.NDArray[np.float64]) -assert_type(np.linalg.svd(AR_f8, compute_uv=False), npt.NDArray[np.floating[Any]]) -assert_type(np.linalg.svd(AR_c16, compute_uv=False), npt.NDArray[np.floating[Any]]) +assert_type(np.linalg.svd(AR_f8, compute_uv=False), npt.NDArray[np.float64]) +assert_type(np.linalg.svd(AR_c16, compute_uv=False), npt.NDArray[np.float64]) +assert_type(np.linalg.cond([[1, 0], [0, 1]]), np.float64) +assert_type(np.linalg.cond([[[1, 0], [0, 1]]]), npt.NDArray[np.float64]) assert_type(np.linalg.cond(AR_i8), Any) assert_type(np.linalg.cond(AR_f8), Any) assert_type(np.linalg.cond(AR_c16), Any) +assert_type(np.linalg.matrix_rank(1), Literal[0, 1]) +assert_type(np.linalg.matrix_rank([1]), Literal[0, 1]) +assert_type(np.linalg.matrix_rank([[1]]), np.int_) +assert_type(np.linalg.matrix_rank([[[1]]]), npt.NDArray[np.int_]) +assert_type(np.linalg.matrix_rank([[[[1]]]]), npt.NDArray[np.int_]) assert_type(np.linalg.matrix_rank(AR_i8), Any) assert_type(np.linalg.matrix_rank(AR_f8), Any) assert_type(np.linalg.matrix_rank(AR_c16), Any) -assert_type(np.linalg.pinv(AR_i8), npt.NDArray[np.float64]) -assert_type(np.linalg.pinv(AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.linalg.pinv(AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.linalg.pinv(AR_i8), _Array_2nd[np.float64]) +assert_type(np.linalg.pinv(AR_f8), _Array_2nd[np.float64]) +assert_type(np.linalg.pinv(AR_c16), _Array_2nd[np.complex128]) +assert_type(np.linalg.slogdet([[1]]), SlogdetResult[np.float64, np.float64]) +assert_type(np.linalg.slogdet([[1.0]]), SlogdetResult[np.float64, np.float64]) +assert_type(np.linalg.slogdet([[1j]]), SlogdetResult[np.float64, np.complex128]) +assert_type( + np.linalg.slogdet([[[1]]]), + SlogdetResult[npt.NDArray[np.float64], npt.NDArray[np.float64]], +) +assert_type( + np.linalg.slogdet([[[1.0]]]), + SlogdetResult[npt.NDArray[np.float64], npt.NDArray[np.float64]], +) +assert_type( + np.linalg.slogdet([[[1j]]]), + SlogdetResult[npt.NDArray[np.float64], npt.NDArray[np.complex128]], +) assert_type(np.linalg.slogdet(AR_i8), SlogdetResult) assert_type(np.linalg.slogdet(AR_f8), SlogdetResult) assert_type(np.linalg.slogdet(AR_c16), SlogdetResult) @@ -93,43 +124,66 @@ assert_type(np.linalg.det(AR_f8), Any) assert_type(np.linalg.det(AR_c16), Any) assert_type( - np.linalg.lstsq(AR_i8, AR_i8), tuple[npt.NDArray[np.float64], npt.NDArray[np.float64], np.int32, npt.NDArray[np.float64]] + np.linalg.lstsq(AR_i8, AR_i8), + tuple[npt.NDArray[np.float64], npt.NDArray[np.float64], np.int32, npt.NDArray[np.float64]], ) assert_type( np.linalg.lstsq(AR_i8, AR_f8), - tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]], np.int32, npt.NDArray[np.floating[Any]]], + tuple[npt.NDArray[np.float64], npt.NDArray[np.float64], np.int32, npt.NDArray[np.float64]], ) assert_type( np.linalg.lstsq(AR_f8, AR_c16), - tuple[npt.NDArray[np.complexfloating[Any, Any]], npt.NDArray[np.floating[Any]], np.int32, npt.NDArray[np.floating[Any]]], + tuple[npt.NDArray[np.complex128], npt.NDArray[np.float64], np.int32, npt.NDArray[np.float64]], ) -assert_type(np.linalg.norm(AR_i8), np.floating[Any]) -assert_type(np.linalg.norm(AR_f8), np.floating[Any]) -assert_type(np.linalg.norm(AR_c16), np.floating[Any]) -assert_type(np.linalg.norm(AR_S), np.floating[Any]) -assert_type(np.linalg.norm(AR_f8, axis=0), Any) - -assert_type(np.linalg.matrix_norm(AR_i8), np.floating[Any]) -assert_type(np.linalg.matrix_norm(AR_f8), np.floating[Any]) -assert_type(np.linalg.matrix_norm(AR_c16), np.floating[Any]) -assert_type(np.linalg.matrix_norm(AR_S), np.floating[Any]) - -assert_type(np.linalg.vector_norm(AR_i8), np.floating[Any]) -assert_type(np.linalg.vector_norm(AR_f8), np.floating[Any]) -assert_type(np.linalg.vector_norm(AR_c16), np.floating[Any]) -assert_type(np.linalg.vector_norm(AR_S), np.floating[Any]) - +assert_type(np.linalg.norm(AR_i8), np.float64) +assert_type(np.linalg.norm(AR_f8), np.float64) +assert_type(np.linalg.norm(AR_c16), np.float64) +assert_type(np.linalg.norm(AR_S), np.float64) +assert_type(np.linalg.norm(AR_f8, axis=0), npt.NDArray[np.float64]) +assert_type(np.linalg.norm(AR_f8, keepdims=True), _Array_2nd[np.float64]) + +assert_type(np.linalg.matrix_norm([[True]]), np.float64) +assert_type(np.linalg.matrix_norm([[1]]), np.float64) +assert_type(np.linalg.matrix_norm([[1j]]), np.float64) +assert_type(np.linalg.matrix_norm([["1"]]), np.float64) +assert_type(np.linalg.matrix_norm([[b"1"]]), np.float64) +assert_type(np.linalg.matrix_norm([[[True]]]), npt.NDArray[np.float64]) +assert_type(np.linalg.matrix_norm([[[1]]]), npt.NDArray[np.float64]) +assert_type(np.linalg.matrix_norm([[[1j]]]), npt.NDArray[np.float64]) +assert_type(np.linalg.matrix_norm([[["1"]]]), npt.NDArray[np.float64]) +assert_type(np.linalg.matrix_norm([[[b"1"]]]), npt.NDArray[np.float64]) +assert_type(np.linalg.matrix_norm(AR_i8), Any) +assert_type(np.linalg.matrix_norm(AR_f8), Any) +assert_type(np.linalg.matrix_norm(AR_c16), Any) +assert_type(np.linalg.matrix_norm(AR_S), Any) + +assert_type(np.linalg.vector_norm(AR_i8), np.float64) +assert_type(np.linalg.vector_norm(AR_f8), np.float64) +assert_type(np.linalg.vector_norm(AR_c16), np.float64) +assert_type(np.linalg.vector_norm(AR_S), np.float64) + +assert_type(np.linalg.multi_dot([[True], [True]]), np.bool) +assert_type(np.linalg.multi_dot([[1], [1]]), np.int_) +assert_type(np.linalg.multi_dot([[1.0], [1.0]]), np.float64) +assert_type(np.linalg.multi_dot([[1j], [1j]]), np.complex128) assert_type(np.linalg.multi_dot([AR_i8, AR_i8]), Any) assert_type(np.linalg.multi_dot([AR_i8, AR_f8]), Any) assert_type(np.linalg.multi_dot([AR_f8, AR_c16]), Any) assert_type(np.linalg.multi_dot([AR_O, AR_O]), Any) assert_type(np.linalg.multi_dot([AR_m, AR_m]), Any) -assert_type(np.linalg.cross(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.linalg.cross(AR_f8, AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.linalg.cross(AR_c16, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) - -assert_type(np.linalg.matmul(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]]) -assert_type(np.linalg.matmul(AR_f8, AR_f8), npt.NDArray[np.floating[Any]]) -assert_type(np.linalg.matmul(AR_c16, AR_c16), npt.NDArray[np.complexfloating[Any, Any]]) +assert_type(np.linalg.cross(AR_i8, AR_i8), npt.NDArray[np.int64]) +assert_type(np.linalg.cross(AR_f8, AR_f8), npt.NDArray[np.float64]) +assert_type(np.linalg.cross(AR_c16, AR_c16), npt.NDArray[np.complex128]) + +assert_type(np.linalg.matmul([True], [True]), np.bool) +assert_type(np.linalg.matmul([2], [2]), np.int_) +assert_type(np.linalg.matmul([2], [True]), np.int_) +assert_type(np.linalg.matmul([1.0], [1.0]), np.float64) +assert_type(np.linalg.matmul([1.0], [2]), np.float64) +assert_type(np.linalg.matmul([1j], [1j]), np.complex128) +assert_type(np.linalg.matmul([True], [1j]), np.complex128) +assert_type(np.linalg.matmul(AR_i8, AR_i8), Any) +assert_type(np.linalg.matmul(AR_f8, AR_f8), Any) +assert_type(np.linalg.matmul(AR_c16, AR_c16), Any) diff --git a/test/static/reject/linalg.pyi b/test/static/reject/linalg.pyi index f394946e..fd5bdf5f 100644 --- a/test/static/reject/linalg.pyi +++ b/test/static/reject/linalg.pyi @@ -14,8 +14,8 @@ np.linalg.tensorinv(AR_O) # type: ignore[arg-type] # pyright: ignore[reportCal np.linalg.solve(AR_O, AR_O) # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] np.linalg.tensorsolve(AR_O, AR_O) # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] -np.linalg.matrix_rank(AR_O) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] -np.linalg.matrix_power(AR_M, 5) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] +np.linalg.matrix_rank(AR_O) # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] +np.linalg.matrix_power(AR_M, 5) # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] np.linalg.cholesky(AR_O) # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] @@ -31,12 +31,12 @@ np.linalg.eigvals(AR_O) # type: ignore[arg-type] # pyright: ignore[reportCallI np.linalg.eigvalsh(AR_O) # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] np.linalg.eigvalsh(AR_O, UPLO="bob") # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType] -np.linalg.cond(AR_O) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] -np.linalg.cond(AR_f8, p="bob") # type: ignore[arg-type] # pyright: ignore[reportArgumentType] +np.linalg.cond(AR_O) # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] +np.linalg.cond(AR_f8, p="bob") # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType] -np.linalg.det(AR_O) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] -np.linalg.slogdet(AR_O) # type: ignore[arg-type] # pyright: ignore[reportArgumentType] +np.linalg.det(AR_O) # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] +np.linalg.slogdet(AR_O) # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType] np.linalg.norm(AR_f8, ord="bob") # type: ignore[call-overload] # pyright: ignore[reportCallIssue,reportArgumentType] -np.linalg.multi_dot([AR_M]) # type: ignore[list-item] # pyright: ignore[reportArgumentType] +np.linalg.multi_dot([AR_M]) # type: ignore[arg-type] # pyright: ignore[reportCallIssue,reportArgumentType]