refactor powell's method

Author: SimonBlanke

src/gradient_free_optimizers/optimizers/global_opt/powells_method/__init__.py

@@ -5,9 +5,19 @@
 
 from .powells_method import PowellsMethod
 from .direction import Direction
+from .line_search import (
+    LineSearch,
+    GridLineSearch,
+    GoldenSectionLineSearch,
+    HillClimbLineSearch,
+)
 
 
 __all__ = [
     "PowellsMethod",
     "Direction",
+    "LineSearch",
+    "GridLineSearch",
+    "GoldenSectionLineSearch",
+    "HillClimbLineSearch",
 ]

src/gradient_free_optimizers/optimizers/global_opt/powells_method/line_search/__init__.py

@@ -0,0 +1,16 @@
+# Author: Simon Blanke
+# Email: [email protected]
+# License: MIT License
+
+from .base import LineSearch
+from .grid_search import GridLineSearch
+from .golden_section import GoldenSectionLineSearch
+from .hill_climb import HillClimbLineSearch
+
+
+__all__ = [
+    "LineSearch",
+    "GridLineSearch",
+    "GoldenSectionLineSearch",
+    "HillClimbLineSearch",
+]

src/gradient_free_optimizers/optimizers/global_opt/powells_method/line_search/base.py

@@ -0,0 +1,175 @@
+# Author: Simon Blanke
+# Email: [email protected]
+# License: MIT License
+
+from abc import ABC, abstractmethod
+from typing import Optional, Tuple
+
+import numpy as np
+
+
+class LineSearch(ABC):
+    """
+    Abstract base class for line search strategies in Powell's method.
+
+    A line search finds the optimum along a given direction from a starting point.
+    Different strategies (grid, golden section, hill climbing) implement this
+    interface to provide various trade-offs between exploration and efficiency.
+    """
+
+    def __init__(self, optimizer):
+        """
+        Initialize the line search strategy.
+
+        Parameters
+        ----------
+        optimizer : PowellsMethod
+            Reference to the parent optimizer for accessing converter and utilities.
+        """
+        self.optimizer = optimizer
+
+    @abstractmethod
+    def start(
+        self,
+        origin: np.ndarray,
+        direction: np.ndarray,
+        max_iters: int,
+    ) -> None:
+        """
+        Initialize a new line search along a direction.
+
+        Parameters
+        ----------
+        origin : np.ndarray
+            Starting position in search space (integer indices).
+        direction : np.ndarray
+            Normalized direction vector to search along.
+        max_iters : int
+            Maximum number of evaluations for this line search.
+        """
+        pass
+
+    @abstractmethod
+    def get_next_position(self) -> Optional[np.ndarray]:
+        """
+        Get the next position to evaluate.
+
+        Returns
+        -------
+        Optional[np.ndarray]
+            Next position to evaluate, or None if line search is complete.
+        """
+        pass
+
+    @abstractmethod
+    def update(self, position: np.ndarray, score: float) -> None:
+        """
+        Update the line search state after an evaluation.
+
+        Parameters
+        ----------
+        position : np.ndarray
+            The position that was evaluated.
+        score : float
+            The score obtained at that position.
+        """
+        pass
+
+    @abstractmethod
+    def get_best_result(self) -> Tuple[Optional[np.ndarray], Optional[float]]:
+        """
+        Get the best result found during this line search.
+
+        Returns
+        -------
+        Tuple[Optional[np.ndarray], Optional[float]]
+            (best_position, best_score) or (None, None) if no valid results.
+        """
+        pass
+
+    @abstractmethod
+    def is_active(self) -> bool:
+        """
+        Check if the line search is still in progress.
+
+        Returns
+        -------
+        bool
+            True if more evaluations are needed, False if complete.
+        """
+        pass
+
+    def _compute_max_step(self, origin: np.ndarray, direction: np.ndarray) -> float:
+        """
+        Compute the maximum step size along a direction that stays within bounds.
+
+        Parameters
+        ----------
+        origin : np.ndarray
+            Starting position.
+        direction : np.ndarray
+            Normalized direction vector.
+
+        Returns
+        -------
+        float
+            Maximum step size (for symmetric bounds [-max_t, max_t]).
+        """
+        max_t_positive = float("inf")
+        max_t_negative = float("inf")
+
+        max_positions = self.optimizer.conv.max_positions
+
+        for i, (d, o, max_pos) in enumerate(zip(direction, origin, max_positions)):
+            if abs(d) < 1e-10:
+                continue
+
+            if d > 0:
+                t_to_max = (max_pos - o) / d
+                t_to_zero = -o / d
+                max_t_positive = min(max_t_positive, t_to_max)
+                max_t_negative = min(max_t_negative, -t_to_zero)
+            else:
+                t_to_zero = -o / d
+                t_to_max = (max_pos - o) / d
+                max_t_positive = min(max_t_positive, t_to_zero)
+                max_t_negative = min(max_t_negative, -t_to_max)
+
+        max_t = min(max_t_positive, max_t_negative)
+
+        if max_t < 1:
+            max_t = max(max_positions) * 0.5
+
+        return max_t
+
+    def _snap_to_grid(self, position: np.ndarray) -> np.ndarray:
+        """
+        Snap a floating-point position to valid grid indices.
+
+        Parameters
+        ----------
+        position : np.ndarray
+            Position with potentially non-integer values.
+
+        Returns
+        -------
+        np.ndarray
+            Valid integer position within search space bounds.
+        """
+        return self.optimizer.conv2pos(position)
+
+    def _is_valid(self, position: np.ndarray) -> bool:
+        """
+        Check if a position satisfies constraints.
+
+        Parameters
+        ----------
+        position : np.ndarray
+            Position to check.
+
+        Returns
+        -------
+        bool
+            True if position is valid (not in constraint).
+        """
+        return self.optimizer.conv.not_in_constraint(position)

