🏷️ optimize: stub the remaining private modules (#722)

Author: jorenham

scipy-stubs/optimize/_bglu_dense.pyi

@@ -0,0 +1,50 @@
+from collections.abc import Callable
+from typing import Any, Concatenate, Generic, Never
+from typing_extensions import TypeVar
+
+import numpy as np
+import optype.numpy as onp
+import optype.numpy.compat as npc
+
+_MethodT = TypeVar("_MethodT", bound=Callable[Concatenate[Any, ...], object])
+_NumberT_co = TypeVar("_NumberT_co", bound=npc.number, default=Any, covariant=True)
+
+###
+
+__all__ = ["BGLU", "LU"]
+
+def _consider_refactor(method: _MethodT) -> _MethodT: ...  # undocumented
+
+class LU(Generic[_NumberT_co]):  # undocumented
+    A: onp.Array2D[_NumberT_co]
+    B: onp.Array2D[_NumberT_co]
+    b: onp.Array1D[np.intp]
+    m: int
+    n: int
+
+    def __init__(self, /, A: onp.Array2D[_NumberT_co], b: onp.Array1D[np.intp]) -> None: ...
+    def __setstate_cython__(self, /, state: tuple[object, ...]) -> None: ...
+    def __reduce_cython__(self) -> tuple[Any, ...]: ...
+    def update(self, /, i: int, j: int) -> None: ...
+    def solve(self, /, q: onp.ArrayND[npc.number], transposed: bool = False) -> onp.ArrayND[_NumberT_co]: ...
+
+class BGLU(LU[_NumberT_co], Generic[_NumberT_co]):  # undocumented
+    plu: tuple[onp.ArrayND[Any], ...]
+    L: onp.Array2D[_NumberT_co]
+    U: onp.Array2D[_NumberT_co]
+    pi: onp.Array2D[_NumberT_co]
+    pit: onp.Array1D[np.int_]
+    ops_list: list[onp.Array2D[np.float64]]
+    bglu_time: float
+    solves: int
+    updates: int
+    max_updates: int
+    average_solve_times: list[float]
+    mast: bool
+
+    def __init__(
+        self, /, A: onp.Array2D[_NumberT_co], b: onp.Array1D[np.intp], max_updates: int = 10, mast: bool = False
+    ) -> None: ...
+    def refactor(self, /, *args: Never) -> None: ...  # *args are needed for stubtest
+    def update_basis(self, /, i: int, j: int) -> None: ...
+    def perform_perm(self, /, p: onp.Array1D[np.intp]) -> onp.Array1D[np.intp]: ...

scipy-stubs/optimize/_direct.pyi

@@ -0,0 +1,27 @@
+# defined in scipy/optimize/_directmodule.c
+
+from _typeshed import Incomplete
+from collections.abc import Callable
+
+import numpy as np
+import optype.numpy as onp
+
+from scipy._lib._ccallback import LowLevelCallable
+
+def direct(
+    f: Callable[..., Incomplete] | LowLevelCallable,
+    lv: onp.Array1D[np.float64],
+    ub: onp.Array1D[np.float64],
+    f_args: tuple[object, ...],
+    disp: bool,
+    magic_eps: float,
+    max_feval: int,
+    max_iter: int,
+    algorithm: str,
+    fglobal: onp.Array1D[np.float64],
+    fglobal_reltol: float,
+    volume_reltol: float,
+    sigma_reltol: float,
+    callback: Callable[..., object],
+    /,
+) -> tuple[list[Incomplete], float, int, int, int]: ...  # -> (x_seq, minf, ret_code, numfunc, numiter)

scipy-stubs/optimize/_lbfgsb.pyi

@@ -0,0 +1,24 @@
+from _typeshed import Incomplete
+
+import numpy as np
+import optype.numpy as onp
+
+def setulb(
+    m: int,
+    x: onp.Array1D[np.float64],
+    l: onp.Array1D[np.float64],
+    u: onp.Array1D[np.float64],
+    nbd: onp.Array1D[np.int32 | np.int64],
+    f: onp.Array0D[np.int32 | np.int64],
+    g: onp.Array1D[np.int32 | np.int64],
+    factr: float,
+    pgtol: float,
+    wa: onp.Array1D[np.float64],
+    iwa: onp.Array1D[np.int32 | np.int64],
+    task: onp.Array1D[np.int32 | np.int64],
+    lsave: onp.Array1D[np.int32 | np.int64],
+    isave: onp.Array1D[np.int32 | np.int64],
+    dsave: onp.Array1D[np.float64],
+    maxls: int | None,
+    ln_task: onp.Array1D[np.int32 | np.int64],
+) -> tuple[Incomplete, ...]: ...

scipy-stubs/optimize/_minpack.pyi

@@ -0,0 +1,72 @@
+from collections.abc import Callable
+from typing import Any
+
+import numpy as np
+import optype.numpy as onp
+
+def _chkder(
+    m: int,
+    n: int,
+    x: onp.Array1D[np.float64],
+    fvec: onp.Array1D[np.float64],
+    fjac: onp.Array2D[np.float64],
+    ldfjac: int,
+    xp: onp.Array1D[np.float64],
+    fvecp: onp.Array1D[np.float64],
+    mode: int,
+    err: float,
+) -> tuple[int, onp.Array1D[np.float64]]: ...  # (good, err)
+
+#
+def _hybrd(
+    fun: Callable[..., onp.Array1D[np.float64]],
+    x0: onp.Array1D[np.float64],
+    args: tuple[object, ...],
+    full_output: bool,
+    xtol: float,
+    maxfev: int,
+    ml: int,
+    mu: int,
+    epsfcn: float,
+    factor: float,
+    diag: onp.Array1D[np.float64],
+) -> tuple[onp.Array1D[np.float64], dict[str, Any], int]: ...
+def _hybrj(
+    fun: Callable[..., onp.Array1D[np.float64]],
+    Dfun: Callable[..., onp.Array1D[np.float64]],
+    x0: onp.Array1D[np.float64],
+    args: tuple[object, ...],
+    full_output: bool,
+    col_deriv: bool,
+    xtol: float,
+    maxfev: int,
+    factor: float,
+    diag: onp.Array1D[np.float64],
+) -> tuple[onp.Array1D[np.float64], dict[str, Any], int]: ...
+def _lmdif(
+    fun: Callable[..., onp.Array1D[np.float64]],
+    x0: onp.Array1D[np.float64],
+    args: tuple[object, ...],
+    full_output: bool,
+    ftol: float,
+    xtol: float,
+    gtol: float,
+    maxfev: int,
+    epsfcn: float,
+    factor: float,
+    diag: onp.Array1D[np.float64],
+) -> tuple[onp.Array1D[np.float64], dict[str, Any], int]: ...
+def _lmder(
+    fun: Callable[..., onp.Array1D[np.float64]],
+    Dfun: Callable[..., onp.Array1D[np.float64]],
+    x0: onp.Array1D[np.float64],
+    args: tuple[object, ...],
+    full_output: bool,
+    col_deriv: bool,
+    ftol: float,
+    xtol: float,
+    gtol: float,
+    maxfev: int,
+    factor: float,
+    diag: onp.Array1D[np.float64],
+) -> tuple[onp.Array1D[np.float64], dict[str, Any], int]: ...

scipy-stubs/optimize/_moduleTNC.pyi

@@ -0,0 +1,27 @@
+# defined in scipy/optimize/tnc/_moduleTNC.pyx
+
+from collections.abc import Callable
+
+import numpy as np
+import optype.numpy as onp
+
+def tnc_minimize(
+    func_and_grad: Callable[..., tuple[float, onp.Array1D[np.float64]]],
+    x0: onp.Array1D[np.float64],
+    low: onp.Array1D[np.float64],
+    up: onp.Array1D[np.float64],
+    scale: onp.Array1D[np.float64],
+    offset: onp.Array1D[np.float64],
+    messages: int,
+    maxCGit: int,
+    maxfun: int,
+    eta: float,
+    stepmx: float,
+    accuracy: float,
+    fmin: float,
+    ftol: float,
+    xtol: float,
+    pgtol: float,
+    rescale: float,
+    callback: Callable[..., object] | None = None,
+) -> tuple[int, int, int, onp.Array1D[np.float64], float, onp.Array1D[np.float64]]: ...  # -> (rc, nfeval, niter, x, f, g)

scipy-stubs/optimize/_pava_pybind.pyi

@@ -0,0 +1,8 @@
+# defined in scipy/optimize/_pava/pava_pybind.cpp
+
+import numpy as np
+import optype.numpy as onp
+
+def pava(
+    xa: onp.Array1D[np.float64], wa: onp.Array1D[np.float64], ra: onp.Array1D[np.intp], /
+) -> tuple[onp.Array1D[np.float64], onp.Array1D[np.float64], onp.Array1D[np.intp], np.intp]: ...  # -> (x, w, r, b)

scipy-stubs/optimize/_remove_redundancy.pyi

@@ -0,0 +1,37 @@
+from typing import Literal, TypeVar
+
+import numpy as np
+import optype.numpy as onp
+import optype.numpy.compat as npc
+
+from scipy.sparse._base import _spbase
+
+_NumberT = TypeVar("_NumberT", bound=npc.number)
+_NumberT2 = TypeVar("_NumberT2", bound=npc.number)
+
+###
+
+def _row_count(A: onp.Array2D[npc.number]) -> onp.Array1D[np.intp]: ...
+def _get_densest(A: onp.Array2D[_NumberT], eligibleRows: onp.Array1D[np.bool_]) -> np.intp: ...
+def _remove_zero_rows(
+    A: onp.Array2D[_NumberT], b: onp.Array1D[_NumberT2]
+) -> tuple[onp.Array2D[_NumberT], onp.Array1D[_NumberT2], Literal[0, 2], str]: ...
+
+#
+def bg_update_dense(
+    plu: tuple[onp.Array1D[_NumberT], onp.Array1D[_NumberT2]], perm_r: onp.Array1D[np.intp], v: onp.Array1D[npc.number], j: int
+) -> tuple[onp.Array1D[_NumberT], onp.Array1D[_NumberT2]]: ...
+
+#
+def _remove_redundancy_pivot_dense(
+    A: onp.Array2D[_NumberT], rhs: onp.Array1D[_NumberT2], true_rank: int | None = None
+) -> tuple[onp.Array2D[_NumberT], onp.Array1D[_NumberT2], int, str]: ...
+def _remove_redundancy_pivot_sparse(
+    A: _spbase[_NumberT, tuple[int, int]], rhs: onp.Array1D[_NumberT2]
+) -> tuple[onp.Array2D[_NumberT], onp.Array1D[_NumberT2], int, str]: ...
+def _remove_redundancy_svd(
+    A: onp.Array2D[_NumberT], b: onp.Array1D[_NumberT2]
+) -> tuple[onp.Array2D[_NumberT], onp.Array1D[_NumberT2], int, str]: ...
+def _remove_redundancy_id(
+    A: onp.Array2D[_NumberT], rhs: onp.Array1D[_NumberT2], rank: int | None = None, randomized: bool = True
+) -> tuple[onp.Array2D[_NumberT], onp.Array1D[_NumberT2], int, str]: ...

scipy-stubs/optimize/_zeros.pyi

@@ -0,0 +1,49 @@
+# defined in scipy/optimize/zeros.c
+
+from collections.abc import Callable
+from typing import Concatenate
+
+def _bisect(
+    f: Callable[Concatenate[float, ...], float],
+    a: float,
+    b: float,
+    xtol: float,
+    rtol: float,
+    iter: int,
+    xargs: tuple[object, ...],
+    fulloutput: int,
+    disp: int = 1,
+) -> tuple[float, int, int, int]: ...
+def _brenth(
+    f: Callable[Concatenate[float, ...], float],
+    a: float,
+    b: float,
+    xtol: float,
+    rtol: float,
+    iter: int,
+    xargs: tuple[object, ...],
+    fulloutput: int,
+    disp: int = 1,
+) -> tuple[float, int, int, int]: ...
+def _brentq(
+    f: Callable[Concatenate[float, ...], float],
+    a: float,
+    b: float,
+    xtol: float,
+    rtol: float,
+    iter: int,
+    xargs: tuple[object, ...],
+    fulloutput: int,
+    disp: int = 1,
+) -> tuple[float, int, int, int]: ...
+def _ridder(
+    f: Callable[Concatenate[float, ...], float],
+    a: float,
+    b: float,
+    xtol: float,
+    rtol: float,
+    iter: int,
+    xargs: tuple[object, ...],
+    fulloutput: int,
+    disp: int = 1,
+) -> tuple[float, int, int, int]: ...