🏷️ integrate: stub the remaining private C-extension modules

Author: jorenham

scipy-stubs/integrate/_dop.pyi

@@ -0,0 +1,50 @@
+from collections.abc import Callable
+from typing import Concatenate, Final, Never, Protocol, TypeAlias, final, type_check_only
+
+import numpy as np
+import optype.numpy as onp
+import optype.numpy.compat as npc
+
+_VecI32: TypeAlias = onp.Array1D[np.int32]
+_VecF64: TypeAlias = onp.Array1D[np.float64]
+
+# (x, y) -> f
+_FnCallback: TypeAlias = Callable[Concatenate[float, _VecF64, ...], onp.ArrayND[npc.floating]]
+# (nr, xold, x, y, con, icomp[, nd]) -> irtn
+_FnSolOut: TypeAlias = Callable[Concatenate[int, float, float, _VecF64, _VecF64, _VecI32, ...], int]
+
+@type_check_only
+@final
+class _fortran_dop(Protocol):
+    def __call__(
+        self,
+        /,
+        fcn: _FnCallback,
+        x: float,
+        y: _VecF64,
+        xend: float,
+        rtol: _VecF64,
+        atol: _VecF64,
+        solout: _FnSolOut,
+        iout: int,
+        work: _VecF64,
+        iwork: _VecI32,
+        fcn_extra_args: tuple[object, ...] = (),
+        overwrite_y: onp.ToBool = 0,
+        solout_extra_args: tuple[object, ...] = (),
+    ) -> tuple[float, _VecF64, _VecI32, int]: ...  # (x, y, iwork, idid)
+
+@type_check_only
+@final
+class _fortran_types(Protocol):
+    intvar: onp.Array0D[np.int32]
+    def __call__(self, *args: Never, **kwargs: Never) -> Never: ...  # raises TypeError at runtime
+
+###
+
+__f2py_numpy_version__: Final[str] = ...
+__version__: Final[str] = ...
+
+dop853: _fortran_dop = ...
+dopri5: _fortran_dop = ...
+types: _fortran_types = ...

scipy-stubs/integrate/_lsoda.pyi

@@ -0,0 +1,44 @@
+from collections.abc import Callable
+from typing import Concatenate, Final, Protocol, TypeAlias, final, type_check_only
+
+import numpy as np
+import optype.numpy as onp
+import optype.numpy.compat as npc
+
+from ._dop import types as types  # same signature, so no need to redefine
+
+_VecI32: TypeAlias = onp.Array1D[np.int32]
+_VecF64: TypeAlias = onp.Array1D[np.float64]
+
+# (t, y) -> ydot
+_FnCallback: TypeAlias = Callable[Concatenate[float, _VecF64, ...], onp.ArrayND[npc.floating]]
+
+@type_check_only
+@final
+class _fortran_lsoda(Protocol):
+    def __call__(
+        self,
+        /,
+        f: _FnCallback,
+        y: _VecF64,
+        t: float,
+        tout: float,
+        rtol: _VecF64,
+        atol: _VecF64,
+        itask: int,
+        istate: int,
+        rwork: _VecF64,
+        iwork: _VecI32,
+        jac: _FnCallback,
+        jt: int,
+        f_extra_args: tuple[object, ...] = (),
+        overwrite_y: onp.ToBool = 0,
+        jac_extra_args: tuple[object, ...] = (),
+    ) -> tuple[_VecF64, float, int]: ...  # (y, t, istate)
+
+###
+
+__f2py_numpy_version__: Final[str] = ...
+__version__: Final[str] = ...
+
+lsoda: _fortran_lsoda = ...

scipy-stubs/integrate/_odepack.pyi

