Merge branch 'main' into nevergrad-OneplusOne

Author: janosg

.pre-commit-config.yaml

@@ -22,10 +22,9 @@ repos:
     hooks:
       - id: update-algo-selection-code
         name: update algo selection code
-        entry: bash .tools/create_and_format_algo_selection_code.sh
+        entry: python .tools/update_algo_selection_hook.py
         language: python
-        files: (src/optimagic/optimizers/.|src/optimagic/algorithms.py|.tools/.)
-        always_run: false
+        files: ^(src/optimagic/optimizers/|src/optimagic/algorithms\.py|\.tools/)
         require_serial: true
         additional_dependencies:
           - hatchling

.tools/create_and_format_algo_selection_code.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+
+# sys.executable guarantees we stay inside the pre‑commit venv
+PYTHON = [sys.executable]
+# "-m" lets us call std‑lib modules (e.g. pip) the same way
+PYTHON_MINUS_M = [*PYTHON, "-m"]
+
+
+def run(cmd: list[str], **kwargs: Any) -> None:
+    subprocess.check_call(cmd, cwd=ROOT, **kwargs)
+
+
+def ensure_optimagic_is_locally_installed() -> None:
+    try:
+        run(PYTHON_MINUS_M + ["pip", "show", "optimagic"], stdout=subprocess.DEVNULL)
+    except subprocess.CalledProcessError:
+        run(PYTHON_MINUS_M + ["pip", "install", "-e", "."])
+
+
+def main() -> int:
+    ensure_optimagic_is_locally_installed()
+    run(PYTHON + [".tools/create_algo_selection_code.py"])
+
+    ruff_args = [
+        "--silent",
+        "--config",
+        "pyproject.toml",
+        "src/optimagic/algorithms.py",
+    ]
+    run(["ruff", "format", *ruff_args])
+    run(["ruff", "check", "--fix", *ruff_args])
+    return 0  # explicit success code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.tools/update_algo_selection_hook.py

@@ -86,6 +86,7 @@ install optimagic.
       f in the stopping criterion.
     - **stopping.maxiter** (int): If the maximum number of iterations is reached,
       the optimization stops, but we do not count this as convergence.
+    - **display** (bool): Set to True to print convergence messages. Default is False. Scipy name: **disp**.
 
 ```
 
@@ -122,6 +123,7 @@ install optimagic.
     - **convergence.ftol_abs** (float): Absolute difference in the criterion value between
       iterations that is tolerated to declare convergence. As no relative tolerances can be passed to Nelder-Mead,
       optimagic sets a non zero default for this.
+    - **display** (bool): Set to True to print convergence messages. Default is False. SciPy name: **disp**.
     - **adaptive** (bool): Adapt algorithm parameters to dimensionality of problem.
       Useful for high-dimensional minimization (:cite:`Gao2012`, p. 259-277). scipy's default is False.
 
@@ -165,6 +167,7 @@ install optimagic.
       the optimization stops but we do not count thisas convergence.
     - **stopping.maxiter** (int): If the maximum number of iterations is reached, the optimization stops,
       but we do not count this as convergence.
+    - **display** (bool): Set to True to print convergence messages. Default is False. SciPy name: **disp**.
 
 ```
 
@@ -190,7 +193,22 @@ install optimagic.
     - **norm** (float): Order of the vector norm that is used to calculate the gradient's "score" that
       is compared to the gradient tolerance to determine convergence. Default is infinite which means that
       the largest entry of the gradient vector is compared to the gradient tolerance.
+    - **display** (bool): Set to True to print convergence messages. Default is False. SciPy name: **disp**.
+    - **convergence_xtol_rel** (float): Relative tolerance for `x`. Terminate successfully if step size is less than `xk * xrtol` where `xk` is the current parameter vector. Default is 1e-5. SciPy name: **xrtol**.
+    - **armijo_condition** (float): Parameter for Armijo condition rule. Default is 1e-4. Ensures 
 
+        .. math::
+
+            f(x_k+\alpha p_k) \le f(x_k) \;+\mathrm{armijo\_condition}\,\cdot\,\alpha\,\nabla f(x_k)^\top p_k, 
+        
+      so each step yields at least a fraction **armijo_condition** of the predicted decrease. Smaller ⇒ more aggressive steps, larger ⇒ more conservative ones. SciPy name: **c1**.
+    - **curvature_condition** (float): Parameter for curvature condition rule. Default is 0.9. Ensures 
+      
+        .. math::
+
+            \nabla f(x_k+\alpha p_k)^\top p_k \ge \mathrm{curvature\_condition}\,\cdot\,\nabla f(x_k)^\top p_k, 
+        
+      so the new slope isn’t too negative. Smaller ⇒ stricter curvature reduction (smaller steps), larger ⇒ looser (bigger steps). SciPy name: **c2**.
 ```
 
 ```{eval-rst}
@@ -225,6 +243,7 @@ install optimagic.
       "score" that is compared to the gradient tolerance to determine convergence.
       Default is infinite which means that the largest entry of the gradient vector
       is compared to the gradient tolerance.