src/gradient_free_optimizers/optimizers/global_opt/powells_method/line_search/golden_section.py

@@ -0,0 +1,157 @@
+# Author: Simon Blanke
+# Email: [email protected]
+# License: MIT License
+
+from typing import Optional, Tuple, List
+
+import numpy as np
+
+from .base import LineSearch
+
+
+# Golden ratio: (sqrt(5) - 1) / 2 ≈ 0.618
+GOLDEN_RATIO = (np.sqrt(5) - 1) / 2
+
+
+class GoldenSectionLineSearch(LineSearch):
+    """
+    Golden section search strategy for line search.
+
+    Uses the golden ratio to efficiently narrow down the bracket containing
+    the optimum. More efficient than grid search for unimodal functions,
+    requiring O(log(n)) evaluations to achieve precision n.
+    """
+
+    def __init__(self, optimizer):
+        super().__init__(optimizer)
+        self.origin: Optional[np.ndarray] = None
+        self.direction: Optional[np.ndarray] = None
+        self.max_iters: int = 0
+        self.current_step: int = 0
+        self.active: bool = False
+
+        # Bracket state: a < c < d < b
+        self.a: float = 0.0
+        self.b: float = 0.0
+        self.c: float = 0.0
+        self.d: float = 0.0
+        self.fc: Optional[float] = None
+        self.fd: Optional[float] = None
+        self.phase: str = "eval_c"
+
+        # Track all evaluations for best result
+        self.evaluated_positions: List[np.ndarray] = []
+        self.evaluated_scores: List[float] = []
+
+    def start(
+        self,
+        origin: np.ndarray,
+        direction: np.ndarray,
+        max_iters: int,
+    ) -> None:
+        """Initialize golden section search with bracket [a, b]."""
+        self.origin = origin.copy()
+        self.direction = direction.copy()
+        self.max_iters = max_iters
+        self.current_step = 0
+        self.active = True
+
+        self.evaluated_positions = []
+        self.evaluated_scores = []
+
+        # Compute bracket bounds
+        max_t = self._compute_max_step(origin, direction)
+
+        # Initialize bracket: a < c < d < b
+        self.a = -max_t
+        self.b = max_t
+        # c at ~38.2% of interval, d at ~61.8% of interval
+        self.c = self.a + (1 - GOLDEN_RATIO) * (self.b - self.a)
+        self.d = self.a + GOLDEN_RATIO * (self.b - self.a)
+
+        self.fc = None
+        self.fd = None
+        self.phase = "eval_c"
+
+    def get_next_position(self) -> Optional[np.ndarray]:
+        """Return the next position to evaluate based on current phase."""
+        if not self.active or self.current_step >= self.max_iters:
+            self.active = False
+            return None
+
+        if self.phase == "eval_c":
+            t = self.c
+        elif self.phase == "eval_d":
+            t = self.d
+        else:
+            self.active = False
+            return None
+
+        pos_float = self.origin + t * self.direction
+        pos = self._snap_to_grid(pos_float)
+        return pos
+
+    def update(self, position: np.ndarray, score: float) -> None:
+        """Update bracket based on evaluation result."""
+        self.evaluated_positions.append(position.copy())
+        self.evaluated_scores.append(score)
+
+        if self.phase == "eval_c":
+            self.fc = score
+            if self.fd is None:
+                # First time: need to evaluate d next
+                self.phase = "eval_d"
+            else:
+                # Both c and d evaluated: narrow bracket
+                self._narrow_bracket()
+        elif self.phase == "eval_d":
+            self.fd = score
+            if self.fc is None:
+                # Need to evaluate c next
+                self.phase = "eval_c"
+            else:
+                # Both c and d evaluated: narrow bracket
+                self._narrow_bracket()
+
+    def _narrow_bracket(self) -> None:
+        """
+        Narrow the bracket based on function values at c and d.
+
+        For MAXIMIZATION:
+        - If f(c) > f(d): maximum in [a, d], narrow right
+        - If f(d) >= f(c): maximum in [c, b], narrow left
+        """
+        if self.fc > self.fd:
+            # Maximum in [a, d], narrow from right
+            # Reuse c as new d
+            self.b = self.d
+            self.d = self.c
+            self.fd = self.fc
+            # Calculate new c
+            self.c = self.a + (1 - GOLDEN_RATIO) * (self.b - self.a)
+            self.fc = None
+            self.phase = "eval_c"
+        else:
+            # Maximum in [c, b], narrow from left
+            # Reuse d as new c
+            self.a = self.c
+            self.c = self.d
+            self.fc = self.fd
+            # Calculate new d
+            self.d = self.a + GOLDEN_RATIO * (self.b - self.a)
+            self.fd = None
+            self.phase = "eval_d"
+
+        self.current_step += 1
+
+    def get_best_result(self) -> Tuple[Optional[np.ndarray], Optional[float]]:
+        """Return the position with the highest score."""
+        if not self.evaluated_scores:
+            return None, None
+
+        best_idx = np.argmax(self.evaluated_scores)
+        return self.evaluated_positions[best_idx], self.evaluated_scores[best_idx]
+
+    def is_active(self) -> bool:
+        """Check if golden section search should continue."""
+        return self.active and self.current_step < self.max_iters