polyblocks 0.2.0__tar.gz → 0.3.0__tar.gz

{polyblocks-0.2.0 → polyblocks-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyblocks
-Version: 0.2.0
+Version: 0.3.0
 Summary: Solvers for global monotonic optimisation problems
 Author: Ahmed Rashwan
 Author-email: Ahmed Rashwan <ar3009@bath.ac.uk>

{polyblocks-0.2.0 → polyblocks-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "polyblocks"
-version = "0.2.0"
+version = "0.3.0"
 description = "Solvers for global monotonic optimisation problems"
 readme = "README.md"
 requires-python = ">=3.11"

{polyblocks-0.2.0 → polyblocks-0.3.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "polyblocks"
-version = "0.2.0"
+version = "0.3.0"
 description = "Solvers for global monotonic optimisation problems"
 readme = "README.md"
 authors = [

{polyblocks-0.2.0 → polyblocks-0.3.0}/src/polyblocks/abstract.py

@@ -60,7 +60,7 @@ class ABPolyblock(ABC):
     """
     An abstract class for custom implementations of the Polyblock Outer-approximation (POA) algorithm.
 
-    POA maximises an increasing objective over `G ∩ H ∩ [x_l, x_u]`, where `G` is a normal set given by `ub_oracle` and `H` a co-normal set given by `lb_oracle`.
+    POA maximises an increasing objective over `G ∩ H ∩ [x_l, x_u]`, where `G` is a normal set given by `ub_oracle`, `H` a co-normal set given by `lb_oracle`, and `x_l < x_u`.
     It does so by maintaining a *polyblock*: a finite vertex set `V` whose union of boxes `(-inf, v]` contains every feasible point which could still improve the incumbent.
     Each iteration projects vertices of `V` onto the boundary of `G` and cuts the
     infeasible cone strictly above each projection out of the polyblock, so the outer-approximation tightens until `V` empties and the incumbent is certified optimal.
@@ -83,7 +83,7 @@ class ABPolyblock(ABC):
     POLYBLOCK_LIMIT = 2 * int(1e8)
 
     @abstractmethod
-    def __init__(self, lower: NDArray, upper: NDArray) -> None:
+    def __init__(self, lower: NDArray, upper: NDArray, upper_obj: np.floating) -> None:
         """
         Initialises polyblock representation using lower and upper points which define the feasible rectangle.
 
@@ -92,6 +92,7 @@ class ABPolyblock(ABC):
         Args:
             lower: Lower point of the feasible rectangle, of shape `(dim,)`.
             upper: Upper point of the feasible rectangle, of shape `(dim,)`.
+            upper_obj: Objective value of the upper point.
         """
 
     @abstractmethod
@@ -223,7 +224,7 @@ class ABPolyblock(ABC):
             The best solution found, see `Solution`. Note that `success` reports whether the solver terminated on its own certificate rather than a limit, so it is also set when the problem is proven infeasible.
 
         Raises:
-            ValueError: If `x_u` is smaller than `x_l` in any coordinate.
+            ValueError: If `x_u` is not greater than `x_l` in each coordinate.
         """
 
         lb_exists = lb_oracle is not None
@@ -234,8 +235,8 @@ class ABPolyblock(ABC):
 
         ## initial checks
         x_l, x_u = np.broadcast_arrays(x_l, x_u)
-        if (x_u - x_l < 0).any():
-            raise ValueError("`x_u` must be no smaller than `x_l` element-wise.")
+        if (x_u <= x_l).any():
+            raise ValueError("`x_u` must be greater than `x_l` element-wise.")
         elif not ub_oracle(x_l[None]):
             sol.success = True
             sol.status = Status.INFEASIBLE_X_L
@@ -248,7 +249,7 @@ class ABPolyblock(ABC):
         x_l = tighten(x_u, x_l, oracle=lb_oracle) if lb_exists else x_l.copy()
 
         mono_proj = partial(monotone_proj, oracle=ub_oracle, eps=eps_ls, delta=delta)
-        polyblock = cls(x_l, x_u)
+        polyblock = cls(x_l, x_u, obj(x_u[None])[0])
         min_obj = -np.inf
 
         ## main loop

{polyblocks-0.2.0 → polyblocks-0.3.0}/src/polyblocks/containers.py

@@ -13,10 +13,10 @@ class DynamicArray:
 
     __slots__ = ("data", "length")
 
-    def __init__(self, dim=1, dtype: DTypeLike = float, start_sz=100):
-        """Initialise dynamic container consisting of `dim` dimensional vectors of type `dtype`"""
+    def __init__(self, dim=1, dtype: DTypeLike = float, start_sz=100, keepdims=False):
+        """Initialise dynamic container consisting of `dim` dimensional vectors of type `dtype`. Flattens array when `dim` is 1 and `keepdims` is False."""
 
-        size = (start_sz,) if dim == 1 else (start_sz, dim)
+        size = (start_sz,) if dim == 1 and not keepdims else (start_sz, dim)
         self.data = np.empty(size, dtype=dtype)
         self.length = 0
 
@@ -65,8 +65,12 @@ class Tree:
     IDX_TYPE = np.int32
     COMPONENT_TYPE = np.int8
 
-    def __init__(self, first: NDArray[np.float32 | np.float64]):
-        """Initialise tree using the root node vertex."""
+    def __init__(
+        self,
+        first: NDArray[np.float32 | np.float64],
+        upper_obj: np.float32 | np.float64,
+    ):
+        """Initialise tree using the root node vertex and its objective value."""
 
         self.first = first
 
@@ -81,7 +85,7 @@ class Tree:
 
         ## add first points
         self.idx_range.append([-1, -1])
-        self.cvo.append((-1, -1, np.inf))
+        self.cvo.append((-1, -1, upper_obj))
         self.parent.append(-1)
 
     def query(self, x: NDArray, lower: NDArray, min_obj=-np.inf, delta=1e-3) -> tuple:

{polyblocks-0.2.0 → polyblocks-0.3.0}/src/polyblocks/naive.py

@@ -1,4 +1,3 @@
-import numpy as np
 from numpy.typing import NDArray
 
 from .abstract import ABPolyblock
@@ -12,17 +11,19 @@ class BasePOA(ABPolyblock):
     POLYBLOCK_LIMIT = 3 * int(1e6)
     RHO = 0.2
 
-    def __init__(self, lower, upper):
+    def __init__(self, lower, upper, upper_obj):
         self.lower = lower
         const = self.RHO / (1 - self.RHO)
         self.lower_offset = lower - const * (upper - lower).max()
         self.lower_offset = self.lower_offset[None]
         self.new: NDArray
 
-        self.vertices = DynamicArray(dim=lower.shape[0], dtype=lower.dtype)
+        self.vertices = DynamicArray(
+            dim=lower.shape[0], dtype=lower.dtype, keepdims=True
+        )
         self.obj_vals = DynamicArray(dim=1, dtype=lower.dtype)
         self.vertices.append(upper)
-        self.obj_vals.append(np.inf)
+        self.obj_vals.append(upper_obj)
 
     def projection_pairs(self) -> tuple[NDArray, NDArray]:
         best_vtx = self.obj_vals.array.argmax()

{polyblocks-0.2.0 → polyblocks-0.3.0}/src/polyblocks/tree.py

@@ -35,9 +35,9 @@ class TreePOA(ABPolyblock):
     REBUILD_GAP: int = 10000
     PROJECTED_VERTICES: int = 8
 
-    def __init__(self, lower, upper) -> None:
+    def __init__(self, lower, upper, upper_obj) -> None:
         self.lower = lower
-        self.tree = Tree(upper)
+        self.tree = Tree(upper, upper_obj)
         self.best_obj = -np.inf
         self.clean_counter = 0
 

{polyblocks-0.2.0 → polyblocks-0.3.0}/src/polyblocks/utils.py

@@ -7,8 +7,8 @@ from numpy.typing import NDArray
 
 
 def monotone_proj(
-    vertices: NDArray,
     anchors: NDArray,
+    vertices: NDArray,
     oracle: Callable,
     eps=1e-4,
     delta=0.0,
@@ -17,8 +17,8 @@ def monotone_proj(
     Perform a vectorised bisection search to compute monotone projections onto the `delta`-eroded normal set corresponding to the given oracle.
 
     Args:
-        vertices: Vertices to project using paired anchors, of shape `(num_pairs, dim)`.
         anchors: Feasible anchor points for projecting paired vertex, of shape `(num_pairs, dim)`. Shifted by `delta` to account for erosion.
+        vertices: Vertices to project using paired anchors, of shape `(num_pairs, dim)`.
         oracle: An oracle for querying normal set feasibility.
         eps: The numerical tolerance for the line search.
         delta: The erosion factor for the normal set.
@@ -27,37 +27,34 @@ def monotone_proj(
         Batched monotone projections of shape `(num_pairs, dim)`.
     """
 
-    ## resolve erosion
-    vert_offset = vertices + delta
-    anchors = anchors - delta
+    ## feasible anchors for eroded set
+    offset_anchors = anchors - delta
 
     ## scale epsilon
-    diff = anchors - vertices
+    diff = vertices - offset_anchors
     eps = eps / norm(diff, ord=2, axis=-1, keepdims=True)
 
     ub = np.ones_like(eps)
-    lb = -eps
-    x = np.full_like(eps, 0.5)
+    lb = np.where(oracle(vertices + delta)[:, None], ub, -eps)
 
     while (ub - lb > eps).any():
-        mask = oracle(diff * x + vert_offset)
+        x = (ub + lb) / 2
+        mask = oracle(diff * x + anchors)
         n_mask = ~mask
         ub[n_mask] = x[n_mask]
         lb[mask] = x[mask]
-        x = (ub + lb) / 2
 
-    return lb * diff + vertices
+    return lb * diff + offset_anchors
 
 
 def tighten(root: NDArray, reduced: NDArray, oracle: Callable, eps=1e-4) -> NDArray:
     """Tighten the box anchored at `root` using a monotone oracle."""
 
-    reduced = reduced.copy()
-    for ind in range(reduced.shape[-1]):
-        c_end = root.copy()
-        c_end[ind] = reduced[ind]
-        reduced[ind] = monotone_proj(root[None], c_end[None], oracle, eps=eps)[0, ind]
-    return reduced
+    root = np.tile(root, (root.shape[0], 1))
+    diag = root.copy()
+    np.fill_diagonal(diag, reduced)
+    proj = monotone_proj(root, diag, oracle=oracle, eps=eps)
+    return proj.diagonal().copy()
 
 
 def _center(s: str, width: int) -> str: