hone-python 0.9.0__tar.gz → 0.10.0__tar.gz

{hone_python-0.9.0 → hone_python-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hone-python
-Version: 0.9.0
+Version: 0.10.0
 Summary: A python-based optimization engine/library.
 License-Expression: BSD-3-Clause
 License-File: LICENSE
@@ -178,6 +178,35 @@ RangeParameter("n_estimators", 10, 1000, integer=True, log=True)
 
 Every parameter the objective function requires must be in the search space. The optimizer checks this before it starts.
 
+### Constraints
+
+Limits across parameters are written with the parameters themselves and passed to `SearchSpace`. Every optimizer then only asks for points that satisfy every constraint, so the objective is never evaluated outside them:
+
+```python
+from hone import RangeParameter, SearchSpace
+
+width = RangeParameter("width", 1, 10)
+height = RangeParameter("height", 1, 10)
+search_space = SearchSpace([width, height], constraints=[width * height <= 40, width >= 2 * height])
+```
+
+Range parameters and numbers combine with `+`, `-`, `*`, `/`, `**` and `abs()`, and `<=` or `>=` makes the result a constraint; `<` and `>` mean the same. A point where a constraint can't be computed, such as one that divides by zero, counts as breaking it. There are no equality constraints: an equality leaves nothing to sample, so remove a variable instead and compute it inside the objective. Write a range as two constraints, since Python reads `0 <= width - height <= 5` as two comparisons joined by `and`, and hone raises an error rather than keep one half.
+
+For anything an expression can't say, such as a square root or a choice parameter, use a function, which takes parameters by name and is satisfied when it returns zero or less:
+
+```python
+from hone import Constraint
+
+def stress(width, height, material):
+    return bending_stress(width, height) - ALLOWED[material]
+
+search_space = SearchSpace([width, height, material], constraints=[Constraint.function(stress)])
+```
+
+Constraints should be quick to check: hone checks them for every candidate it considers, which can be many times the number of evaluations. Expression constraints are saved with a result; a function constraint saves only its name, so after `Result.load` pass the function again with `rebuild_optimizer(functions={"stress": stress})`.
+
+Starting points must satisfy the constraints. If the constraints leave nothing to search, or a region too small to find in 100,000 random draws, the optimizer raises `InfeasibleSearchSpace` when it's created, before any evaluation. Each optimizer keeps to constraints in its own way: random search and Bayesian optimization only consider points that satisfy them, CMA-ES draws a candidate again while it breaks one, and the genetic optimizer moves such a child back toward its fitter parent until it is feasible, which tends to land it near the boundary, where constrained optima usually are. On the benchmark's constrained problems the choice between optimizers follows the same pattern as without constraints; see [benchmarks/README.md](benchmarks/README.md#constrained-problems). [examples/pressure_vessel.py](examples/pressure_vessel.py) designs a pressure vessel of least cost under three constraints and finds the best published design. [examples/maintenance_schedule.py](examples/maintenance_schedule.py) chooses a maintenance schedule for a production line, scored by a noisy simulation of a year, with a constraint on technician hours and a function constraint that depends on the chosen shift; it halves the expected yearly cost of a sensible schedule chosen by hand.
+
 ### Configuration
 
 `GeneticOptimizerConfig` validates its values when created. It can also be loaded from a JSON or YAML file:
@@ -326,6 +355,7 @@ Requires Python 3.12 or later and [Poetry](https://python-poetry.org/) 2.
 | `make benchmark` | Run the full benchmark suite and update `benchmarks/results.md` |
 | `make benchmark-noisy` | Run the noisy problems and update `benchmarks/noisy-results.md` |
 | `make benchmark-ml` | Run the machine learning tuning problems and update `benchmarks/ml-results.md` |
+| `make benchmark-constrained` | Run the constrained problems and update `benchmarks/constrained-results.md` |
 
 To release, raise `version` in `pyproject.toml` and add a section for it to `CHANGELOG.md`. Once the change is on `main` and its checks pass, CI tags the version, publishes a GitHub release with that section as its notes and the built package attached, and uploads the same package to PyPI as `hone-python`.
 

{hone_python-0.9.0 → hone_python-0.10.0}/README.md

@@ -157,6 +157,35 @@ RangeParameter("n_estimators", 10, 1000, integer=True, log=True)
 
 Every parameter the objective function requires must be in the search space. The optimizer checks this before it starts.
 
+### Constraints
+
+Limits across parameters are written with the parameters themselves and passed to `SearchSpace`. Every optimizer then only asks for points that satisfy every constraint, so the objective is never evaluated outside them:
+
+```python
+from hone import RangeParameter, SearchSpace
+
+width = RangeParameter("width", 1, 10)
+height = RangeParameter("height", 1, 10)
+search_space = SearchSpace([width, height], constraints=[width * height <= 40, width >= 2 * height])
+```
+
+Range parameters and numbers combine with `+`, `-`, `*`, `/`, `**` and `abs()`, and `<=` or `>=` makes the result a constraint; `<` and `>` mean the same. A point where a constraint can't be computed, such as one that divides by zero, counts as breaking it. There are no equality constraints: an equality leaves nothing to sample, so remove a variable instead and compute it inside the objective. Write a range as two constraints, since Python reads `0 <= width - height <= 5` as two comparisons joined by `and`, and hone raises an error rather than keep one half.
+
+For anything an expression can't say, such as a square root or a choice parameter, use a function, which takes parameters by name and is satisfied when it returns zero or less:
+
+```python
+from hone import Constraint
+
+def stress(width, height, material):
+    return bending_stress(width, height) - ALLOWED[material]
+
+search_space = SearchSpace([width, height, material], constraints=[Constraint.function(stress)])
+```
+
+Constraints should be quick to check: hone checks them for every candidate it considers, which can be many times the number of evaluations. Expression constraints are saved with a result; a function constraint saves only its name, so after `Result.load` pass the function again with `rebuild_optimizer(functions={"stress": stress})`.
+
+Starting points must satisfy the constraints. If the constraints leave nothing to search, or a region too small to find in 100,000 random draws, the optimizer raises `InfeasibleSearchSpace` when it's created, before any evaluation. Each optimizer keeps to constraints in its own way: random search and Bayesian optimization only consider points that satisfy them, CMA-ES draws a candidate again while it breaks one, and the genetic optimizer moves such a child back toward its fitter parent until it is feasible, which tends to land it near the boundary, where constrained optima usually are. On the benchmark's constrained problems the choice between optimizers follows the same pattern as without constraints; see [benchmarks/README.md](benchmarks/README.md#constrained-problems). [examples/pressure_vessel.py](examples/pressure_vessel.py) designs a pressure vessel of least cost under three constraints and finds the best published design. [examples/maintenance_schedule.py](examples/maintenance_schedule.py) chooses a maintenance schedule for a production line, scored by a noisy simulation of a year, with a constraint on technician hours and a function constraint that depends on the chosen shift; it halves the expected yearly cost of a sensible schedule chosen by hand.
+
 ### Configuration
 
 `GeneticOptimizerConfig` validates its values when created. It can also be loaded from a JSON or YAML file:
@@ -305,6 +334,7 @@ Requires Python 3.12 or later and [Poetry](https://python-poetry.org/) 2.
 | `make benchmark` | Run the full benchmark suite and update `benchmarks/results.md` |
 | `make benchmark-noisy` | Run the noisy problems and update `benchmarks/noisy-results.md` |
 | `make benchmark-ml` | Run the machine learning tuning problems and update `benchmarks/ml-results.md` |
+| `make benchmark-constrained` | Run the constrained problems and update `benchmarks/constrained-results.md` |
 
 To release, raise `version` in `pyproject.toml` and add a section for it to `CHANGELOG.md`. Once the change is on `main` and its checks pass, CI tags the version, publishes a GitHub release with that section as its notes and the built package attached, and uploads the same package to PyPI as `hone-python`.
 

{hone_python-0.9.0 → hone_python-0.10.0}/hone/__init__.py

@@ -10,7 +10,7 @@ from hone.optimizers import (
     UnsupportedSearchSpace,
     choose_optimizer,
 )
-from hone.parameters import ChoiceParameter, FixedParameter, RangeParameter, SearchSpace
+from hone.parameters import ChoiceParameter, Constraint, FixedParameter, InfeasibleSearchSpace, RangeParameter, SearchSpace
 from hone.result import GenerationStats, Progress, Result, RunInfo, print_progress
 
 __all__ = [
@@ -19,11 +19,13 @@ __all__ = [
     "CMAES",
     "CMAESConfig",
     "ChoiceParameter",
+    "Constraint",
     "EvaluationFailed",
     "FixedParameter",
     "GenerationStats",
     "GeneticOptimizer",
     "GeneticOptimizerConfig",
+    "InfeasibleSearchSpace",
     "Optimizer",
     "OptimizerConfig",
     "Progress",

{hone_python-0.9.0 → hone_python-0.10.0}/hone/benchmarks/__init__.py

@@ -1,4 +1,5 @@
 """Benchmark problems and a runner for comparing optimizers. Run `python -m hone.benchmarks --help`."""
+from .constrained import constrained_problems
 from .ml import ml_problems
 from .problems import Problem, noisy_problems, quick_problems, standard_problems
 from .runner import (

{hone_python-0.9.0 → hone_python-0.10.0}/hone/benchmarks/__main__.py

@@ -6,6 +6,7 @@ from collections.abc import Sequence
 from importlib.metadata import version
 
 from . import ml
+from .constrained import constrained_problems
 from .problems import noisy_problems, quick_problems, standard_problems
 from .runner import BUDGETS, load_summaries, regressions, run_benchmark, save_summaries, summarize, to_markdown
 
@@ -26,6 +27,7 @@ def main(argv: list[str] | None = None) -> int:
     suite.add_argument("--quick", action="store_true", help="run the small CI subset with fewer seeds and evaluations")
     suite.add_argument("--ml", action="store_true", help="run the machine learning tuning problems instead (needs scikit-learn)")
     suite.add_argument("--noisy", action="store_true", help="run the problems with noise added to every evaluation instead")
+    suite.add_argument("--constrained", action="store_true", help="run the problems with constraints instead")
     parser.add_argument("--seeds", type=int, help="number of seeds per problem (default 10, or 5 with --quick)")
     parser.add_argument(
         "--budgets",
@@ -49,6 +51,8 @@ def main(argv: list[str] | None = None) -> int:
         problems, default_budgets = ml.ml_problems(), ml.BUDGETS
     elif args.noisy:
         problems, default_budgets = noisy_problems(), NOISY_BUDGETS
+    elif args.constrained:
+        problems, default_budgets = constrained_problems(), BUDGETS
     else:
         problems, default_budgets = standard_problems(), BUDGETS
     seeds = args.seeds or (5 if args.quick else 10)

hone_python-0.10.0/hone/benchmarks/constrained.py

@@ -0,0 +1,172 @@
+"""Constrained test problems, whose optima lie on a constraint's boundary, as they usually do in engineering.
+
+- boundary-sphere and boundary-ellipsoid: a shifted sphere or ellipsoid with a linear constraint
+  that cuts off its unconstrained optimum, so the answer is on the cutting plane. Both optima are
+  known exactly.
+- rosenbrock-disk: Rosenbrock's function inside the disk x² + y² ≤ 2, whose optimum (1, 1) sits
+  on the disk's edge.
+- pressure-vessel, tension-spring and welded-beam: three standard engineering design problems,
+  scored against the best designs published for them. The welded beam's stress formulas need
+  square roots, so its constraints are functions; the others are expressions.
+"""
+import math
+import zlib
+from typing import Any
+
+import numpy as np
+
+from hone.parameters import Constraint, RangeParameter, SearchSpace
+
+from .problems import BOUND, Problem, _shift
+
+
+def _normal(name: str, dimensions: int) -> np.ndarray:
+    """A fixed unit vector for the named problem, with no component near zero."""
+    rng = np.random.default_rng(zlib.crc32(f"{name}/normal".encode()))
+    w = rng.uniform(0.3, 1.0, dimensions) * rng.choice([-1.0, 1.0], dimensions)
+    return w / np.linalg.norm(w)
+
+
+def _boundary(name: str, dimensions: int, weights: np.ndarray) -> Problem:
+    """Minimize sum(weights * (x - c)²) subject to w·x ≤ w·c - 1, which the unconstrained optimum c breaks.
+
+    The optimum is at c + z with z = -D⁻¹w / (wᵀD⁻¹w), where D is diag(weights), and its value is 1 / (wᵀD⁻¹w).
+    """
+    names = [f"x{i}" for i in range(dimensions)]
+    parameters = [RangeParameter(n, -BOUND, BOUND) for n in names]
+    centre, w = _shift(name, dimensions), _normal(name, dimensions)
+    limit = float(w @ centre) - 1.0
+    terms = [float(wi) * p for wi, p in zip(w, parameters)]
+    plane = terms[0]
+    for term in terms[1:]:
+        plane = plane + term
+    inverse = 1.0 / weights
+    best = centre - inverse * w / float(w @ (inverse * w))
+    assert np.all(np.abs(best) <= BOUND), f"{name}: the constrained optimum must lie inside the bounds"
+
+    def function(**params: Any) -> float:
+        x = np.array([params[n] for n in names], dtype=float)
+        return float(np.sum(weights * (x - centre) ** 2))
+
+    function.__name__ = name.replace("-", "_")
+    space = SearchSpace(parameters, [plane <= limit])
+    return Problem(name=name, function=function, search_space=space, optimum=1.0 / float(w @ (inverse * w)), tags=frozenset({"constrained"}))
+
+
+def boundary_sphere(dimensions: int) -> Problem:
+    return _boundary(f"boundary-sphere-{dimensions}d", dimensions, np.ones(dimensions))
+
+
+def boundary_ellipsoid(dimensions: int) -> Problem:
+    # Axis weights from 1 to 1,000: wide enough to need scaling, narrow enough to keep the optimum in bounds.
+    return _boundary(f"boundary-ellipsoid-{dimensions}d", dimensions, 10.0 ** (3 * np.arange(dimensions) / max(dimensions - 1, 1)))
+
+
+def rosenbrock_disk() -> Problem:
+    x, y = RangeParameter("x", -1.5, 1.5), RangeParameter("y", -1.5, 1.5)
+
+    def rosenbrock_disk(x: float, y: float) -> float:
+        return (1 - x) ** 2 + 100 * (y - x**2) ** 2
+
+    space = SearchSpace([x, y], [x**2 + y**2 <= 2])
+    return Problem(name="rosenbrock-disk-2d", function=rosenbrock_disk, search_space=space, optimum=0.0, tags=frozenset({"constrained"}))
+
+
+def pressure_vessel() -> Problem:
+    """A cylindrical vessel with hemispherical heads, at least 1,296,000 cubic inches, of least cost.
+
+    Shell and head thicknesses come in sixteenths of an inch, so they are integers here. The best
+    published design costs 6059.714 (Ts = 13/16, Th = 7/16, R = 42.098, L = 176.637).
+    """
+    shell, head = RangeParameter("shell", 1, 99, integer=True), RangeParameter("head", 1, 99, integer=True)
+    radius, length = RangeParameter("radius", 10, 200), RangeParameter("length", 10, 200)
+
+    def pressure_vessel(shell: int, head: int, radius: float, length: float) -> float:
+        ts, th = shell / 16, head / 16
+        return 0.6224 * ts * radius * length + 1.7781 * th * radius**2 + 3.1661 * ts**2 * length + 19.84 * ts**2 * radius
+
+    space = SearchSpace(
+        [shell, head, radius, length],
+        [
+            shell / 16 >= 0.0193 * radius,
+            head / 16 >= 0.00954 * radius,
+            math.pi * radius**2 * length + 4 / 3 * math.pi * radius**3 >= 1_296_000,
+        ],
+    )
+    return Problem(name="pressure-vessel", function=pressure_vessel, search_space=space, optimum=6059.714335, tags=frozenset({"constrained", "mixed", "engineering"}))
+
+
+def tension_spring() -> Problem:
+    """A coil spring of least weight under limits on deflection, shear stress, surge frequency and diameter.
+
+    The best published design weighs 0.0126652 (d = 0.051690, D = 0.356750, N = 11.287126).
+    """
+    d, coil, n = RangeParameter("wire", 0.05, 2.0), RangeParameter("coil", 0.25, 1.3), RangeParameter("turns", 2.0, 15.0)
+
+    def tension_spring(wire: float, coil: float, turns: float) -> float:
+        return (turns + 2) * coil * wire**2
+
+    space = SearchSpace(
+        [d, coil, n],
+        [
+            coil**3 * n / (71785 * d**4) >= 1,
+            (4 * coil**2 - d * coil) / (12566 * (coil * d**3 - d**4)) + 1 / (5108 * d**2) <= 1,
+            140.45 * d / (coil**2 * n) >= 1,
+            d + coil <= 1.5,
+        ],
+    )
+    return Problem(name="tension-spring", function=tension_spring, search_space=space, optimum=0.012665233, tags=frozenset({"constrained", "engineering"}))
+
+
+# The welded beam's load and material: load P (lb), length L (in), Young's and shear moduli (psi).
+P, L, E, G = 6000.0, 14.0, 30e6, 12e6
+
+
+def _shear(weld: float, length: float, thickness: float) -> float:
+    primary = P / (math.sqrt(2) * weld * length)
+    moment = P * (L + length / 2)
+    r = math.sqrt(length**2 / 4 + ((weld + thickness) / 2) ** 2)
+    j = 2 * math.sqrt(2) * weld * length * (length**2 / 12 + ((weld + thickness) / 2) ** 2)
+    secondary = moment * r / j
+    return math.sqrt(primary**2 + primary * secondary * length / r + secondary**2)
+
+
+def _buckling(thickness: float, width: float) -> float:
+    return 4.013 * E * math.sqrt(thickness**2 * width**6 / 36) / L**2 * (1 - thickness / (2 * L) * math.sqrt(E / (4 * G)))
+
+
+def welded_beam() -> Problem:
+    """A beam welded to a support, of least cost under limits on shear, bending, buckling and deflection.
+
+    The best published design costs 1.724852 (h = 0.205730, l = 3.470489, t = 9.036624, b = 0.205730).
+    """
+    weld, length = RangeParameter("weld", 0.1, 2.0), RangeParameter("length", 0.1, 10.0)
+    thickness, width = RangeParameter("thickness", 0.1, 10.0), RangeParameter("width", 0.1, 2.0)
+
+    def welded_beam(weld: float, length: float, thickness: float, width: float) -> float:
+        return 1.10471 * weld**2 * length + 0.04811 * thickness * width * (14 + length)
+
+    def shear(weld: float, length: float, thickness: float) -> float:
+        return _shear(weld, length, thickness) - 13600
+
+    def buckling(thickness: float, width: float) -> float:
+        return P - _buckling(thickness, width)
+
+    space = SearchSpace(
+        [weld, length, thickness, width],
+        [
+            Constraint.function(shear),
+            6 * P * L / (width * thickness**2) <= 30000,
+            weld <= width,
+            0.10471 * weld**2 + 0.04811 * thickness * width * (14 + length) <= 5,
+            4 * P * L**3 / (E * thickness**3 * width) <= 0.25,
+            Constraint.function(buckling),
+        ],
+    )
+    return Problem(name="welded-beam", function=welded_beam, search_space=space, optimum=1.724852, tags=frozenset({"constrained", "engineering"}))
+
+
+def constrained_problems(dimensions: tuple[int, ...] = (2, 5, 10)) -> list[Problem]:
+    """The constrained suite: boundary sphere and ellipsoid in each dimension, Rosenbrock in a disk, and three engineering designs."""
+    problems = [factory(d) for d in dimensions for factory in (boundary_sphere, boundary_ellipsoid)]
+    return problems + [rosenbrock_disk(), pressure_vessel(), tension_spring(), welded_beam()]

{hone_python-0.9.0 → hone_python-0.10.0}/hone/optimizers/base.py

@@ -77,6 +77,7 @@ class Optimizer(ABC):
             Fixed parameters may be left out.
     """
     config_class: ClassVar[type[OptimizerConfig]] = OptimizerConfig
+    supports_constraints: ClassVar[bool] = False  # whether it keeps to a search space's constraints
 
     def __init__(
         self,
@@ -91,9 +92,17 @@ class Optimizer(ABC):
         self.config = config if config is not None else self.config_class()
         if not isinstance(self.config, self.config_class):
             raise TypeError(f"{type(self).__name__} needs a {self.config_class.__name__}, got {type(self.config).__name__}")
+        if search_space.constraints and not self.supports_constraints:
+            raise UnsupportedSearchSpace(f"{type(self).__name__} doesn't support constraints yet; RandomSearch does")
         if isinstance(initial_points, dict):
             initial_points = [initial_points]
         self.initial_points = [search_space.check(point) for point in initial_points or []]
+        for point in self.initial_points:
+            if broken := search_space.broken(point):
+                raise ValueError(f"the initial point {point} breaks the constraint `{broken[0]}`")
+        if search_space.constraints and not self.initial_points:
+            # Fail now, before any evaluation, if the constraints leave nothing to search.
+            search_space.sample(np.random.default_rng(0))
         self._workers = 1  # how many evaluations run at once; optimizers may size their population from it
         self.reset()
 
@@ -297,7 +306,9 @@ class Optimizer(ABC):
 
         The file is replaced in one step, so a crash while saving leaves the previous checkpoint intact.
         """
-        state = dict(self.__dict__)
+        # The search space is left out: the loading optimizer has its own, which must match, and a
+        # constraint function may not be picklable.
+        state = {name: value for name, value in self.__dict__.items() if name != "search_space"}
         elapsed = self._elapsed() if self._start_clock is not None else None
         state.update(_start_clock=None, _end_clock=None, _workers=1)
         checkpoint = {

{hone_python-0.9.0 → hone_python-0.10.0}/hone/optimizers/bayesian.py

@@ -45,6 +45,7 @@ class BayesianOptimizer(Optimizer):
         initial_points: Points to evaluate first: one dict of parameter values, or a list of them.
     """
     config_class = BayesianConfig
+    supports_constraints = True
     config: BayesianConfig
 
     def __init__(
@@ -73,12 +74,12 @@ class BayesianOptimizer(Optimizer):
             count = self.config.initial_samples or 2 * (self._encoding.variables + 1)
             taken = {tuple(self._encoding.encode(ind.params)) for ind in initial}
             spread = []
-            for x in self._encoding.spread(self.rng, max(count - len(initial), 0)):
+            for x in self._feasible_spread(max(count - len(initial), 0)):
                 # Rounding integers can land two points on the same values; try others instead.
                 for _ in range(100):
                     if tuple(x) not in taken:
                         break
-                    x = self._encoding.spread(self.rng, 1)[0]
+                    x = self._feasible_spread(1)[0]
                 taken.add(tuple(x))
                 spread.append(x)
             return initial + [Individual(params=self._encoding.decode(x), generation=generation) for x in spread]
@@ -98,7 +99,7 @@ class BayesianOptimizer(Optimizer):
     def _propose(self, count: int) -> list[np.ndarray]:
         succeeded = [y for y in self._y if y is not None]
         if len(succeeded) < 2:
-            return list(self._encoding.spread(self.rng, count))
+            return list(self._feasible_spread(count))
         worst = max(succeeded)
         X = np.array(self._X)
         model = GaussianProcess(X, np.array([worst if y is None else y for y in self._y]), self._theta)
@@ -129,20 +130,40 @@ class BayesianOptimizer(Optimizer):
         scales = self.rng.choice([0.01, 0.05, 0.2], size=(LOCAL_CANDIDATES, 1))
         local = encoding.perturb(self.rng, local, scales)
         candidates = encoding.snap(np.vstack([encoding.spread(self.rng, GLOBAL_CANDIDATES), local]))
-        scores = _log_expected_improvement(model, candidates, best)
+        scores = self._only_feasible(candidates, _log_expected_improvement(model, candidates, best))
 
         columns = encoding.numeric
         if columns.size:
             starts = candidates[np.argsort(-scores)[:REFINED]]
             refined = encoding.snap(_refine(model, starts, columns, best))
             candidates = np.vstack([candidates, refined])
-            scores = np.append(scores, _log_expected_improvement(model, refined, best))
+            scores = np.append(scores, self._only_feasible(refined, _log_expected_improvement(model, refined, best)))
 
         seen = model.X
         for index in np.argsort(-scores):
+            if scores[index] == -np.inf and self.search_space.constraints:
+                break  # the rest break a constraint
             if not np.any(np.all(np.abs(seen - candidates[index]) < 1e-9, axis=1)):
                 return candidates[index]
-        return encoding.spread(self.rng, 1)[0]  # every candidate was already evaluated
+        return self._feasible_spread(1)[0]  # every feasible candidate was already evaluated
+
+    # --- constraints --------------------------------------------------------------
+
+    def _feasible_spread(self, count: int) -> np.ndarray:
+        """count points spread over the space, any that break a constraint replaced by random feasible points."""
+        X = self._encoding.spread(self.rng, count)
+        if self.search_space.constraints:
+            for i, x in enumerate(X):
+                if not self.search_space.feasible(self._encoding.decode(x)):
+                    X[i] = self._encoding.encode(self.search_space.sample(self.rng))
+        return X
+
+    def _only_feasible(self, X: np.ndarray, scores: np.ndarray) -> np.ndarray:
+        """scores, with those of points that break a constraint set to minus infinity."""
+        if not self.search_space.constraints:
+            return scores
+        feasible = np.array([self.search_space.feasible(self._encoding.decode(x)) for x in X], dtype=bool)
+        return np.where(feasible, scores, -np.inf)
 
 
 def _refine(model: GaussianProcess, starts: np.ndarray, columns: np.ndarray, best: float) -> np.ndarray:
@@ -187,7 +208,7 @@ class _Encoding:
     """Between parameter values and points in [0, 1]^columns, where the model works."""
 
     def __init__(self, search_space: SearchSpace) -> None:
-        self.search_space = search_space
+        self.names = search_space.names  # not the search space itself, whose function constraints may not pickle
         self._blocks: list[tuple[RangeParameter | ChoiceParameter, slice]] = []
         self._constant: dict[str, Any] = {}
         column = 0
@@ -228,7 +249,7 @@ class _Encoding:
                 values[p.name] = p.from_unit(float(x[block][0]))
             else:
                 values[p.name] = p.choices[int(np.argmax(x[block]))]
-        return {name: values[name] for name in self.search_space.names}
+        return {name: values[name] for name in self.names}
 
     def snap(self, X: np.ndarray) -> np.ndarray:
         """Each row moved to the nearest point that parameter values can take: whole integers and one choice per block."""

{hone_python-0.9.0 → hone_python-0.10.0}/hone/optimizers/cmaes.py

@@ -27,6 +27,7 @@ INTEGER_SPREAD = 0.25  # minimum standard deviation of an integer variable, in i
 MAX_CONDITION = 1e14  # restart when the covariance matrix is this badly conditioned
 MIN_STEP = 1e-12  # restart when every continuous step, in [0, 1] units, falls below this
 FLAT = 1e-12  # restart when recent generations' best values differ by less than this
+RESAMPLES = 100  # draws from the distribution for a feasible candidate before falling back to a random feasible point
 
 
 class CMAES(Optimizer):
@@ -50,6 +51,7 @@ class CMAES(Optimizer):
         initial_points: Points to evaluate first: one dict of parameter values, or a list of them.
     """
     config_class = CMAESConfig
+    supports_constraints = True
     config: CMAESConfig
 
     def __init__(
@@ -137,10 +139,28 @@ class CMAES(Optimizer):
         self._widen = np.where(spread < minimum, minimum / np.maximum(spread, 1e-300), 1.0)
         return [self._sample(generation) for _ in range(self.population_size)]
 
-    def _sample(self, generation: int) -> Individual:
+    def _draw(self) -> np.ndarray:
         z = self.rng.standard_normal(len(self._mean))
-        x = _mirror(self._mean + self._sigma * self._widen * (self._B @ (self._D * z)))
-        individual = Individual(params=self._decode(x), generation=generation)
+        return _mirror(self._mean + self._sigma * self._widen * (self._B @ (self._D * z)))
+
+    def _sample(self, generation: int) -> Individual:
+        """A candidate from the search distribution, drawn again while it breaks a constraint.
+
+        Redrawing did better on the constrained benchmark than ranking infeasible candidates
+        below every feasible one without evaluating them.
+        """
+        x = self._draw()
+        params = self._decode(x)
+        if self.search_space.constraints and not self.search_space.feasible(params):
+            for _ in range(RESAMPLES):
+                x = self._draw()
+                params = self._decode(x)
+                if self.search_space.feasible(params):
+                    break
+            else:
+                params = self.search_space.sample(self.rng)
+                x = self._encode(params)
+        individual = Individual(params=params, generation=generation)
         self._vectors[individual] = x
         return individual
 

{hone_python-0.9.0 → hone_python-0.10.0}/hone/optimizers/genetic/optimizer.py

@@ -17,6 +17,8 @@ MIN_STEP = 1e-9
 MAX_STEP = 0.5
 # A child that repeats a point already asked for is mutated again, one gene at a time, up to this many times.
 REPEAT_TRIES = 10
+# A child that breaks a constraint is moved halfway back toward its fitter parent this many times.
+REPAIR_STEPS = 10
 
 
 class GeneticOptimizer(Optimizer):
@@ -61,6 +63,7 @@ class GeneticOptimizer(Optimizer):
         >>> result = optimizer.optimize(objective_function)
     """
     config_class = GeneticOptimizerConfig
+    supports_constraints = True
     config: GeneticOptimizerConfig
 
     def reset(self) -> None:
@@ -95,7 +98,46 @@ class GeneticOptimizer(Optimizer):
         return select(individuals, self.rng, maximize=self.config.maximize)
 
     def _child(self, parents: list[Individual], generation: int, niche: dict | None = None) -> Individual:
-        """A child of two parents selected from parents. A niche fixes the child's choice parameters."""
+        """A child of two parents selected from parents. A niche fixes the child's choice parameters.
+
+        A child that breaks a constraint is repaired: moved toward the fitter of its parents,
+        which satisfies every constraint, by halving the gap REPAIR_STEPS times and keeping the
+        last point inside. Its numbers end up near the constraint's boundary, where optima
+        under constraints usually are.
+        """
+        child, first, second = self._bred(parents, generation, niche)
+        if self.search_space.feasible(child.params):
+            return child
+        fitter = first if (_fitness(first) > _fitness(second)) == self.config.maximize else second
+        return self._repaired(child, fitter, generation)
+
+    def _repaired(self, child: Individual, anchor: Individual, generation: int) -> Individual:
+        inside, outside = dict(anchor.params), dict(child.params)
+        if not self.search_space.feasible(inside):
+            inside = self.search_space.sample(self.rng)  # can't happen: every evaluated point is feasible
+        for _ in range(REPAIR_STEPS):
+            middle = self._between(inside, outside)
+            if self.search_space.feasible(middle):
+                inside = middle
+            else:
+                outside = middle
+        repaired = Individual(params=inside, generation=generation)
+        if child in self._steps:
+            self._steps[repaired] = self._steps.pop(child)
+        return repaired
+
+    def _between(self, inside: dict, outside: dict) -> dict:
+        """The midpoint of two points, in each range's unit scale; other values are taken from inside."""
+        middle = dict(inside)
+        for parameter in self.search_space.parameters:
+            if isinstance(parameter, RangeParameter) and parameter.maximum > parameter.minimum:
+                unit = (float(parameter.to_unit(inside[parameter.name])) + float(parameter.to_unit(outside[parameter.name]))) / 2
+                value = parameter.from_unit(unit)
+                middle[parameter.name] = int(value) if parameter.integer else float(value)
+        return middle
+
+    def _bred(self, parents: list[Individual], generation: int, niche: dict | None) -> tuple[Individual, Individual, Individual]:
+        """A child bred from two parents selected from parents, and the parents."""
         first, second = self._select(parents), self._select(parents)
         if self.config.blend_crossover:
             params = blend_crossover(
@@ -114,7 +156,7 @@ class GeneticOptimizer(Optimizer):
         child = Individual(params=params, generation=generation)
         if self._adaptive:
             self._steps[child] = step
-        return child
+        return child, first, second
 
     def _new_point(self, params: dict, step: float, niche: dict | None) -> dict:
         """params, mutated again a gene at a time while they repeat a point already asked for.

{hone_python-0.9.0 → hone_python-0.10.0}/hone/optimizers/random_search.py

@@ -7,6 +7,7 @@ class RandomSearch(Optimizer):
     Useful as a baseline: a smarter optimizer should beat it for the same number of evaluations.
     Any initial points take the place of random points in the first generation.
     """
+    supports_constraints = True
 
     def _next_population(self, previous: list[Individual] | None, generation: int) -> list[Individual]:
         initial = self._initial_individuals(generation) if previous is None else []

{hone_python-0.9.0 → hone_python-0.10.0}/hone/parameters/__init__.py

@@ -1 +1,2 @@
+from .constraints import Constraint, InfeasibleSearchSpace
 from .parameters import ChoiceParameter, FixedParameter, Parameter, RangeParameter, SearchSpace

hone_python-0.10.0/hone/parameters/constraints.py

@@ -0,0 +1,318 @@
+"""Constraints on a search space: limits that every point an optimizer asks for must satisfy.
+
+An expression is built from range parameters and numbers with ordinary arithmetic, and comparing
+it with <= or >= makes a constraint:
+
+    width * height <= 40
+
+Expressions are pydantic models, so a search space with constraints saves and loads like any other.
+Constraint.function covers what an expression can't say, at the cost of not being saved.
+"""
+import inspect
+import math
+import numbers
+from typing import Annotated, Any, Callable, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+TOLERANCE = 1e-9  # a point this close to a limit, relative to the limit's size, satisfies it
+
+_PRECEDENCE = {"+": 1, "-": 1, "*": 2, "/": 2, "neg": 3, "**": 4}
+
+
+class _Arithmetic:
+    """Arithmetic and comparison for anything that can stand in an expression: range parameters and expressions."""
+
+    def _as_term(self) -> "Term":
+        raise NotImplementedError
+
+    def __add__(self, other: Any) -> "BinaryOp":
+        return BinaryOp(op="+", left=self._as_term(), right=_term(other))
+
+    def __radd__(self, other: Any) -> "BinaryOp":
+        return BinaryOp(op="+", left=_term(other), right=self._as_term())
+
+    def __sub__(self, other: Any) -> "BinaryOp":
+        return BinaryOp(op="-", left=self._as_term(), right=_term(other))
+
+    def __rsub__(self, other: Any) -> "BinaryOp":
+        return BinaryOp(op="-", left=_term(other), right=self._as_term())
+
+    def __mul__(self, other: Any) -> "BinaryOp":
+        return BinaryOp(op="*", left=self._as_term(), right=_term(other))
+
+    def __rmul__(self, other: Any) -> "BinaryOp":
+        return BinaryOp(op="*", left=_term(other), right=self._as_term())
+
+    def __truediv__(self, other: Any) -> "BinaryOp":
+        return BinaryOp(op="/", left=self._as_term(), right=_term(other))
+
+    def __rtruediv__(self, other: Any) -> "BinaryOp":
+        return BinaryOp(op="/", left=_term(other), right=self._as_term())
+
+    def __pow__(self, other: Any) -> "BinaryOp":
+        return BinaryOp(op="**", left=self._as_term(), right=_term(other))
+
+    def __rpow__(self, other: Any) -> "BinaryOp":
+        return BinaryOp(op="**", left=_term(other), right=self._as_term())
+
+    def __neg__(self) -> "UnaryOp":
+        return UnaryOp(op="neg", operand=self._as_term())
+
+    def __abs__(self) -> "UnaryOp":
+        return UnaryOp(op="abs", operand=self._as_term())
+
+    # < and > mean the same as <= and >=: for numbers searched continuously the difference has no effect.
+    def __le__(self, other: Any) -> "ExpressionConstraint":
+        return ExpressionConstraint(left=self._as_term(), op="<=", right=_term(other))
+
+    def __ge__(self, other: Any) -> "ExpressionConstraint":
+        return ExpressionConstraint(left=self._as_term(), op=">=", right=_term(other))
+
+    __lt__ = __le__
+    __gt__ = __ge__
+
+
+def _term(value: Any) -> "Term":
+    if isinstance(value, _Arithmetic):
+        return value._as_term()
+    if isinstance(value, numbers.Real) and not isinstance(value, bool):
+        return Number(value=float(value))
+    raise TypeError(
+        f"constraints are built from range parameters and numbers, not {value!r}; "
+        "for anything else, such as choice parameters, use Constraint.function"
+    )
+
+
+class _Term(_Arithmetic, BaseModel):
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    def _as_term(self) -> "Term":
+        return self  # type: ignore[return-value]
+
+    def evaluate(self, params: dict[str, Any]) -> float:
+        """The expression's value at params."""
+        raise NotImplementedError
+
+    def names(self) -> set[str]:
+        """The parameters the expression uses."""
+        raise NotImplementedError
+
+    def _precedence(self) -> int:
+        return 5
+
+    def __str__(self) -> str:
+        raise NotImplementedError
+
+
+class Variable(_Term):
+    """A range parameter's value, by name."""
+    kind: Literal["variable"] = "variable"
+    name: str
+
+    def evaluate(self, params: dict[str, Any]) -> float:
+        return float(params[self.name])
+
+    def names(self) -> set[str]:
+        return {self.name}
+
+    def __str__(self) -> str:
+        return self.name
+
+
+class Number(_Term):
+    kind: Literal["number"] = "number"
+    value: float
+
+    def evaluate(self, params: dict[str, Any]) -> float:
+        return self.value
+
+    def names(self) -> set[str]:
+        return set()
+
+    def __str__(self) -> str:
+        return repr(int(self.value)) if self.value.is_integer() and abs(self.value) < 1e15 else repr(self.value)
+
+
+class BinaryOp(_Term):
+    kind: Literal["binary"] = "binary"
+    op: Literal["+", "-", "*", "/", "**"]
+    left: "Term"
+    right: "Term"
+
+    def evaluate(self, params: dict[str, Any]) -> float:
+        a, b = self.left.evaluate(params), self.right.evaluate(params)
+        match self.op:
+            case "+":
+                return a + b
+            case "-":
+                return a - b
+            case "*":
+                return a * b
+            case "/":
+                return a / b
+            case "**":
+                return a**b
+
+    def names(self) -> set[str]:
+        return self.left.names() | self.right.names()
+
+    def _precedence(self) -> int:
+        return _PRECEDENCE[self.op]
+
+    def __str__(self) -> str:
+        mine = self._precedence()
+        # ** groups to the right, the others to the left, so the other side needs brackets at equal precedence.
+        left_brackets = self.left._precedence() < mine or (self.op == "**" and self.left._precedence() == mine)
+        right_brackets = self.right._precedence() < mine or (self.op in ("-", "/") and self.right._precedence() == mine)
+        left = f"({self.left})" if left_brackets else str(self.left)
+        right = f"({self.right})" if right_brackets else str(self.right)
+        return f"{left} {self.op} {right}"
+
+
+class UnaryOp(_Term):
+    kind: Literal["unary"] = "unary"
+    op: Literal["neg", "abs"]
+    operand: "Term"
+
+    def evaluate(self, params: dict[str, Any]) -> float:
+        value = self.operand.evaluate(params)
+        return -value if self.op == "neg" else abs(value)
+
+    def names(self) -> set[str]:
+        return self.operand.names()
+
+    def _precedence(self) -> int:
+        return _PRECEDENCE["neg"] if self.op == "neg" else 5
+
+    def __str__(self) -> str:
+        if self.op == "abs":
+            return f"abs({self.operand})"
+        return f"-({self.operand})" if self.operand._precedence() < self._precedence() else f"-{self.operand}"
+
+
+type Term = Annotated[Variable | Number | BinaryOp | UnaryOp, Field(discriminator="kind")]
+
+
+class Constraint(BaseModel):
+    """A limit every point an optimizer asks for must satisfy.
+
+    Build one by comparing an expression of range parameters with <= or >=, such as
+    `width * height <= 40`, or with Constraint.function for anything an expression can't say.
+    """
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    def violation(self, params: dict[str, Any]) -> float:
+        """How far params break the constraint: 0 when they satisfy it, infinity when it can't be computed."""
+        raise NotImplementedError
+
+    def satisfied(self, params: dict[str, Any]) -> bool:
+        return self.violation(params) == 0
+
+    def names(self) -> set[str]:
+        """The parameters the constraint uses."""
+        raise NotImplementedError
+
+    def __bool__(self) -> bool:
+        raise TypeError(
+            f"the constraint `{self}` has no truth value. A chained comparison such as `0 <= x + y <= 10` "
+            "keeps only one half; write two constraints, `x + y >= 0` and `x + y <= 10`"
+        )
+
+    @staticmethod
+    def function(function: Callable[..., float], name: str | None = None) -> "FunctionConstraint":
+        """A constraint computed by function, which is satisfied when it returns zero or less.
+
+        The function takes parameters by name, like an objective function, and may take only
+        some of them. It can use anything, such as square roots or choice parameters, but it
+        isn't saved with the search space: a run record stores only its name.
+        """
+        return FunctionConstraint(name=name or getattr(function, "__name__", "constraint"), func=function)
+
+
+def _limit(value: float, scale: float) -> float:
+    """value as a violation: 0 within the tolerance, infinity when it couldn't be computed."""
+    if isinstance(value, complex) or math.isnan(value):
+        return math.inf
+    return 0.0 if value <= TOLERANCE * max(1.0, abs(scale)) else float(value)
+
+
+class ExpressionConstraint(Constraint):
+    """An expression compared with another: left <= right, or left >= right."""
+    kind: Literal["expression"] = "expression"
+    left: Term
+    op: Literal["<=", ">="]
+    right: Term
+
+    def violation(self, params: dict[str, Any]) -> float:
+        try:
+            left, right = self.left.evaluate(params), self.right.evaluate(params)
+        except (ArithmeticError, ValueError):
+            return math.inf  # division by zero, or an overflow: the point can't be judged, so it isn't allowed
+        if isinstance(left, complex) or isinstance(right, complex):
+            return math.inf  # a negative number to a fractional power
+        return _limit(left - right if self.op == "<=" else right - left, right)
+
+    def names(self) -> set[str]:
+        return self.left.names() | self.right.names()
+
+    def __str__(self) -> str:
+        return f"{self.left} {self.op} {self.right}"
+
+
+class FunctionConstraint(Constraint):
+    """A constraint computed by a function of the parameters: satisfied when it returns zero or less."""
+    kind: Literal["function"] = "function"
+    name: str
+    func: Callable[..., float] | None = Field(default=None, exclude=True)  # not saved; None once loaded
+
+    def violation(self, params: dict[str, Any]) -> float:
+        if self.func is None:
+            raise ValueError(
+                f"the constraint {self.name!r} was loaded without its function, which can't be saved; "
+                "pass it again, such as with rebuild_optimizer(functions=...)"
+            )
+        signature = inspect.signature(self.func)
+        if any(p.kind is inspect.Parameter.VAR_KEYWORD for p in signature.parameters.values()):
+            arguments = params
+        else:
+            arguments = {name: value for name, value in params.items() if name in signature.parameters}
+        value = self.func(**arguments)
+        if isinstance(value, bool) or not isinstance(value, numbers.Real):
+            raise TypeError(f"the constraint {self.name!r} must return a number, but returned {value!r}")
+        return _limit(float(value), 0.0)
+
+    def names(self) -> set[str]:
+        if self.func is None:
+            return set()
+        signature = inspect.signature(self.func)
+        return {
+            name
+            for name, p in signature.parameters.items()
+            if p.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY)
+        }
+
+    def required(self) -> set[str]:
+        """The parameters the function can't be called without."""
+        if self.func is None:
+            return set()
+        return {
+            name
+            for name, p in inspect.signature(self.func).parameters.items()
+            if p.default is inspect.Parameter.empty
+            and p.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY)
+        }
+
+    def __str__(self) -> str:
+        return self.name
+
+
+type AnyConstraint = Annotated[ExpressionConstraint | FunctionConstraint, Field(discriminator="kind")]
+
+
+class InfeasibleSearchSpace(ValueError):
+    """No point satisfying every constraint could be found."""
+
+
+BinaryOp.model_rebuild()
+UnaryOp.model_rebuild()

{hone_python-0.9.0 → hone_python-0.10.0}/hone/parameters/parameters.py

@@ -6,6 +6,8 @@ from typing import Annotated, Any, Literal
 import numpy as np
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
+from .constraints import AnyConstraint, ExpressionConstraint, FunctionConstraint, InfeasibleSearchSpace, Variable, _Arithmetic
+
 type Value = float | int | str
 
 
@@ -20,7 +22,7 @@ class _Parameter(BaseModel):
         super().__init__(**data)
 
 
-class RangeParameter(_Parameter):
+class RangeParameter(_Arithmetic, _Parameter):
     """A number between minimum and maximum, optionally restricted to integers.
 
     With log=True the range is searched on a logarithmic scale: values are drawn evenly in
@@ -37,6 +39,9 @@ class RangeParameter(_Parameter):
     def __init__(self, name: str, minimum: float, maximum: float, **data: Any) -> None:
         super().__init__(name=name, minimum=minimum, maximum=maximum, **data)
 
+    def _as_term(self) -> Variable:
+        return Variable(name=self.name)
+
     @model_validator(mode="after")
     def _check_bounds(self):
         if self.minimum > self.maximum:
@@ -185,14 +190,22 @@ class ChoiceParameter(_Parameter):
 type Parameter = Annotated[RangeParameter | FixedParameter | ChoiceParameter, Field(discriminator="kind")]
 
 
+MAX_DRAWS = 100_000  # draws in a row without a feasible point before a search space counts as infeasible
+
+
 class SearchSpace(BaseModel):
-    """The set of parameters an objective function is optimized over."""
+    """The set of parameters an objective function is optimized over, and any constraints on them.
+
+    Every point an optimizer asks for satisfies every constraint, so the objective is never
+    evaluated where a constraint rules it out.
+    """
     model_config = ConfigDict(extra="forbid", frozen=True)
 
     parameters: list[Parameter] = Field(min_length=1)
+    constraints: list[AnyConstraint] = Field(default_factory=list)
 
-    def __init__(self, parameters: Sequence[Parameter], **data: Any) -> None:
-        super().__init__(parameters=list(parameters), **data)
+    def __init__(self, parameters: Sequence[Parameter], constraints: Sequence[AnyConstraint] = (), **data: Any) -> None:
+        super().__init__(parameters=list(parameters), constraints=list(constraints), **data)
 
     @model_validator(mode="after")
     def _check_unique_names(self):
@@ -202,13 +215,68 @@ class SearchSpace(BaseModel):
             raise ValueError(f"each parameter needs a unique name; repeated: {', '.join(duplicates)}")
         return self
 
+    @model_validator(mode="after")
+    def _check_constraints(self):
+        by_name = {parameter.name: parameter for parameter in self.parameters}
+        for constraint in self.constraints:
+            if isinstance(constraint, ExpressionConstraint):
+                for name in sorted(constraint.names()):
+                    if name not in by_name:
+                        raise ValueError(f"the constraint `{constraint}` uses {name!r}, which isn't a parameter of this search space")
+                    if not isinstance(by_name[name], RangeParameter):
+                        raise ValueError(
+                            f"the constraint `{constraint}` uses {name!r}, which isn't a range parameter; "
+                            "use Constraint.function for constraints on other kinds"
+                        )
+            elif isinstance(constraint, FunctionConstraint):
+                missing = sorted(constraint.required() - set(by_name))
+                if missing:
+                    raise ValueError(f"the constraint {constraint.name!r} needs parameters missing from the search space: {', '.join(missing)}")
+        return self
+
     @property
     def names(self) -> list[str]:
         return [parameter.name for parameter in self.parameters]
 
     def sample(self, rng: np.random.Generator) -> dict[str, Any]:
-        """Draw one value for every parameter."""
-        return {parameter.name: parameter.sample(rng) for parameter in self.parameters}
+        """Draw one value for every parameter, at a point that satisfies every constraint.
+
+        Points are drawn until one is feasible. Raises InfeasibleSearchSpace after MAX_DRAWS
+        draws in a row without one.
+        """
+        for _ in range(MAX_DRAWS if self.constraints else 1):
+            point = {parameter.name: parameter.sample(rng) for parameter in self.parameters}
+            if self.feasible(point):
+                return point
+        raise InfeasibleSearchSpace(
+            f"no point satisfying every constraint was found in {MAX_DRAWS:,} random draws: the constraints may "
+            "contradict each other, or leave too small a region to sample"
+        )
+
+    def with_functions(self, functions: dict[str, Any]) -> "SearchSpace":
+        """This search space with function constraints given their functions by name, as after loading one.
+
+        Raises ValueError if a function constraint is left without one.
+        """
+        constraints: list[AnyConstraint] = []
+        for constraint in self.constraints:
+            if isinstance(constraint, FunctionConstraint) and constraint.name in functions:
+                constraint = constraint.model_copy(update={"func": functions[constraint.name]})
+            if isinstance(constraint, FunctionConstraint) and constraint.func is None:
+                raise ValueError(f"the constraint {constraint.name!r} needs its function, which isn't saved; pass it in functions")
+            constraints.append(constraint)
+        unknown = sorted(set(functions) - {c.name for c in self.constraints if isinstance(c, FunctionConstraint)})
+        if unknown:
+            raise ValueError(f"no function constraint is named {', '.join(map(repr, unknown))}")
+        return SearchSpace(self.parameters, constraints)
+
+    def feasible(self, params: dict[str, Any]) -> bool:
+        """Whether params satisfy every constraint."""
+        return all(constraint.satisfied(params) for constraint in self.constraints)
+
+    def broken(self, params: dict[str, Any]) -> list[AnyConstraint]:
+        """The constraints params don't satisfy."""
+        return [constraint for constraint in self.constraints if not constraint.satisfied(params)]
 
     def check(self, params: dict[str, Any]) -> dict[str, Any]:
         """params as a complete point of this space, in parameter order, or ValueError if they aren't one.

{hone_python-0.9.0 → hone_python-0.10.0}/hone/result.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Self
+from typing import TYPE_CHECKING, Any, Callable, Self
 
 from pydantic import BaseModel, ConfigDict
 
@@ -89,12 +89,17 @@ class Result(BaseModel):
             return NotImplemented
         return self.model_dump(exclude={"run"}) == other.model_dump(exclude={"run"})
 
-    def rebuild_optimizer(self, optimizer_class: "type[Optimizer] | None" = None) -> "Optimizer":
+    def rebuild_optimizer(
+        self, optimizer_class: "type[Optimizer] | None" = None, *, functions: dict[str, Callable[..., float]] | None = None
+    ) -> "Optimizer":
         """A new optimizer set up exactly as this result's was, to repeat or extend the run.
 
         Running it gives the same result, given the same objective and, for CMA-ES and
         Bayesian optimization, the same number of workers (run.workers). An optimizer that
         isn't one of hone's own is rebuilt by passing its class.
+
+        A constraint made with Constraint.function isn't saved with a result: after loading
+        one, pass each such constraint's function by name, as functions={"stress": stress}.
         """
         from hone import optimizers
 
@@ -108,7 +113,7 @@ class Result(BaseModel):
                 raise ValueError(f"{self.run.optimizer} isn't one of hone's optimizers; pass its class to rebuild it")
             optimizer_class = builtin[self.run.optimizer]
         config = optimizer_class.config_class.model_validate(self.run.config)
-        return optimizer_class(self.run.search_space, config, initial_points=self.run.initial_points or None)
+        return optimizer_class(self.run.search_space.with_functions(functions or {}), config, initial_points=self.run.initial_points or None)
 
     def save(self, filepath: str | Path) -> None:
         Path(filepath).write_text(self.model_dump_json(indent=2))

{hone_python-0.9.0 → hone_python-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hone-python"
-version = "0.9.0"
+version = "0.10.0"
 description = "A python-based optimization engine/library."
 authors = [{ name = "David Beare", email = "rnbeare@gmail.com" }]
 readme = "README.md"