Merge pull request #222 from jorenham/optimize.shgo

`optimize`: complete `shgo`, improve `basinhopping`

Author: jorenham

scipy-stubs/optimize/_basinhopping.pyi

@@ -1,11 +1,12 @@
-from collections.abc import Callable, Mapping
+from collections.abc import Callable
 from typing import Concatenate, Literal, Protocol, TypeAlias, TypeVar, type_check_only
 
 import numpy as np
 import optype.numpy as onp
 from scipy._typing import Seed
 from ._minimize import OptimizeResult as _MinimizeResult
 from ._optimize import OptimizeResult as _OptimizeResult
+from ._typing import MinimizerKwargs
 
 __all__ = ["basinhopping"]
 
@@ -53,7 +54,7 @@ def basinhopping(
     niter: onp.ToJustInt = 100,
     T: onp.ToFloat = 1.0,
     stepsize: onp.ToFloat = 0.5,
-    minimizer_kwargs: Mapping[str, object] | None = None,
+    minimizer_kwargs: MinimizerKwargs | None = None,
     take_step: Callable[[_Float1D], onp.ToFloat] | None = None,
     accept_test: _AcceptTestFun[onp.ToFloat] | None = None,
     callback: _CallbackFun[float] | _CallbackFun[np.float64] | None = None,

scipy-stubs/optimize/_dual_annealing.pyi

@@ -1,29 +1,16 @@
 from collections.abc import Callable
-from typing import Concatenate, Literal, TypeAlias, TypedDict, type_check_only
+from typing import Concatenate, Literal, TypeAlias
 
 import numpy as np
 import optype.numpy as onp
 from scipy._typing import Seed
 from scipy.optimize import OptimizeResult as _OptimizeResult
 from ._constraints import Bounds
-from ._hessian_update_strategy import HessianUpdateStrategy
-from ._minimize import _MinimizeOptions
-from ._typing import Constraints, MethodMimimize
+from ._typing import MinimizerKwargs
 
 __all__ = ["dual_annealing"]
 
 _Float1D: TypeAlias = onp.Array1D[np.float64]
-_FDMethod: TypeAlias = Literal["2-point", "3-point", "cs"]
-
-@type_check_only
-class _MinimizeKwargs(TypedDict, total=False):
-    method: MethodMimimize
-    jac: Callable[Concatenate[_Float1D, ...], onp.ToFloat1D] | _FDMethod | bool
-    hess: Callable[Concatenate[_Float1D, ...], onp.ToFloat2D] | _FDMethod | HessianUpdateStrategy
-    hessp: Callable[Concatenate[_Float1D, _Float1D, ...], onp.ToFloat1D]
-    constraints: Constraints
-    tol: onp.ToFloat
-    options: _MinimizeOptions
 
 ###
 
@@ -43,7 +30,7 @@ def dual_annealing(
     bounds: Bounds | tuple[onp.ToFloat1D, onp.ToFloat1D] | onp.ToFloat2D,
     args: tuple[object, ...] = (),
     maxiter: onp.ToJustInt = 1_000,
-    minimizer_kwargs: _MinimizeKwargs | None = None,
+    minimizer_kwargs: MinimizerKwargs | None = None,
     initial_temp: onp.ToFloat = 5_230.0,
     restart_temp_ratio: onp.ToFloat = 2e-05,
     visit: onp.ToFloat = 2.62,

scipy-stubs/optimize/_shgo.pyi

@@ -1,30 +1,46 @@
-from collections.abc import Callable, Iterable, Mapping, Sequence
-from typing import Any, Final, Literal, TypeAlias, TypeVar
+from collections.abc import Callable, Iterable, Sequence
+from typing import Concatenate, Literal, TypeAlias, TypedDict, TypeVar, type_check_only
 
 import numpy as np
-import numpy.typing as npt
 import optype.numpy as onp
-from scipy._typing import EnterSelfMixin, Untyped, UntypedArray, UntypedCallable
+from ._constraints import Bounds
 from ._optimize import OptimizeResult as _OptimizeResult
-from ._typing import Constraints
+from ._typing import Constraints, MinimizerKwargs
 
 __all__ = ["shgo"]
 
-_MinimizerKwargs: TypeAlias = Mapping[str, object]  # TODO(jorenham): TypedDict
-_Options: TypeAlias = Mapping[str, object]  # TODO(jorenham): TypedDict
-
-_SamplingMethodName: TypeAlias = Literal["simplicial", "halton", "sobol"]
-_SamplingMethodFunc: TypeAlias = Callable[[int, int], onp.ArrayND[np.float64]]
-_SamplingMethod: TypeAlias = _SamplingMethodName | _SamplingMethodFunc
-
 _VT = TypeVar("_VT")
 _RT = TypeVar("_RT")
 
+_Float: TypeAlias = float | np.float64
+_Float1D: TypeAlias = onp.Array1D[np.float64]
+_Fun1D: TypeAlias = Callable[Concatenate[_Float1D, ...], _RT]
+
+@type_check_only
+class _SHGOOptions(TypedDict, total=False):
+    f_min: _Float
+    f_tol: _Float
+    maxiter: int
+    maxfev: int
+    maxev: int
+    mmaxtime: _Float
+    minhgrd: int
+    symmetry: Sequence[int] | onp.ToBool
+    jac: _Fun1D[onp.ToFloat1D] | onp.ToBool  # gradient
+    hess: _Fun1D[onp.ToFloat2D]
+    hessp: Callable[Concatenate[_Float1D, _Float1D, ...], onp.ToFloat1D]
+    minimize_every_iter: onp.ToBool
+    local_iter: int
+    infty_constraints: onp.ToBool
+    disp: onp.ToBool
+
+###
+
 class OptimizeResult(_OptimizeResult):
-    x: onp.ArrayND[np.float64]
-    xl: list[onp.ArrayND[np.float64]]
-    fun: float | np.float64
-    funl: list[float | np.float64]
+    x: _Float1D
+    xl: Sequence[_Float1D]
+    fun: _Float
+    funl: Sequence[_Float]
     success: bool
     message: str
     nfev: int
@@ -33,151 +49,17 @@ class OptimizeResult(_OptimizeResult):
     nlhev: int  # undocumented
     nit: int
 
-###
-
-class SHGO(EnterSelfMixin):
-    func: UntypedCallable
-    bounds: Untyped
-    args: tuple[object, ...]
-    callback: UntypedCallable
-    dim: int
-    constraints: Constraints
-    min_cons: Untyped
-    g_cons: Untyped
-    g_args: Untyped
-    minimizer_kwargs: _MinimizerKwargs
-    f_min_true: Untyped
-    minimize_every_iter: bool
-    maxiter: int
-    maxfev: int
-    maxev: Untyped
-    maxtime: Untyped
-    minhgrd: Untyped
-    symmetry: Untyped
-    infty_cons_sampl: bool
-    local_iter: bool
-    disp: bool
-    min_solver_args: Untyped
-    stop_global: bool
-    break_routine: bool
-    iters: int
-    iters_done: int
-    n: int
-    nc: int
-    n_prc: int
-    n_sampled: int
-    fn: int
-    hgr: int
-    qhull_incremental: bool
-    HC: Untyped
-    iterate_complex: Untyped
-    sampling_method: Untyped
-    qmc_engine: Untyped
-    sampling: Untyped
-    sampling_function: Untyped
-    stop_l_iter: bool
-    stop_complex_iter: bool
-    minimizer_pool: Untyped
-    LMC: Untyped
-    res: Untyped
-    init: Untyped
-    f_tol: Untyped
-    f_lowest: Untyped
-    x_lowest: Untyped
-    hgrd: Untyped
-    Ind_sorted: Untyped
-    Tri: Untyped
-    points: Untyped
-    minimizer_pool_F: Untyped
-    X_min: Untyped
-    X_min_cache: Untyped
-    Y: Untyped
-    Z: Untyped
-    Ss: Untyped
-    ind_f_min: Untyped
-    C: Untyped
-    Xs: Untyped
-    def __init__(
-        self,
-        /,
-        func: UntypedCallable,
-        bounds: Untyped,
-        args: tuple[object, ...] = (),
-        constraints: Constraints | None = None,
-        n: Untyped | None = None,
-        iters: Untyped | None = None,
-        callback: UntypedCallable | None = None,
-        minimizer_kwargs: Mapping[str, Any] | None = None,
-        options: Mapping[str, Any] | None = None,
-        sampling_method: _SamplingMethod = "simplicial",
-        workers: int = 1,
-    ) -> None: ...
-    def init_options(self, /, options: Untyped) -> None: ...
-    def iterate_all(self, /) -> None: ...
-    def find_minima(self, /) -> None: ...
-    def find_lowest_vertex(self, /) -> None: ...
-    def finite_iterations(self, /) -> Untyped: ...
-    def finite_fev(self, /) -> Untyped: ...
-    def finite_ev(self, /) -> None: ...
-    def finite_time(self, /) -> None: ...
-    def finite_precision(self, /) -> Untyped: ...
-    def finite_homology_growth(self, /) -> Untyped: ...
-    def stopping_criteria(self, /) -> Untyped: ...
-    def iterate(self, /) -> None: ...
-    def iterate_hypercube(self, /) -> None: ...
-    def iterate_delaunay(self, /) -> None: ...
-    def minimizers(self, /) -> Untyped: ...
-    def minimise_pool(self, /, force_iter: bool = False) -> None: ...
-    def sort_min_pool(self, /) -> None: ...
-    def trim_min_pool(self, /, trim_ind: Untyped) -> None: ...
-    def g_topograph(self, /, x_min: Untyped, X_min: Untyped) -> Untyped: ...
-    def construct_lcb_simplicial(self, /, v_min: Untyped) -> Untyped: ...
-    def construct_lcb_delaunay(self, /, v_min: Untyped, ind: Untyped | None = None) -> Untyped: ...
-    def minimize(self, /, x_min: Untyped, ind: Untyped | None = None) -> Untyped: ...
-    def sort_result(self, /) -> Untyped: ...
-    def fail_routine(self, /, mes: str = "Failed to converge") -> None: ...
-    def sampled_surface(self, /, infty_cons_sampl: bool = False) -> None: ...
-    def sampling_custom(self, /, n: Untyped, dim: Untyped) -> Untyped: ...
-    def sampling_subspace(self, /) -> None: ...
-    def sorted_samples(self, /) -> Untyped: ...
-    def delaunay_triangulation(self, /, n_prc: int = 0) -> Untyped: ...
-
-# undocumented
-class LMap:
-    v: Untyped
-    x_l: Untyped
-    lres: Untyped
-    f_min: Untyped
-    lbounds: list[Untyped]
-    def __init__(self, /, v: Untyped) -> None: ...
-
-# undocumented
-class LMapCache:
-    cache: Final[dict[tuple[np.number[Any], ...], Untyped]]
-    xl_maps_set: Final[set[Untyped]]
-    v_maps: Final[list[Untyped]]
-    lbound_maps: Final[list[Untyped]]
-
-    xl_maps: list[Untyped] | UntypedArray
-    f_maps: list[Untyped]
-    size: int
-
-    def __init__(self, /) -> None: ...
-    def __getitem__(self, v: npt.ArrayLike, /) -> Untyped: ...
-    def add_res(self, /, v: Untyped, lres: Untyped, bounds: Untyped | None = None) -> None: ...
-    def sort_cache_result(self, /) -> dict[str, Untyped]: ...  # TODO(jorenham): TypedDict
-
 def shgo(
-    func: UntypedCallable,
-    bounds: Untyped,
+    func: _Fun1D[onp.ToFloat],
+    bounds: tuple[onp.ToFloat | onp.ToFloat1D, onp.ToFloat | onp.ToFloat1D] | Bounds,
     args: tuple[object, ...] = (),
     constraints: Constraints | None = None,
-    n: int = 100,
-    iters: int = 1,
-    callback: Callable[[onp.Array1D[np.float64]], None] | None = None,
-    minimizer_kwargs: _MinimizerKwargs | None = None,  # TODO(jorenham): TypedDict
-    options: _Options | None = None,  # TODO(jorenham): TypedDict
-    sampling_method: _SamplingMethod = "simplicial",
+    n: onp.ToJustInt = 100,
+    iters: onp.ToJustInt = 1,
+    callback: Callable[[_Float1D], None] | None = None,
+    minimizer_kwargs: MinimizerKwargs | None = None,
+    options: _SHGOOptions | None = None,
+    sampling_method: Callable[[int, int], onp.ToFloat2D] | Literal["simplicial", "halton", "sobol"] = "simplicial",
     *,
-    workers: int | Callable[[Callable[[_VT], _RT], Iterable[_VT]], Sequence[_RT]] = 1,
+    workers: onp.ToJustInt | Callable[[Callable[[_VT], _RT], Iterable[_VT]], Sequence[_RT]] = 1,
 ) -> OptimizeResult: ...

scipy-stubs/optimize/_typing.pyi

@@ -5,6 +5,8 @@ from typing_extensions import NotRequired, TypedDict
 import numpy as np
 import optype.numpy as onp
 from ._constraints import Bounds as _Bounds, LinearConstraint, NonlinearConstraint
+from ._hessian_update_strategy import HessianUpdateStrategy
+from ._minimize import _MinimizeOptions
 
 __all__ = [
     "Bound",
@@ -17,6 +19,7 @@ __all__ = [
     "MethodMimimize",
     "MethodMinimizeScalar",
     "MethodRootScalar",
+    "MinimizerKwargs",
     "Solver",
     "TRSolver",
 ]
@@ -84,3 +87,15 @@ MethodAll: TypeAlias = Literal[
     MethodLinprog,
     _MethodQuadraticAssignment,
 ]
+
+_FDMethod: TypeAlias = Literal["2-point", "3-point", "cs"]
+
+@type_check_only
+class MinimizerKwargs(TypedDict, total=False):
+    method: MethodMimimize
+    jac: Callable[Concatenate[_Float1D, ...], onp.ToFloat1D] | _FDMethod | bool
+    hess: Callable[Concatenate[_Float1D, ...], onp.ToFloat2D] | _FDMethod | HessianUpdateStrategy
+    hessp: Callable[Concatenate[_Float1D, _Float1D, ...], onp.ToFloat1D]
+    constraints: Constraints
+    tol: onp.ToFloat
+    options: _MinimizeOptions