diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 2cf16e25..0cf8845d 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -43,10 +43,12 @@ _SCT = TypeVar("_SCT", bound=_Numeric, default=Any) _SCT0 = TypeVar("_SCT0", bound=_Numeric) _ShapeT = TypeVar("_ShapeT", bound=tuple[int, *tuple[int, ...]], default=tuple[Any, ...]) -_Numeric: TypeAlias = npc.number | np.bool_ +_Numeric: TypeAlias = np.bool_ | npc.number -_ToArray1D: TypeAlias = Seq[_SCT] | onp.CanArrayND[_SCT] -_ToArray2D: TypeAlias = Seq[Seq[_SCT | int] | onp.CanArrayND[_SCT]] | onp.CanArrayND[_SCT] +_ToArray1D: TypeAlias = Seq[_SCT] | onp.CanArray1D[_SCT] +_ToArray2D: TypeAlias = Seq[Seq[_SCT] | onp.CanArray1D[_SCT]] | onp.CanArray2D[_SCT] +_ToArray1D2D: TypeAlias = _ToArray1D[_SCT] | _ToArray2D[_SCT] +_CanArray1D2D: TypeAlias = onp.CanArrayND[_SCT, tuple[int] | tuple[int, int]] _ToSpMatrix: TypeAlias = spmatrix[_SCT] | _ToArray2D[_SCT] _ToSparse2D: TypeAlias = _spbase[_SCT, tuple[int, int]] | _ToArray2D[_SCT] @@ -55,7 +57,6 @@ _SpMatrix: TypeAlias = spmatrix[_SCT] | Any _SpArray: TypeAlias = sparray[_SCT, _ShapeT] | Any _SpBase2D: TypeAlias = _SpBase[_SCT, tuple[int, int]] -_SpArray1D: TypeAlias = _SpArray[_SCT, tuple[int]] _SpArray2D: TypeAlias = _SpArray[_SCT, tuple[int, int]] _BSRArray: TypeAlias = bsr_array[_SCT] @@ -74,7 +75,11 @@ _FmtDIA: TypeAlias = Literal["dia"] _FmtDOK: TypeAlias = Literal["dok"] _FmtLIL: TypeAlias = Literal["lil"] _FmtNonCOO: TypeAlias = Literal["bsr", "csc", "csr", "dia", "dok", "lil"] -_FmtNonDIA: TypeAlias = Literal["bsr", "coo", "csc", "csr", "dok", "lil"] + +# TODO(julvandenbroeck): find a way to separate float and complex +_ComplexSeq1D2D: TypeAlias = Seq[Seq[complex] | complex] +_ToComplex1D2D: TypeAlias = onp.ToComplex1D | onp.ToComplex2D +_Offsets: TypeAlias = onp.ToInt | onp.ToInt1D _DataRVS: TypeAlias = Callable[[int], onp.ArrayND[_Numeric]] @@ -85,436 +90,1197 @@ class _DataSampler(Protocol): def __call__(self, /, *, size: int) -> onp.ArrayND[_Numeric]: ... ### +@overload # diagonals: , format: "dia" | None, dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDIA | None = None, + dtype: None = None, +) -> _DIAArray[np.float64] | _DIAArray[np.complex128]: ... +@overload # diagonals: , format: "bsr", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: None = None +) -> _BSRArray[np.float64] | _BSRArray[np.complex128]: ... +@overload # diagonals: , format: "coo", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: None = None +) -> _COOArray2D[np.float64] | _COOArray2D[np.complex128]: ... +@overload # diagonals: , format: "csc", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: None = None +) -> _CSCArray[np.float64] | _CSCArray[np.complex128]: ... +@overload # diagonals: , format: "csr", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: None = None +) -> _CSRArray2D[np.float64] | _CSRArray2D[np.complex128]: ... +@overload # diagonals: , format: "dok", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: None = None +) -> _DOKArray2D[np.float64] | _DOKArray2D[np.complex128]: ... +@overload # diagonals: , format: "lil", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: None = None +) -> _LILArray[np.float64] | _LILArray[np.complex128]: ... -@overload # diagonals: , dtype: None = ..., format: {"dia", None} = ... +# +@overload # diagonals: , format: "dia" | None, dtype: None def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: None = None, -) -> dia_array[_SCT]: ... -@overload # diagonals: , dtype: None = ..., format: +) -> _DIAArray[_SCT]: ... +@overload # diagonals: , format: "bsr", dtype: None +def diags_array( + diagonals: _CanArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: None = None, +) -> _BSRArray[_SCT]: ... +@overload # diagonals: , format: "coo", dtype: None +def diags_array( + diagonals: _CanArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: None = None, +) -> _COOArray2D[_SCT]: ... +@overload # diagonals: , format: "csc", dtype: None def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtNonDIA, + format: _FmtCSC, dtype: None = None, -) -> _SpArray2D[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: int +) -> _CSCArray[_SCT]: ... +@overload # diagonals: , format: "csr", dtype: None def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, + diagonals: _CanArray1D2D[_SCT], /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: None = None, +) -> _CSRArray2D[_SCT]: ... +@overload # diagonals: , format: "dok", dtype: None +def diags_array( + diagonals: _CanArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: None = None, +) -> _DOKArray2D[_SCT]: ... +@overload # diagonals: , format: "lil", dtype: None +def diags_array( + diagonals: _CanArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: None = None, +) -> _LILArray[_SCT]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: bool-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, + dtype: onp.AnyBoolDType, +) -> _DIAArray[np.bool_]: ... +@overload # diagonals: , format: "bsr", dtype: bool-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyBoolDType, +) -> _BSRArray[np.bool_]: ... +@overload # diagonals: , format: "coo", dtype: bool-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyBoolDType, +) -> _COOArray2D[np.bool_]: ... +@overload # diagonals: , format: "csc", dtype: bool-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyBoolDType, +) -> _CSCArray[np.bool_]: ... +@overload # diagonals: , format: "csr", dtype: bool-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyBoolDType, +) -> _CSRArray2D[np.bool_]: ... +@overload # diagonals: , format: "dok", dtype: bool-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyBoolDType, +) -> _DOKArray2D[np.bool_]: ... +@overload # diagonals: , format: "lil", dtype: bool-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyBoolDType, +) -> _LILArray[np.bool_]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: int-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDIA | None = None, + dtype: onp.AnyIntDType, +) -> _DIAArray[np.int_]: ... +@overload # diagonals: , format: "bsr", dtype: int-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyIntDType, +) -> _BSRArray[np.int_]: ... +@overload # diagonals: , format: "coo", dtype: int-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyIntDType, +) -> _COOArray2D[np.int_]: ... +@overload # diagonals: , format: "csc", dtype: int-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyIntDType, +) -> _CSCArray[np.int_]: ... +@overload # diagonals: , format: "csr", dtype: int-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyIntDType, +) -> _CSRArray2D[np.int_]: ... +@overload # diagonals: , format: "dok", dtype: int-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, dtype: onp.AnyIntDType, -) -> dia_array[np.int_]: ... -@overload # diagonals: , format: , dtype: int +) -> _DOKArray2D[np.int_]: ... +@overload # diagonals: , format: "lil", dtype: int-like def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, + diagonals: _ToComplex1D2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtNonDIA, + format: _FmtLIL, dtype: onp.AnyIntDType, -) -> _SpArray2D[np.int_]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: float +) -> _LILArray[np.int_]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: float64-like def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, + diagonals: _ToComplex1D2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: onp.AnyFloat64DType, -) -> dia_array[np.float64]: ... -@overload # diagonals: , format: , dtype: float +) -> _DIAArray[np.float64]: ... +@overload # diagonals: , format: "bsr", dtype: float64-like def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, + diagonals: _ToComplex1D2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtNonDIA, + format: _FmtBSR, dtype: onp.AnyFloat64DType, -) -> _SpArray2D[np.float64]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: complex +) -> _BSRArray[np.float64]: ... +@overload # diagonals: , format: "coo", dtype: float64-like def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyFloat64DType, +) -> _COOArray2D[np.float64]: ... +@overload # diagonals: , format: "csc", dtype: float64-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyFloat64DType, +) -> _CSCArray[np.float64]: ... +@overload # diagonals: , format: "csr", dtype: float64-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyFloat64DType, +) -> _CSRArray2D[np.float64]: ... +@overload # diagonals: , format: "dok", dtype: float64-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyFloat64DType, +) -> _DOKArray2D[np.float64]: ... +@overload # diagonals: , format: "lil", dtype: float64-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyFloat64DType, +) -> _LILArray[np.float64]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: complex128-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: onp.AnyComplex128DType, -) -> dia_array[np.complex128]: ... -@overload # diagonals: , format: , dtype: complex +) -> _DIAArray[np.complex128]: ... +@overload # diagonals: , format: "bsr", dtype: complex128-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyComplex128DType, +) -> _BSRArray[np.complex128]: ... +@overload # diagonals: , format: "coo", dtype: complex128-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyComplex128DType, +) -> _COOArray2D[np.complex128]: ... +@overload # diagonals: , format: "csc", dtype: complex128-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyComplex128DType, +) -> _CSCArray[np.complex128]: ... +@overload # diagonals: , format: "csr", dtype: complex128-like def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtNonDIA, + format: _FmtCSR, dtype: onp.AnyComplex128DType, -) -> _SpArray2D[np.complex128]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: +) -> _CSRArray2D[np.complex128]: ... +@overload # diagonals: , format: "dok", dtype: complex128-like def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyComplex128DType, +) -> _DOKArray2D[np.complex128]: ... +@overload # diagonals: , format: "lil", dtype: complex128-like +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyComplex128DType, +) -> _LILArray[np.complex128]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: onp.ToDType[_SCT], -) -> dia_array[_SCT]: ... -@overload # diagonals: , format: , dtype: +) -> _DIAArray[_SCT]: ... +@overload # diagonals: , format: "bsr", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtNonDIA, + format: _FmtBSR, dtype: onp.ToDType[_SCT], -) -> _SpArray2D[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: +) -> _BSRArray[_SCT]: ... +@overload # diagonals: , format: "coo", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: npt.DTypeLike | None = None, -) -> dia_array: ... -@overload # diagonals: , format: , dtype: + format: _FmtCOO, + dtype: onp.ToDType[_SCT], +) -> _COOArray2D[_SCT]: ... +@overload # diagonals: , format: "csc", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtNonDIA, - dtype: npt.DTypeLike | None = None, -) -> _SpArray2D: ... + format: _FmtCSC, + dtype: onp.ToDType[_SCT], +) -> _CSCArray[_SCT]: ... +@overload # diagonals: , format: "csr", dtype: +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.ToDType[_SCT], +) -> _CSRArray2D[_SCT]: ... +@overload # diagonals: , format: "dok", dtype: +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.ToDType[_SCT], +) -> _DOKArray2D[_SCT]: ... +@overload # diagonals: , format: "lil", dtype: +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.ToDType[_SCT], +) -> _LILArray[_SCT]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: +def diags_array( + diagonals: _ToComplex1D2D, + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDIA | None = None, + dtype: npt.DTypeLike, +) -> _DIAArray: ... +@overload # diagonals: , format: "bsr", dtype: +def diags_array( + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: npt.DTypeLike +) -> _BSRArray: ... +@overload # diagonals: , format: "coo", dtype: +def diags_array( + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: npt.DTypeLike +) -> _COOArray2D: ... +@overload # diagonals: , format: "csc", dtype: +def diags_array( + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: npt.DTypeLike +) -> _CSCArray: ... +@overload # diagonals: , format: "csr", dtype: +def diags_array( + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: npt.DTypeLike +) -> _CSRArray2D: ... +@overload # diagonals: , format: "dok", dtype: +def diags_array( + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: npt.DTypeLike +) -> _DOKArray2D: ... +@overload # diagonals: , format: "lil", dtype: +def diags_array( + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: npt.DTypeLike +) -> _LILArray: ... +### # NOTE: `diags_array` should be prefered over `diags` -@overload # diagonals: , format: {"dia", None} = ... +@overload # diagonals: , format: "dia" | None, dtype: None def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D = 0, + diagonals: _ToArray1D2D[_SCT], + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, - dtype: onp.ToDType[_SCT] | None = None, + dtype: None = None, ) -> dia_matrix[_SCT]: ... -@overload # diagonals: , format: (positional) +@overload # diagonals: , format: "bsr", dtype: None def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D, - shape: _ToShape2D | None, - format: _FmtNonDIA, - dtype: onp.ToDType[_SCT] | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # diagonals: , format: (keyword) + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtBSR, dtype: None = None +) -> bsr_matrix[_SCT]: ... +@overload # diagonals: , format: "coo", dtype: None +def diags( + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCOO, dtype: None = None +) -> coo_matrix[_SCT]: ... +@overload # diagonals: , format: "csc", dtype: None +def diags( + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSC, dtype: None = None +) -> csc_matrix[_SCT]: ... +@overload # diagonals: , format: "csr", dtype: None +def diags( + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSR, dtype: None = None +) -> csr_matrix[_SCT]: ... +@overload # diagonals: , format: "dok", dtype: None +def diags( + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtDOK, dtype: None = None +) -> dok_matrix[_SCT]: ... +@overload # diagonals: , format: "lil", dtype: None def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D = 0, + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtLIL, dtype: None = None +) -> lil_matrix[_SCT]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: +def diags( + diagonals: _ToArray1D2D, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, + format: _FmtDIA | None = None, *, - format: _FmtNonDIA, - dtype: onp.ToDType[_SCT] | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: (positional) -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, - shape: _ToShape2D | None, - format: _FmtDIA | None, dtype: onp.ToDType[_SCT], ) -> dia_matrix[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: (keyword) +@overload # diagonals: , format: "bsr", dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtBSR, dtype: onp.ToDType[_SCT] +) -> bsr_matrix[_SCT]: ... +@overload # diagonals: , format: "coo", dtype: +def diags( + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCOO, dtype: onp.ToDType[_SCT] +) -> coo_matrix[_SCT]: ... +@overload # diagonals: , format: "csr", dtype: +def diags( + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSR, dtype: onp.ToDType[_SCT] +) -> csr_matrix[_SCT]: ... +@overload # diagonals: , format: "csc", dtype: +def diags( + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSC, dtype: onp.ToDType[_SCT] +) -> csc_matrix[_SCT]: ... +@overload # diagonals: , format: "dok", dtype: +def diags( + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtDOK, dtype: onp.ToDType[_SCT] +) -> dok_matrix[_SCT]: ... +@overload # diagonals: , format: "lil", dtype: +def diags( + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtLIL, dtype: onp.ToDType[_SCT] +) -> lil_matrix[_SCT]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: +def diags( + diagonals: _ToComplex1D2D, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, + dtype: npt.DTypeLike | None = None, +) -> dia_matrix: ... +@overload # diagonals: , format: "bsr", dtype: +def diags( + diagonals: _ToComplex1D2D, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, *, - dtype: onp.ToDType[_SCT], -) -> dia_matrix[_SCT]: ... -@overload # diagonals: , format: (positional), dtype: + format: _FmtBSR, + dtype: npt.DTypeLike | None = None, +) -> bsr_matrix: ... +@overload # diagonals: , format: "coo", dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, - shape: _ToShape2D | None, - format: _FmtNonDIA, - dtype: onp.ToDType[_SCT], -) -> _SpMatrix[_SCT]: ... -@overload # diagonals: , format: (keyword), dtype: + diagonals: _ToComplex1D2D, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtCOO, + dtype: npt.DTypeLike | None = None, +) -> coo_matrix: ... +@overload # diagonals: , format: "csr", dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, + diagonals: _ToComplex1D2D, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, - format: _FmtNonDIA, - dtype: onp.ToDType[_SCT], -) -> _SpMatrix[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: + format: _FmtCSR, + dtype: npt.DTypeLike | None = None, +) -> csr_matrix: ... +@overload # diagonals: , format: "csc", dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, + diagonals: _ToComplex1D2D, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, + *, + format: _FmtCSC, dtype: npt.DTypeLike | None = None, -) -> dia_matrix: ... -@overload # diagonals: , format: (positional), dtype: +) -> csc_matrix: ... +@overload # diagonals: , format: "dok", dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, - shape: _ToShape2D | None, - format: _FmtNonDIA, + diagonals: _ToComplex1D2D, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtDOK, dtype: npt.DTypeLike | None = None, -) -> _SpMatrix: ... -@overload # diagonals: , format: (keyword), dtype: +) -> dok_matrix: ... +@overload # diagonals: , format: "lil", dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, + diagonals: _ToComplex1D2D, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, - format: _FmtNonDIA, + format: _FmtLIL, dtype: npt.DTypeLike | None = None, -) -> _SpMatrix: ... +) -> lil_matrix: ... +### # NOTE: `diags_array` should be prefered over `spdiags` @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, - m: onp.ToJustInt, - n: onp.ToJustInt, - format: _FmtDIA | None = None, + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDIA | None = None ) -> dia_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR +) -> bsr_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO +) -> coo_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC +) -> csc_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR +) -> csr_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK +) -> dok_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL +) -> lil_matrix[_SCT]: ... + +# +@overload +def spdiags( + data: _ToArray1D2D[_SCT], + diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, format: _FmtDIA | None = None, ) -> dia_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, - m: onp.ToJustInt, - n: onp.ToJustInt, - format: _FmtNonDIA, -) -> _SpMatrix[_SCT]: ... + data: _ToArray1D2D[_SCT], + diags: _Offsets, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtBSR, +) -> bsr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, + data: _ToArray1D2D[_SCT], + diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, - format: _FmtNonDIA, -) -> _SpMatrix[_SCT]: ... + format: _FmtCOO, +) -> coo_matrix[_SCT]: ... @overload def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, - diags: onp.ToInt | onp.ToInt1D, - m: onp.ToJustInt, - n: onp.ToJustInt, - format: _Format | None = None, -) -> _SpMatrix: ... + data: _ToArray1D2D[_SCT], + diags: _Offsets, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtCSC, +) -> csc_matrix[_SCT]: ... @overload def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, - diags: onp.ToInt | onp.ToInt1D, + data: _ToArray1D2D[_SCT], + diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, - format: _Format | None = None, -) -> _SpMatrix: ... + format: _FmtCSR, +) -> csr_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], + diags: _Offsets, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtDOK, +) -> dok_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], + diags: _Offsets, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtLIL, +) -> lil_matrix[_SCT]: ... + +### +@overload # dtype: float64-like (default), format: "dia" | None +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", format: _FmtDIA | None = None) -> dia_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "bsr" +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtBSR) -> bsr_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "coo" +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtCOO) -> coo_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "csc" +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtCSC) -> csc_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "csr" +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtCSR) -> csr_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "dok" +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtDOK) -> dok_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "lil" +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtLIL) -> lil_matrix[np.float64]: ... # -@overload # dtype like bool, format: None = ... +@overload # dtype: bool-like, format: "dia" | None def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None) -> dia_matrix[np.bool_]: ... -@overload # dtype like int, format: None = ... +@overload # dtype: bool-like, format: "bsr" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtBSR) -> bsr_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "coo" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtCOO) -> coo_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "csc" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtCSC) -> csc_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "csr" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtCSR) -> csr_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "dok" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtDOK) -> dok_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "lil" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtLIL) -> lil_matrix[np.bool_]: ... + +# +@overload # dtype: int-like, format: "dia" | None def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtDIA | None = None) -> dia_matrix[np.int_]: ... -@overload # dtype like float (default), format: None = ... -def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", format: _FmtDIA | None = None) -> dia_matrix[np.float64]: ... -@overload # dtype like complex, format: None = ... +@overload # dtype: int-like, format: "bsr" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtBSR) -> bsr_matrix[np.int_]: ... +@overload # dtype: int-like, format: "coo" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtCOO) -> coo_matrix[np.int_]: ... +@overload # dtype: int-like, format: "csc" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtCSC) -> csc_matrix[np.int_]: ... +@overload # dtype: int-like, format: "csr" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtCSR) -> csr_matrix[np.int_]: ... +@overload # dtype: int-like, format: "dok" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtDOK) -> dok_matrix[np.int_]: ... +@overload # dtype: int-like, format: "lil" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtLIL) -> lil_matrix[np.int_]: ... + +# +@overload # dtype: complex128-like, format: "dia" | None def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None) -> dia_matrix[np.complex128]: ... -@overload # dtype like , format: None = ... +@overload # dtype: complex128-like, format: "bsr" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtBSR) -> bsr_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "coo" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtCOO) -> coo_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "csc" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtCSC) -> csc_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "csr" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtCSR) -> csr_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "dok" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtDOK) -> dok_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "lil" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtLIL) -> lil_matrix[np.complex128]: ... + +# +@overload # dtype: , format: "dia" | None def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None) -> dia_matrix[_SCT]: ... -@overload # dtype like , format: None = ... +@overload # dtype: , format: "bsr" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtBSR) -> bsr_matrix[_SCT]: ... +@overload # dtype: , format: "coo" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtCOO) -> coo_matrix[_SCT]: ... +@overload # dtype: , format: "csc" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtCSC) -> csc_matrix[_SCT]: ... +@overload # dtype: , format: "csr" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtCSR) -> csr_matrix[_SCT]: ... +@overload # dtype: , format: "dok" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtDOK) -> dok_matrix[_SCT]: ... +@overload # dtype: , format: "lil" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtLIL) -> lil_matrix[_SCT]: ... + +# +@overload # dtype: , format: "dia" | None def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtDIA | None = None) -> dia_matrix[Incomplete]: ... -@overload # dtype like float, format: (positional) -def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtNonDIA) -> _SpMatrix[np.float64]: ... -@overload # dtype like float (default), format: (keyword) -def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtNonDIA) -> _SpMatrix[np.float64]: ... -@overload # dtype like bool, format: -def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtNonDIA) -> _SpMatrix[np.bool_]: ... -@overload # dtype like int, format: -def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtNonDIA) -> _SpMatrix[np.int_]: ... -@overload # dtype like complex, format: -def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtNonDIA) -> _SpMatrix[np.complex128]: ... -@overload # dtype like , format: -def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtNonDIA) -> _SpMatrix[_SCT]: ... -@overload # dtype like , fformat: -def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtNonDIA) -> _SpMatrix[Incomplete]: ... +@overload # dtype: , format: "bsr" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtBSR) -> bsr_matrix[Incomplete]: ... +@overload # dtype: , format: "coo" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtCOO) -> coo_matrix[Incomplete]: ... +@overload # dtype: , format: "csc" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtCSC) -> csc_matrix[Incomplete]: ... +@overload # dtype: , format: "csr" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtCSR) -> csr_matrix[Incomplete]: ... +@overload # dtype: , format: "dok" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtDOK) -> dok_matrix[Incomplete]: ... +@overload # dtype: , format: "lil" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtLIL) -> lil_matrix[Incomplete]: ... + +### +@overload # dtype: float64-like (default), format: "dia" | None +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtDIA | None = None +) -> _DIAArray[np.float64]: ... +@overload # dtype: float64-like (default), format: "bsr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtBSR +) -> _BSRArray[np.float64]: ... +@overload # dtype: float64-like (default), format: "coo" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtCOO +) -> _COOArray2D[np.float64]: ... +@overload # dtype: float64-like (default), format: "csc" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtCSC +) -> _CSCArray[np.float64]: ... +@overload # dtype: float64-like (default), format: "csr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtCSR +) -> _CSRArray2D[np.float64]: ... +@overload # dtype: float64-like (default), format: "dok" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtDOK +) -> _DOKArray2D[np.float64]: ... +@overload # dtype: float64-like (default), format: "lil" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtLIL +) -> _LILArray[np.float64]: ... # -@overload # dtype like bool, format: None = ... +@overload # dtype: bool-like, format: "dia" | None def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None -) -> dia_array[np.bool_]: ... -@overload # dtype like int, format: None = ... +) -> _DIAArray[np.bool_]: ... +@overload # dtype: bool-like, format: "bsr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtBSR +) -> _BSRArray[np.bool_]: ... +@overload # dtype: bool-like, format: "coo" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtCOO +) -> _COOArray2D[np.bool_]: ... +@overload # dtype: bool-like, format: "csc" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtCSC +) -> _CSCArray[np.bool_]: ... +@overload # dtype: bool-like, format: "csr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtCSR +) -> _CSRArray2D[np.bool_]: ... +@overload # dtype: bool-like, format: "dok" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtDOK +) -> _DOKArray2D[np.bool_]: ... +@overload # dtype: bool-like, format: "lil" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtLIL +) -> _LILArray[np.bool_]: ... + +# +@overload # dtype: int-like, format: "dia" | None def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtDIA | None = None -) -> dia_array[np.int_]: ... -@overload # dtype like float (default), format: None = ... +) -> _DIAArray[np.int_]: ... +@overload # dtype: int-like, format: "bsr" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtDIA | None = None -) -> dia_array[np.float64]: ... -@overload # dtype like complex, format: None = ... + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtBSR +) -> _BSRArray[np.int_]: ... +@overload # dtype: int-like, format: "coo" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtCOO +) -> _COOArray2D[np.int_]: ... +@overload # dtype: int-like, format: "csc" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtCSC +) -> _CSCArray[np.int_]: ... +@overload # dtype: int-like, format: "csr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtCSR +) -> _CSRArray2D[np.int_]: ... +@overload # dtype: int-like, format: "dok" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtDOK +) -> _DOKArray2D[np.int_]: ... +@overload # dtype: int-like, format: "lil" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtLIL +) -> _LILArray[np.int_]: ... + +# +@overload # dtype: complex128-like, format: "dia" | None def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None -) -> dia_array[np.complex128]: ... -@overload # dtype like , format: None = ... +) -> _DIAArray[np.complex128]: ... +@overload # dtype: complex128-like, format: "bsr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtBSR +) -> _BSRArray[np.complex128]: ... +@overload # dtype: complex128-like, format: "coo" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtCOO +) -> _COOArray2D[np.complex128]: ... +@overload # dtype: complex128-like, format: "csc" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtCSC +) -> _CSCArray[np.complex128]: ... +@overload # dtype: complex128-like, format: "csr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtCSR +) -> _CSRArray2D[np.complex128]: ... +@overload # dtype: complex128-like, format: "dok" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtDOK +) -> _DOKArray2D[np.complex128]: ... +@overload # dtype: complex128-like, format: "lil" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtLIL +) -> _LILArray[np.complex128]: ... + +# +@overload # dtype: , format: "dia" | None def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None -) -> dia_array[_SCT]: ... -@overload # dtype like , format: None = ... +) -> _DIAArray[_SCT]: ... +@overload # dtype: , format: "bsr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtBSR +) -> _BSRArray[_SCT]: ... +@overload # dtype: , format: "coo" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtCOO +) -> _COOArray2D[_SCT]: ... +@overload # dtype: , format: "csc" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtCSC +) -> _CSCArray[_SCT]: ... +@overload # dtype: , format: "csr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtCSR +) -> _CSRArray2D[_SCT]: ... +@overload # dtype: , format: "dok" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtDOK +) -> _DOKArray2D[_SCT]: ... +@overload # dtype: , format: "lil" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtLIL +) -> _LILArray[_SCT]: ... + +# +@overload # dtype: , format: "dia" | None def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtDIA | None = None -) -> dia_array[Incomplete]: ... -@overload # dtype like float (default), format: +) -> _DIAArray[Incomplete]: ... +@overload # dtype: , format: "bsr" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtNonDIA -) -> _SpArray2D[np.float64]: ... -@overload # dtype like bool, format: + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtBSR +) -> _BSRArray[Incomplete]: ... +@overload # dtype: , format: "coo" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtNonDIA -) -> _SpArray2D[np.bool_]: ... -@overload # dtype like int, format: + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtCOO +) -> _COOArray2D[Incomplete]: ... +@overload # dtype: , format: "csc" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtNonDIA -) -> _SpArray2D[np.int_]: ... -@overload # dtype like complex, format: + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtCSC +) -> _CSCArray[Incomplete]: ... +@overload # dtype: , format: "csr" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtNonDIA -) -> _SpArray2D[np.complex128]: ... -@overload # dtype like , format: + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtCSR +) -> _CSRArray2D[Incomplete]: ... +@overload # dtype: , format: "dok" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtNonDIA -) -> _SpArray2D[_SCT]: ... -@overload # dtype like , fformat: + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtDOK +) -> _DOKArray2D[Incomplete]: ... +@overload # dtype: , format: "lil" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtNonDIA -) -> _SpArray2D[Incomplete]: ... + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtLIL +) -> _LILArray[Incomplete]: ... +### # NOTE: `eye_array` should be prefered over `eye` -@overload # dtype like float (default), default format +@overload # dtype: float64-like (default), format: "dia" | None def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtDIA | None = None ) -> dia_matrix[np.float64]: ... -@overload # dtype like bool (positional), default format +@overload # dtype: float64-like (default), format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None -) -> dia_matrix[np.bool_]: ... -@overload # dtype like bool (keyword), default format + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtBSR +) -> bsr_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "coo" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCOO +) -> coo_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCSC +) -> csc_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCSR +) -> csr_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtDOK +) -> dok_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "lil" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtLIL +) -> lil_matrix[np.float64]: ... + +# +@overload # dtype: bool-like, format: "dia" | None def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None ) -> dia_matrix[np.bool_]: ... -@overload # dtype like int (positional), default format +@overload # dtype: bool-like, format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtDIA | None = None -) -> dia_matrix[np.int_]: ... -@overload # dtype like int (keyword), default format + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtBSR +) -> bsr_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "coo" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCOO +) -> coo_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCSC +) -> csc_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCSR +) -> csr_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtDOK +) -> dok_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "lil" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtLIL +) -> lil_matrix[np.bool_]: ... + +# +@overload # dtype: int-like, format: "dia" | None def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtDIA | None = None ) -> dia_matrix[np.int_]: ... -@overload # dtype like complex (positional), default format +@overload # dtype: int-like, format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None -) -> dia_matrix[np.complex128]: ... -@overload # dtype like complex (keyword), default format + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtBSR +) -> bsr_matrix[np.int_]: ... +@overload # dtype: int-like, format: "coo" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCOO +) -> coo_matrix[np.int_]: ... +@overload # dtype: int-like, format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCSC +) -> csc_matrix[np.int_]: ... +@overload # dtype: int-like, format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCSR +) -> csr_matrix[np.int_]: ... +@overload # dtype: int-like, format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtDOK +) -> dok_matrix[np.int_]: ... +@overload # dtype: int-like, format: "lil" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtLIL +) -> lil_matrix[np.int_]: ... + +# +@overload # dtype: complex128-like, format: "dia" | None def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None ) -> dia_matrix[np.complex128]: ... -@overload # dtype like (positional), default format +@overload # dtype: complex128-like, format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None -) -> dia_matrix[_SCT]: ... -@overload # dtype like (keyword), default format + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtBSR +) -> bsr_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "coo" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCOO +) -> coo_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCSC +) -> csc_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCSR +) -> csr_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtDOK +) -> dok_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "lil" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtLIL +) -> lil_matrix[np.complex128]: ... + +# +@overload # dtype: , format: "dia" | None def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None ) -> dia_matrix[_SCT]: ... -@overload # dtype like (positional), default format +@overload # dtype: , format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtDIA | None = None -) -> dia_matrix[Incomplete]: ... -@overload # dtype like (keyword), default format + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtBSR +) -> bsr_matrix[_SCT]: ... +@overload # dtype: , format: "coo" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtDIA | None = None -) -> dia_matrix[Incomplete]: ... -@overload # dtype like float (default) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCOO +) -> coo_matrix[_SCT]: ... +@overload # dtype: , format: "csc" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _Format | None = None -) -> _SpMatrix[np.float64]: ... -@overload # dtype like bool (positional) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCSC +) -> csc_matrix[_SCT]: ... +@overload # dtype: , format: "csr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _Format | None = None -) -> _SpMatrix[np.bool_]: ... -@overload # dtype like bool (keyword) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCSR +) -> csr_matrix[_SCT]: ... +@overload # dtype: , format: "dok" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _Format | None = None -) -> _SpMatrix[np.bool_]: ... -@overload # dtype like int (positional) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtDOK +) -> dok_matrix[_SCT]: ... +@overload # dtype: , format: "lil" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _Format | None = None -) -> _SpMatrix[np.int_]: ... -@overload # dtype like int (keyword) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtLIL +) -> lil_matrix[_SCT]: ... + +# +@overload # dtype: , format: "dia" | None def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _Format | None = None -) -> _SpMatrix[np.int_]: ... -@overload # dtype like complex (positional) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtDIA | None = None +) -> dia_matrix[Incomplete]: ... +@overload # dtype: , format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _Format | None = None -) -> _SpMatrix[np.complex128]: ... -@overload # dtype like complex (keyword) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtBSR +) -> bsr_matrix[Incomplete]: ... +@overload # dtype: , format: "coo" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _Format | None = None -) -> _SpMatrix[np.complex128]: ... -@overload # dtype like (positional) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCOO +) -> coo_matrix[Incomplete]: ... +@overload # dtype: , format: "csc" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _Format | None = None -) -> _SpMatrix[_SCT]: ... -@overload # dtype like (keyword) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCSC +) -> csc_matrix[Incomplete]: ... +@overload # dtype: , format: "csr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _Format | None = None -) -> _SpMatrix[_SCT]: ... -@overload # dtype like (positional) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCSR +) -> csr_matrix[Incomplete]: ... +@overload # dtype: , format: "dok" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _Format | None = None -) -> _SpMatrix[Incomplete]: ... -@overload # dtype like (keyword) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtDOK +) -> dok_matrix[Incomplete]: ... +@overload # dtype: , format: "lil" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _Format | None = None -) -> _SpMatrix[Incomplete]: ... + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtLIL +) -> lil_matrix[Incomplete]: ... -# -@overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: {"bsr", None} = ... +### +@overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "bsr" | None def kron(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtBSR | None = None) -> bsr_matrix[_SCT]: ... @overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "coo" def kron(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtCOO) -> coo_matrix[_SCT]: ... @@ -528,7 +1294,9 @@ def kron(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtDIA) -> dia_mat def kron(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtDOK) -> dok_matrix[_SCT]: ... @overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "lil" def kron(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtLIL) -> lil_matrix[_SCT]: ... -@overload # A: sparray, B: 2D sparse, format: {"bsr", None} = ... + +# +@overload # A: sparray, B: 2D sparse, format: "bsr" | None def kron(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtBSR | None = None) -> _BSRArray[_SCT]: ... @overload # A: sparray, B: sparse, format: "coo" def kron(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtCOO) -> _COOArray2D[_SCT]: ... @@ -542,7 +1310,9 @@ def kron(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtDI def kron(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtDOK) -> _DOKArray2D[_SCT]: ... @overload # A: sparray, B: sparse, format: "lil" def kron(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtLIL) -> _LILArray[_SCT]: ... -@overload # A: sparse, B: sparray, format: {"bsr", None} = ... + +# +@overload # A: sparse, B: sparray, format: "bsr" | None def kron(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _FmtBSR | None = None) -> _BSRArray[_SCT]: ... @overload # A: sparray, B: sparse, format: "coo" def kron(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _FmtCOO) -> _COOArray2D[_SCT]: ... @@ -559,8 +1329,9 @@ def kron(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _FmtLI @overload # A: unknown array-like, B: unknown array-like (catch-all) def kron(A: onp.ToComplex2D, B: onp.ToComplex2D, format: _Format | None = None) -> _SpBase2D[Incomplete]: ... +### # NOTE: The `overload-overlap` mypy errors are false positives. -@overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: {"csr", None} = ... +@overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "csr" | None def kronsum(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtCSR | None = None) -> csr_matrix[_SCT]: ... @overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "bsr" def kronsum(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtBSR) -> bsr_matrix[_SCT]: ... @@ -574,7 +1345,9 @@ def kronsum(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtDIA) -> dia_ def kronsum(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtDOK) -> dok_matrix[_SCT]: ... @overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "lil" def kronsum(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtLIL) -> lil_matrix[_SCT]: ... -@overload # A: sparray, B: sparse, format: {"csr", None} = ... + +# +@overload # A: sparray, B: sparse, format: "csr" | None def kronsum(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtCSR | None = None) -> _CSRArray2D[_SCT]: ... @overload # A: sparray, B: sparse, format: "bsr" def kronsum(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtBSR) -> _BSRArray[_SCT]: ... @@ -588,7 +1361,9 @@ def kronsum(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _Fm def kronsum(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtDOK) -> _DOKArray2D[_SCT]: ... @overload # A: sparray, B: sparse, format: "lil" def kronsum(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtLIL) -> _LILArray[_SCT]: ... -@overload # A: sparse, B: sparray, format: {"csr", None} = ... + +# +@overload # A: sparse, B: sparray, format: "csr" | None def kronsum(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _FmtCSR | None = None) -> _CSRArray2D[_SCT]: ... @overload # A: sparse, B: sparray, format: "bsr" def kronsum(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _FmtBSR) -> _BSRArray[_SCT]: ... @@ -605,134 +1380,159 @@ def kronsum(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _Fm @overload # A: unknown array-like, B: unknown array-like (catch-all) def kronsum(A: onp.ToComplex2D, B: onp.ToComplex2D, format: _Format | None = None) -> _SpBase2D[Incomplete]: ... +### # NOTE: keep in sync with `vstack` @overload # sparray, format: , dtype: def hstack(blocks: Seq[_CanStack[_T]], format: None = None, dtype: None = None) -> _T: ... -@overload # sparray, format: , dtype: T (keyword) +@overload # sparray, format: , dtype: def hstack(blocks: Seq[_CanStackAs[_SCT0, _T]], format: None = None, *, dtype: onp.ToDType[_SCT0]) -> _T: ... -@overload # sparray, format: , dtype: bool_ (keyword) +@overload # sparray, format: , dtype: bool-like def hstack(blocks: Seq[_CanStackAs[np.bool_, _T]], format: None = None, *, dtype: onp.AnyBoolDType) -> _T: ... -@overload # sparray, format: , dtype: int_ (keyword) +@overload # sparray, format: , dtype: int-like def hstack(blocks: Seq[_CanStackAs[np.int_, _T]], format: None = None, *, dtype: onp.AnyIntDType) -> _T: ... -@overload # sparray, format: , dtype: float64 (keyword) +@overload # sparray, format: , dtype: float64-like def hstack(blocks: Seq[_CanStackAs[np.float64, _T]], format: None = None, *, dtype: onp.AnyFloat64DType) -> _T: ... -@overload # sparray, format: , dtype: complex128 (keyword) +@overload # sparray, format: , dtype: complex128-like def hstack(blocks: Seq[_CanStackAs[np.complex128, _T]], format: None = None, *, dtype: onp.AnyComplex128DType) -> _T: ... -@overload # sparray, format: , dtype: complex128-like (keyword) +@overload # sparray, format: , dtype: def hstack(blocks: Seq[_CanStackAs[Any, _T]], format: None = None, *, dtype: npt.DTypeLike) -> _T: ... @overload # TODO(jorenham): Support for `format=...` def hstack(blocks: Seq[_spbase], format: _Format, dtype: npt.DTypeLike | None = None) -> Incomplete: ... +### # NOTE: keep in sync with `vstack` @overload # sparray, format: , dtype: def vstack(blocks: Seq[_CanStack[_T]], format: None = None, dtype: None = None) -> _T: ... -@overload # sparray, format: , dtype: T (keyword) +@overload # sparray, format: , dtype: def vstack(blocks: Seq[_CanStackAs[_SCT0, _T]], format: None = None, *, dtype: onp.ToDType[_SCT0]) -> _T: ... -@overload # sparray, format: , dtype: bool_ (keyword) +@overload # sparray, format: , dtype: bool-like def vstack(blocks: Seq[_CanStackAs[np.bool_, _T]], format: None = None, *, dtype: onp.AnyBoolDType) -> _T: ... -@overload # sparray, format: , dtype: int_ (keyword) +@overload # sparray, format: , dtype: int-like def vstack(blocks: Seq[_CanStackAs[np.int_, _T]], format: None = None, *, dtype: onp.AnyIntDType) -> _T: ... -@overload # sparray, format: , dtype: float64 (keyword) +@overload # sparray, format: , dtype: float64-like def vstack(blocks: Seq[_CanStackAs[np.float64, _T]], format: None = None, *, dtype: onp.AnyFloat64DType) -> _T: ... -@overload # sparray, format: , dtype: complex128 (keyword) +@overload # sparray, format: , dtype: complex128-like def vstack(blocks: Seq[_CanStackAs[np.complex128, _T]], format: None = None, *, dtype: onp.AnyComplex128DType) -> _T: ... -@overload # sparray, format: , dtype: complex128-like (keyword) +@overload # sparray, format: , dtype: def vstack(blocks: Seq[_CanStackAs[Any, _T]], format: None = None, *, dtype: npt.DTypeLike) -> _T: ... @overload # TODO(jorenham): Support for `format=...` def vstack(blocks: Seq[_spbase], format: _Format, dtype: npt.DTypeLike | None = None) -> Incomplete: ... +### # TODO(jorenham): Use `_CanStack` here, which requires a way to map matrix types to array types. -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks[_SCT], *, format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks, *, format: _FmtCOO | None = None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks, *, format: _FmtCOO | None = None, dtype: npt.DTypeLike) -> _COOArray2D: ... -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks[_SCT], *, format: _FmtNonCOO, dtype: None = None) -> _SpArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: + +# +@overload # blocks: , format: , dtype: +def block_array(blocks: _ToBlocks, *, format: _FmtCOO | None = None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... +@overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks, *, format: _FmtNonCOO, dtype: onp.ToDType[_SCT]) -> _SpArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: + +# +@overload # blocks: , format: , dtype: +def block_array(blocks: _ToBlocks, *, format: _FmtCOO | None = None, dtype: npt.DTypeLike) -> _COOArray2D: ... +@overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks, *, format: _FmtNonCOO, dtype: npt.DTypeLike) -> _SpArray2D: ... +### # TODO(jorenham): Use `_CanStack` here, which requires a way to map array types to matrix types. -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: def bmat(blocks: Seq[Seq[sparray[_SCT]]], format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: +def bmat(blocks: Seq[Seq[sparray[_SCT]]], format: _FmtNonCOO, dtype: None = None) -> _SpArray2D[_SCT]: ... + +# +@overload # blocks: , format: , dtype: def bmat(blocks: Seq[Seq[spmatrix[_SCT]]], format: _FmtCOO | None = None, dtype: None = None) -> coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: (positional) -def bmat(blocks: _ToBlocks, format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: (keyword) +@overload # blocks: , format: , dtype: +def bmat(blocks: Seq[Seq[spmatrix[_SCT]]], format: _FmtNonCOO, dtype: None = None) -> _SpMatrix[_SCT]: ... + +# +@overload # blocks: , format: , dtype: def bmat( blocks: _ToBlocks, format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT] ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: +@overload # blocks: , format: , dtype: +def bmat(blocks: _ToBlocks, format: _FmtNonCOO, dtype: onp.ToDType[_SCT]) -> _SpBase2D[_SCT]: ... + +# +@overload # blocks: , format: , dtype: def bmat( blocks: _ToBlocks[_SCT], format: _FmtCOO | None = None, dtype: npt.DTypeLike | None = None ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: -def bmat(blocks: Seq[Seq[sparray[_SCT]]], format: _Format, dtype: None = None) -> _SpArray2D[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: -def bmat(blocks: Seq[Seq[spmatrix[_SCT]]], format: _Format, dtype: None = None) -> _SpMatrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: -def bmat(blocks: _ToBlocks, format: _Format, dtype: onp.ToDType[_SCT]) -> _SpBase2D[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: -def bmat(blocks: _ToBlocks, format: _Format, dtype: npt.DTypeLike) -> _SpBase2D: ... +@overload # blocks: , format: , dtype: +def bmat(blocks: _ToBlocks[_SCT], format: _FmtNonCOO, dtype: npt.DTypeLike) -> _SpBase2D[_SCT]: ... +### # TODO(jorenham): Add support for non-COO formats. -@overload # mats: +@overload # mats: , format: , dtype: None def block_diag(mats: Iterable[sparray[_SCT]], format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... -@overload # mats: + +# +@overload # mats: , format: , dtype: None def block_diag(mats: Iterable[spmatrix[_SCT]], format: _FmtCOO | None = None, dtype: None = None) -> coo_matrix[_SCT]: ... -@overload # mats: + +# +@overload # mats: , format: , dtype: None def block_diag( mats: Iterable[_spbase[_SCT] | onp.ArrayND[_SCT]], format: _FmtCOO | None = None, dtype: None = None ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # mats: , dtype: (positional) -def block_diag(mats: Iterable[sparray], format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> coo_array[_SCT, tuple[int, int]]: ... -@overload # mats: , dtype: (keyword) + +# +@overload # mats: , format: , dtype: (keyword) def block_diag(mats: Iterable[sparray], format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... -@overload # mats: , dtype: (positional) +@overload # mats: , format: , dtype: (positional) +def block_diag(mats: Iterable[sparray], format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... + +# +@overload # mats: , format: , dtype: (keyword) def block_diag( mats: Iterable[spmatrix | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], - format: _FmtCOO | None, + format: _FmtCOO | None = None, + *, dtype: onp.ToDType[_SCT], ) -> coo_matrix[_SCT]: ... -@overload # mats: , dtype: (keyword) +@overload # mats: , format: , dtype: (positional) def block_diag( mats: Iterable[spmatrix | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], - format: _FmtCOO | None = None, - *, + format: _FmtCOO | None, dtype: onp.ToDType[_SCT], ) -> coo_matrix[_SCT]: ... -@overload # mats: , dtype: (positional) + +# +@overload # mats: , format: , dtype: (keyword) def block_diag( mats: Iterable[_spbase | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], - format: _FmtCOO | None, + format: _FmtCOO | None = None, + *, dtype: onp.ToDType[_SCT], ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # mats: , dtype: (keyword) +@overload # mats: , format: , dtype: (positional) def block_diag( mats: Iterable[_spbase | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], - format: _FmtCOO | None = None, - *, + format: _FmtCOO | None, dtype: onp.ToDType[_SCT], ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # catch-all + +# +@overload # mats: , format: , dtype: def block_diag( mats: Iterable[_spbase | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], format: _FmtCOO | None = None, dtype: npt.DTypeLike | None = None, ) -> _COOArray2D[_SCT] | coo_matrix[Any]: ... -@overload # catch-all +@overload # mats: , format: , dtype: def block_diag( mats: Iterable[_spbase | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], - format: _Format | None = None, + format: _FmtNonCOO | None = None, dtype: npt.DTypeLike | None = None, ) -> Incomplete: ... -# -@overload # shape: T, dtype: , format: +### +@overload # shape: T, format: , dtype: def random_array( shape: _ShapeT, *, @@ -743,130 +1543,93 @@ def random_array( random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, ) -> coo_array[np.float64, _ShapeT]: ... -@overload # shape: T, dtype: , format: -def random_array( - shape: _ShapeT, - *, - density: float | npc.floating = 0.01, - format: _FmtCOO = "coo", - dtype: onp.ToDType[_SCT], - rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, - data_sampler: _DataSampler | None = None, -) -> coo_array[_SCT, _ShapeT]: ... -@overload # shape: T, dtype: complex, format: +@overload # shape: T, format: , dtype: def random_array( shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _FmtCOO = "coo", - dtype: onp.AnyComplex128DType, + format: _FmtNonCOO, + dtype: onp.AnyFloat64DType | None = None, rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> coo_array[np.complex128, _ShapeT]: ... -@overload # shape: T, dtype: , format: +) -> _SpArray[np.float64, _ShapeT]: ... + +# +@overload # shape: T, format: , dtype: def random_array( shape: _ShapeT, *, density: float | npc.floating = 0.01, format: _FmtCOO = "coo", - dtype: npt.DTypeLike, - rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, - data_sampler: _DataSampler | None = None, -) -> coo_array[Any, _ShapeT]: ... -@overload # shape: T, dtype: -def random_array( - shape: tuple[int], - *, - density: float | npc.floating = 0.01, - format: _Format = "coo", - dtype: onp.AnyFloat64DType | None = None, - rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, - data_sampler: _DataSampler | None = None, -) -> _SpArray1D[np.float64]: ... -@overload # shape: 2d, dtype: -def random_array( - shape: tuple[int, int], - *, - density: float | npc.floating = 0.01, - format: _Format = "coo", - dtype: onp.AnyFloat64DType | None = None, - rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, - data_sampler: _DataSampler | None = None, -) -> _SpArray2D[np.float64]: ... -@overload # shape: 1d, dtype: -def random_array( - shape: tuple[int], - *, - density: float | npc.floating = 0.01, - format: _Format = "coo", dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray1D[_SCT]: ... -@overload # shape: 2d, dtype: +) -> coo_array[_SCT, _ShapeT]: ... +@overload # shape: T, format: , dtype: def random_array( - shape: tuple[int, int], + shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _Format = "coo", + format: _FmtNonCOO, dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray2D[_SCT]: ... -@overload # shape: 1d, dtype: complex +) -> _SpArray[_SCT, _ShapeT]: ... + +# +@overload # shape: T, format: , dtype: complex def random_array( - shape: tuple[int], + shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _Format = "coo", + format: _FmtCOO = "coo", dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray1D[np.complex128]: ... -@overload # shape: 2d, dtype: complex +) -> coo_array[np.complex128, _ShapeT]: ... +@overload # shape: T, format: , dtype: complex def random_array( - shape: tuple[int, int], + shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _Format = "coo", + format: _FmtNonCOO, dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray2D[np.complex128]: ... -@overload # shape: 1d, dtype: +) -> _SpArray[np.complex128, _ShapeT]: ... + +# +@overload # shape: T, format: , dtype: def random_array( - shape: tuple[int], + shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _Format = "coo", + format: _FmtCOO = "coo", dtype: npt.DTypeLike, rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray1D: ... -@overload # shape: 2d, dtype: +) -> coo_array[Any, _ShapeT]: ... +@overload # shape: T, format: , dtype: def random_array( - shape: tuple[int, int], + shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _Format = "coo", + format: _FmtNonCOO, dtype: npt.DTypeLike, rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray2D: ... +) -> _SpArray[Any, _ShapeT]: ... +### # NOTE: `random_array` should be prefered over `random` -@overload # dtype: , format: +@overload # format: , dtype: def random( m: opt.AnyInt, n: opt.AnyInt, @@ -878,19 +1641,21 @@ def random( *, random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.float64]: ... -@overload # dtype: (positional), format: +@overload # format: , dtype: def random( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating, - format: _FmtCOO, - dtype: onp.ToDType[_SCT], + density: float | npc.floating = 0.01, + *, + format: _FmtNonCOO, + dtype: onp.AnyFloat64DType | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - *, random_state: onp.random.ToRNG | None = None, -) -> coo_matrix[_SCT]: ... -@overload # dtype: (keyword), format: +) -> _SpMatrix[np.float64]: ... + +# +@overload # format: , dtype: (keyword) def random( m: opt.AnyInt, n: opt.AnyInt, @@ -902,108 +1667,128 @@ def random( data_rvs: _DataRVS | None = None, random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[_SCT]: ... -@overload # dtype: complex (positional), format: +@overload # format: , dtype: (keyword) +def random( + m: opt.AnyInt, + n: opt.AnyInt, + density: float | npc.floating = 0.01, + *, + format: _FmtNonCOO, + dtype: onp.ToDType[_SCT], + rng: onp.random.ToRNG | None = None, + data_rvs: _DataRVS | None = None, + random_state: onp.random.ToRNG | None = None, +) -> _SpMatrix[_SCT]: ... + +# +@overload # format: , dtype: (positional) def random( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating, format: _FmtCOO, - dtype: onp.AnyComplex128DType, + dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, *, random_state: onp.random.ToRNG | None = None, -) -> coo_matrix[np.complex128]: ... -@overload # dtype: complex (keyword), format: +) -> coo_matrix[_SCT]: ... +@overload # format: , dtype: (positional) def random( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating = 0.01, - format: _FmtCOO = "coo", - *, - dtype: onp.AnyComplex128DType, + density: float | npc.floating, + format: _FmtNonCOO, + dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + *, random_state: onp.random.ToRNG | None = None, -) -> coo_matrix[np.complex128]: ... -@overload # dtype: , format: +) -> _SpMatrix[_SCT]: ... + +# +@overload # format: , dtype: complex (keyword) def random( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating = 0.01, format: _FmtCOO = "coo", - dtype: npt.DTypeLike | None = None, + *, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - *, random_state: onp.random.ToRNG | None = None, -) -> coo_matrix: ... -@overload # dtype: +) -> coo_matrix[np.complex128]: ... +@overload # format: , dtype: complex (keyword) def random( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating = 0.01, - format: _Format = ..., - dtype: onp.AnyFloat64DType | None = None, + *, + format: _FmtNonCOO, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - *, random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.float64]: ... -@overload # dtype: (positional) +) -> _SpMatrix[np.complex128]: ... + +# +@overload # format: , dtype: complex (positional) def random( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating, - format: _Format, - dtype: onp.ToDType[_SCT], + format: _FmtCOO, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, *, random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # dtype: (keyword) +) -> coo_matrix[np.complex128]: ... +@overload # format: , dtype: complex (positional) def random( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating = 0.01, - format: _Format = ..., - *, - dtype: onp.ToDType[_SCT], + density: float | npc.floating, + format: _FmtNonCOO, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + *, random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # dtype: complex (positional) +) -> _SpMatrix[np.complex128]: ... + +# +@overload # format: , dtype: def random( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating, - format: _Format, - dtype: onp.AnyComplex128DType, + density: float | npc.floating = 0.01, + format: _FmtCOO = "coo", + dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, *, random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.complex128]: ... -@overload # dtype: complex (keyword) +) -> coo_matrix: ... +@overload # format: (keyword), dtype: def random( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating = 0.01, - format: _Format = ..., *, - dtype: onp.AnyComplex128DType, + format: _FmtNonCOO, + dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.complex128]: ... -@overload # dtype: +) -> _SpMatrix: ... +@overload # format: (positional), dtype: def random( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating = 0.01, - format: _Format = ..., + density: float | npc.floating, + format: _FmtNonCOO, dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, @@ -1011,8 +1796,9 @@ def random( random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix: ... +### # NOTE: `random_array` should be prefered over `rand` -@overload # dtype: , format: +@overload # format: , dtype: def rand( m: opt.AnyInt, n: opt.AnyInt, @@ -1023,18 +1809,20 @@ def rand( *, random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.float64]: ... -@overload # dtype: (positional), format: +@overload # format: , dtype: def rand( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating, - format: _FmtCOO, - dtype: onp.ToDType[_SCT], - rng: onp.random.ToRNG | None = None, + density: float | npc.floating = 0.01, *, + format: _FmtNonCOO, + dtype: onp.AnyFloat64DType | None = None, + rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, -) -> coo_matrix[_SCT]: ... -@overload # dtype: (keyword), format: +) -> _SpMatrix[np.float64]: ... + +# +@overload # format: , dtype: (keyword) def rand( m: opt.AnyInt, n: opt.AnyInt, @@ -1045,18 +1833,44 @@ def rand( rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[_SCT]: ... -@overload # dtype: complex (positional), format: +@overload # format: , dtype: (keyword) +def rand( + m: opt.AnyInt, + n: opt.AnyInt, + density: float | npc.floating = 0.01, + *, + format: _FmtNonCOO, + dtype: onp.ToDType[_SCT], + rng: onp.random.ToRNG | None = None, + random_state: onp.random.ToRNG | None = None, +) -> _SpMatrix[_SCT]: ... + +# +@overload # format: , dtype: (positional) def rand( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating, format: _FmtCOO, - dtype: onp.AnyComplex128DType, + dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, *, random_state: onp.random.ToRNG | None = None, -) -> coo_matrix[np.complex128]: ... -@overload # dtype: complex (keyword), format: +) -> coo_matrix[_SCT]: ... +@overload # format: , dtype: (positional) +def rand( + m: opt.AnyInt, + n: opt.AnyInt, + density: float | npc.floating, + format: _FmtNonCOO, + dtype: onp.ToDType[_SCT], + rng: onp.random.ToRNG | None = None, + *, + random_state: onp.random.ToRNG | None = None, +) -> _SpMatrix[_SCT]: ... + +# +@overload # format: , dtype: complex (keyword) def rand( m: opt.AnyInt, n: opt.AnyInt, @@ -1067,67 +1881,71 @@ def rand( rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.complex128]: ... -@overload # dtype: +@overload # format: , dtype: complex (keyword) def rand( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating = 0.01, - format: _Format = "coo", - dtype: onp.AnyFloat64DType | None = None, - rng: onp.random.ToRNG | None = None, *, + format: _FmtNonCOO, + dtype: onp.AnyComplex128DType, + rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.float64]: ... -@overload # dtype: (positional) +) -> _SpMatrix[np.complex128]: ... + +# +@overload # format: , dtype: complex (positional) def rand( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating, - format: _Format, - dtype: onp.ToDType[_SCT], + format: _FmtCOO, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, *, random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # dtype: (keyword) +) -> coo_matrix[np.complex128]: ... +@overload # format: , dtype: complex (positional) def rand( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating = 0.01, - format: _Format = "coo", - *, - dtype: onp.ToDType[_SCT], + density: float | npc.floating, + format: _FmtNonCOO, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, + *, random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # dtype: complex (positional) +) -> _SpMatrix[np.complex128]: ... + +# +@overload # format: , dtype: def rand( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating, - format: _Format, - dtype: onp.AnyComplex128DType, + density: float | npc.floating = 0.01, + format: _FmtCOO = "coo", + dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, *, random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.complex128]: ... -@overload # dtype: complex (keyword) +) -> coo_matrix: ... +@overload # format: (keyword), dtype: def rand( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating = 0.01, - format: _Format = "coo", *, - dtype: onp.AnyComplex128DType, + format: _FmtNonCOO, + dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.complex128]: ... -@overload # dtype: +) -> _SpMatrix: ... +@overload # format: (positional), dtype: def rand( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating = 0.01, - format: _Format = "coo", + density: float | npc.floating, + format: _FmtNonCOO, dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, *, diff --git a/tests/sparse/test_construct.pyi b/tests/sparse/test_construct.pyi index e09f9424..d68c8182 100644 --- a/tests/sparse/test_construct.pyi +++ b/tests/sparse/test_construct.pyi @@ -27,6 +27,7 @@ shape_1d: tuple[int] shape_2d: tuple[int, int] shape_3d: tuple[int, int, int] +# TODO(julvandenbroeck): add tests for arrays with unknown shape, like np.ndarray[tuple[int, ...], np.dtype[ScalarType]] dense_1d: np.ndarray[tuple[int], np.dtype[ScalarType]] dense_2d: np.ndarray[tuple[int, int], np.dtype[ScalarType]] @@ -36,28 +37,149 @@ int_list: list[int] ### # diags_array +assert_type(sparse.diags_array([1, 2]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array([[1, 2], 2.0]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array([[1, 2.0], [2]]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array([3j, 5j]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array([[1, 2.0], [3j]]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array([[1, 2.0], 3j]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) assert_type(sparse.diags_array(dense_1d), sparse.dia_array[ScalarType]) -assert_type(sparse.diags_array([dense_1d, dense_1d]), sparse.dia_array[ScalarType]) +assert_type(sparse.diags_array(dense_1d.astype(np.longdouble)), sparse.dia_array[np.longdouble]) +assert_type(sparse.diags_array(dense_1d.astype(np.complex128)), sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array(dense_2d, offsets=int_list), sparse.dia_array[ScalarType]) +assert_type(sparse.diags_array(dense_1d, dtype="bool"), sparse.dia_array[np.bool_]) +assert_type(sparse.diags_array(dense_2d, dtype="bool"), sparse.dia_array[np.bool_]) +assert_type(sparse.diags_array(dense_1d, dtype=int), sparse.dia_array[np.int_]) +assert_type(sparse.diags_array(dense_2d, dtype=int), sparse.dia_array[np.int_]) +assert_type(sparse.diags_array(dense_1d, dtype=np.longdouble), sparse.dia_array[np.longdouble]) +assert_type(sparse.diags_array(dense_2d, dtype=np.longdouble), sparse.dia_array[np.longdouble]) +assert_type(sparse.diags_array(dense_1d, dtype="