+    - **display** (bool): Set to True to print convergence messages. Default is False. SciPy name: **disp**.
 
 ```
 
@@ -271,6 +290,7 @@ install optimagic.
       relative change in the parameters for determining the convergence.
     - **stopping.maxiter** (int): If the maximum number of iterations is reached,
       the optimization stops, but we do not count this as convergence.
+    - **display** (bool): Set to True to print convergence messages. Default is False. SciPy name: **disp**.
 
 
 
@@ -309,6 +329,7 @@ install optimagic.
     RHO_j from x_j. RHO_j only decreases, never increases. The initial RHO_j is
     the `trustregion.initial_radius`. In this way COBYLA's iterations behave
     like a trust region algorithm.
+  - **display** (bool): Set to True to print convergence messages. Default is False. SciPy name: **disp**.
 
 ```
 
@@ -376,6 +397,7 @@ install optimagic.
       criterion rescaling. If 0, rescale at each iteration. If a large value,
       never rescale. If < 0, rescale is set to 1.3. optimagic defaults to scipy's
       default.
+    - **display** (bool): Set to True to print convergence messages. Default is False. SciPy name: **disp**.
 
 
 ```
@@ -436,6 +458,7 @@ install optimagic.
       valid only close to the current point it should be a small one.
       The trust radius is automatically updated throughout the optimization
       process, with ``trustregion_initial_radius`` being its initial value.
+    - **display** (bool): Set to True to print convergence messages. Default is False. SciPy name: **disp**.
 
 ```
 

docs/source/algorithms.md

@@ -190,7 +190,7 @@ def _build_history_dataframe(self) -> pd.DataFrame:
         # For numpy arrays with ndim = 0, tolist() returns a scalar, which violates the
         # type hinting list[Any] from above. As history["time"] is always a list, this
         # case is safe to ignore.