@@ -0,0 +1,29 @@
+from _typeshed import Incomplete
+from collections.abc import Callable
+
+import optype.numpy as onp
+
+class error(Exception): ...
+
+def odeint(
+    fun: Callable[..., Incomplete],
+    y0: onp.ToFloat | onp.ToFloatND,
+    t: float,
+    args: tuple[object, ...] = (),
+    Dfun: Callable[..., Incomplete] | None = None,
+    col_deriv: int = 0,
+    ml: int = ...,
+    mu: int = ...,
+    full_output: onp.ToBool = 0,
+    rtol: float = ...,
+    atol: float = ...,
+    tcrit: float = ...,
+    h0: float = 0.0,
+    hmax: float = 0.0,
+    hmin: float = 0.0,
+    ixpr: float = 0.0,
+    mxstep: float = 0.0,
+    mxhnil: int = 0,
+    mxordn: int = 0,
+    mxords: int = 0,
+) -> tuple[Incomplete, ...]: ...

scipy-stubs/integrate/_quadpack.pyi

@@ -0,0 +1,11 @@
+class error(Exception): ...
+
+# _qagie(fun, bound, inf,                   | args, full_output, epsabs, epsrel, limit) -> {out}
+# _qagse(fun, a, b,                         | args, full_output, epsabs, epsrel, limit) -> {out}
+# _qagpe(fun, a, b, points,                 | args, full_output, epsabs, epsrel, limit) -> {out}
+# _qawce(fun, a, b, c,                      | args, full_output, epsabs, epsrel, limit) -> {out}
+# _qawse(fun, a, b, (alpha, beta), integr,  | args, full_output, epsabs, epsrel, limit) -> {out}
+# _qawfe(fun, a, omega, integr,             | args, full_output, epsabs, limlst, limit, maxp1) -> {out}
+# _qawoe(fun, a, b, omega, integr,          | args, full_output, epsabs, epsrel, limit, maxp1, icall, momcom, chebmo) -> {out}
+
+# {out} := [result, abserr, infodict, ier]

scipy-stubs/integrate/_vode.pyi

@@ -0,0 +1,71 @@
+from collections.abc import Callable
+from typing import Concatenate, Final, Protocol, TypeAlias, final, type_check_only
+
+import numpy as np
+import optype.numpy as onp
+import optype.numpy.compat as npc
+
+from ._dop import types as types  # same signature, so no need to redefine
+
+_VecI32: TypeAlias = onp.Array1D[np.int32]
+_VecF64: TypeAlias = onp.Array1D[np.float64]
+_VecC128: TypeAlias = onp.Array1D[np.complex128]
+
+# (t, y) -> ydot or jac
+_FnCallbackD: TypeAlias = Callable[Concatenate[float, _VecF64, ...], onp.ArrayND[npc.floating]]
+_FnCallbackZ: TypeAlias = Callable[Concatenate[float, _VecC128, ...], onp.ArrayND[npc.complexfloating]]
+
+@type_check_only
+@final
+class _fortran_dvode(Protocol):
+    def __call__(
+        self,
+        /,
+        f: _FnCallbackD,
+        jac: _FnCallbackD,
+        y: _VecF64,
+        t: float,
+        tout: float,
+        rtol: _VecF64,
+        atol: _VecF64,
+        itask: int,
+        istate: int,
+        rwork: _VecF64,
+        iwork: _VecI32,
+        mf: int,
+        f_extra_args: tuple[object, ...] = (),
+        jac_extra_args: tuple[object, ...] = (),
+        overwrite_y: onp.ToBool = 0,
+    ) -> tuple[_VecF64, float, int]: ...  # (y, t, istate)
+
+@type_check_only
+@final
+class _fortran_zvode(Protocol):
+    def __call__(
+        self,
+        /,
+        f: _FnCallbackZ,
+        jac: _FnCallbackZ,
+        y: _VecC128,
+        t: float,
+        tout: float,
+        rtol: _VecF64,
+        atol: _VecF64,
+        itask: int,
+        istate: int,
+        zwork: _VecC128,
+        rwork: _VecF64,
+        iwork: _VecI32,
+        mf: int,
+        f_extra_args: tuple[object, ...] = (),
+        jac_extra_args: tuple[object, ...] = (),
+        overwrite_y: onp.ToBool = 0,
+    ) -> tuple[_VecF64, float, int]: ...  # (y, t, istate)
+
+###
+
+__f2py_numpy_version__: Final[str] = ...
+__version__: Final[str] = ...
+
+dvode: _fortran_dvode = ...
+zvode: _fortran_zvode = ...