-        history["time"] = times.tolist()  # type: ignore[assignment]
+        history["time"] = times.tolist()
 
         df = pd.DataFrame(history)
         df = df.merge(

src/optimagic/logging/logger.py

@@ -409,7 +409,7 @@ def _get_flat_param_names(param: PyTree) -> list[str]:
     if fast_path:
         # Mypy raises an error here because .tolist() returns a str for zero-dimensional
         # arrays, but the fast path is only taken for 1d arrays, so it can be ignored.
-        return np.arange(param.size).astype(str).tolist()  # type: ignore[return-value]
+        return np.arange(param.size).astype(str).tolist()
 
     registry = get_registry(extended=True)
     return leaf_names(param, registry=registry)
@@ -530,7 +530,7 @@ def _get_batch_starts_and_stops(batch_ids: list[int]) -> tuple[list[int], list[i
     """
     ids_arr = np.array(batch_ids, dtype=np.int64)
     indices = np.where(ids_arr[:-1] != ids_arr[1:])[0] + 1
-    list_indices: list[int] = indices.tolist()  # type: ignore[assignment]
+    list_indices: list[int] = indices.tolist()
     starts = [0, *list_indices]
     stops = [*starts[1:], len(batch_ids)]
     return starts, stops

src/optimagic/optimization/history.py

@@ -145,13 +145,15 @@ def _solve_internal_problem(
 class ScipySLSQP(Algorithm):
     convergence_ftol_abs: NonNegativeFloat = CONVERGENCE_SECOND_BEST_FTOL_ABS
     stopping_maxiter: PositiveInt = STOPPING_MAXITER
+    display: bool = False
 
     def _solve_internal_problem(
         self, problem: InternalOptimizationProblem, x0: NDArray[np.float64]
     ) -> InternalOptimizeResult:
         options = {
             "maxiter": self.stopping_maxiter,
             "ftol": self.convergence_ftol_abs,
+            "disp": self.display,
         }
         raw_res = scipy.optimize.minimize(
             fun=problem.fun_and_jac,
@@ -186,6 +188,7 @@ class ScipyNelderMead(Algorithm):
     convergence_ftol_abs: NonNegativeFloat = CONVERGENCE_SECOND_BEST_FTOL_ABS
     convergence_xtol_abs: NonNegativeFloat = CONVERGENCE_SECOND_BEST_XTOL_ABS
     adaptive: bool = False
+    display: bool = False
 
     def _solve_internal_problem(
         self, problem: InternalOptimizationProblem, x0: NDArray[np.float64]
@@ -197,6 +200,7 @@ def _solve_internal_problem(
             "fatol": self.convergence_ftol_abs,
             # TODO: Benchmark if adaptive = True works better
             "adaptive": self.adaptive,
+            "disp": self.display,
         }
         raw_res = scipy.optimize.minimize(
             fun=problem.fun,
@@ -228,6 +232,7 @@ class ScipyPowell(Algorithm):
     convergence_ftol_rel: NonNegativeFloat = CONVERGENCE_FTOL_REL
     stopping_maxfun: PositiveInt = STOPPING_MAXFUN
     stopping_maxiter: PositiveInt = STOPPING_MAXITER
+    display: bool = False
 
     def _solve_internal_problem(
         self, problem: InternalOptimizationProblem, x0: NDArray[np.float64]
@@ -237,6 +242,7 @@ def _solve_internal_problem(
             "ftol": self.convergence_ftol_rel,
             "maxfev": self.stopping_maxfun,
             "maxiter": self.stopping_maxiter,
+            "disp": self.display,
         }
         raw_res = scipy.optimize.minimize(
             fun=problem.fun,
@@ -267,6 +273,10 @@ class ScipyBFGS(Algorithm):
     convergence_gtol_abs: NonNegativeFloat = CONVERGENCE_GTOL_ABS
     stopping_maxiter: PositiveInt = STOPPING_MAXITER
     norm: NonNegativeFloat = np.inf
+    convergence_xtol_rel: NonNegativeFloat = CONVERGENCE_XTOL_REL
+    display: bool = False
+    armijo_condition: NonNegativeFloat = 1e-4
+    curvature_condition: NonNegativeFloat = 0.9
 
     def _solve_internal_problem(
         self, problem: InternalOptimizationProblem, x0: NDArray[np.float64]
@@ -275,6 +285,10 @@ def _solve_internal_problem(
             "gtol": self.convergence_gtol_abs,
             "maxiter": self.stopping_maxiter,
             "norm": self.norm,
+            "xrtol": self.convergence_xtol_rel,
+            "disp": self.display,
+            "c1": self.armijo_condition,
+            "c2": self.curvature_condition,
         }
         raw_res = scipy.optimize.minimize(
             fun=problem.fun_and_jac, x0=x0, method="BFGS", jac=True, options=options
@@ -301,6 +315,7 @@ class ScipyConjugateGradient(Algorithm):
     convergence_gtol_abs: NonNegativeFloat = CONVERGENCE_GTOL_ABS
     stopping_maxiter: PositiveInt = STOPPING_MAXITER
     norm: NonNegativeFloat = np.inf
+    display: bool = False
 
     def _solve_internal_problem(
         self, problem: InternalOptimizationProblem, x0: NDArray[np.float64]
@@ -309,6 +324,7 @@ def _solve_internal_problem(
             "gtol": self.convergence_gtol_abs,
             "maxiter": self.stopping_maxiter,
             "norm": self.norm,
+            "disp": self.display,
         }
         raw_res = scipy.optimize.minimize(
             fun=problem.fun_and_jac, x0=x0, method="CG", jac=True, options=options
@@ -334,13 +350,15 @@ def _solve_internal_problem(
 class ScipyNewtonCG(Algorithm):
     convergence_xtol_rel: NonNegativeFloat = CONVERGENCE_XTOL_REL
     stopping_maxiter: PositiveInt = STOPPING_MAXITER
+    display: bool = False
 
     def _solve_internal_problem(
         self, problem: InternalOptimizationProblem, x0: NDArray[np.float64]
     ) -> InternalOptimizeResult:
         options = {
             "xtol": self.convergence_xtol_rel,
             "maxiter": self.stopping_maxiter,
+            "disp": self.display,
         }
         raw_res = scipy.optimize.minimize(
             fun=problem.fun_and_jac,
@@ -371,6 +389,7 @@ class ScipyCOBYLA(Algorithm):
     convergence_xtol_rel: NonNegativeFloat = CONVERGENCE_XTOL_REL
     stopping_maxiter: PositiveInt = STOPPING_MAXITER
     trustregion_initial_radius: PositiveFloat | None = None
+    display: bool = False
 
     def _solve_internal_problem(
         self, problem: InternalOptimizationProblem, x0: NDArray[np.float64]
@@ -384,6 +403,7 @@ def _solve_internal_problem(
         options = {
             "maxiter": self.stopping_maxiter,
             "rhobeg": radius,
+            "disp": self.display,
         }
 
         # cannot handle equality constraints
@@ -563,6 +583,7 @@ class ScipyTruncatedNewton(Algorithm):
     criterion_rescale_factor: float = -1
     # TODO: Check type hint for `func_min_estimate`
     func_min_estimate: float = 0
+    display: bool = False
 
     def _solve_internal_problem(
         self, problem: InternalOptimizationProblem, x0: NDArray[np.float64]
@@ -578,6 +599,7 @@ def _solve_internal_problem(
             "eta": self.line_search_severity,
             "accuracy": self.finite_difference_precision,
             "rescale": self.criterion_rescale_factor,
+            "disp": self.display,
         }
 
         raw_res = scipy.optimize.minimize(
@@ -612,6 +634,7 @@ class ScipyTrustConstr(Algorithm):
     convergence_xtol_rel: NonNegativeFloat = CONVERGENCE_XTOL_REL
     stopping_maxiter: PositiveInt = STOPPING_MAXITER
     trustregion_initial_radius: PositiveFloat | None = None
+    display: bool = False
 
     def _solve_internal_problem(
         self, problem: InternalOptimizationProblem, x0: NDArray[np.float64]
@@ -626,6 +649,7 @@ def _solve_internal_problem(
             "maxiter": self.stopping_maxiter,
             "xtol": self.convergence_xtol_rel,
             "initial_tr_radius": trustregion_initial_radius,
+            "disp": self.display,
         }
 
         # cannot handle equality constraints