complete reimplementation of powell's method

Author: SimonBlanke

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

@@ -4,8 +4,10 @@
 
 
 from .powells_method import PowellsMethod
+from .direction import Direction
 
 
 __all__ = [
     "PowellsMethod",
+    "Direction",
 ]

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

@@ -2,32 +2,86 @@
 # Email: simon.blanke@yahoo.com
 # License: MIT License
 
+import numpy as np
+
 
 class Direction:
-    def __init__(self, position_1, position_2) -> None:
+    """
+    Represents a search direction for Powell's method.
+
+    This class handles movement along an arbitrary direction vector in the
+    search space, supporting line searches for 1D optimization.
+    """
+
+    def __init__(self, direction_vector: np.ndarray):
         """
-        Parameters:
-        - position_1: dict, starting point in the search-space
-        - position_2: dict, end point in the search-space
+        Initialize a direction for line search.
+
+        Parameters
+        ----------
+        direction_vector : np.ndarray
+            The direction vector to search along. Will be normalized.
         """
+        norm = np.linalg.norm(direction_vector)
+        if norm < 1e-10:
+            raise ValueError("Direction vector cannot be zero")
+        self.direction = direction_vector / norm
+
+    def get_position_at(self, origin: np.ndarray, t: float) -> np.ndarray:
+        """
+        Calculate position along the direction from an origin point.
+
+        Parameters
+        ----------
+        origin : np.ndarray
+            Starting position in search space
+        t : float
+            Step size along the direction (can be negative)
 
-        self.position_1 = position_1
-        self.position_2 = position_2
+        Returns
+        -------
+        np.ndarray
+            New position: origin + t * direction
+        """
+        return origin + t * self.direction
+
+    @classmethod
+    def from_two_points(cls, position_1: np.ndarray, position_2: np.ndarray):
+        """
+        Create a Direction from two points in the search space.
+
+        Parameters
+        ----------
+        position_1 : np.ndarray
+            Starting point
+        position_2 : np.ndarray
+            End point
+
+        Returns
+        -------
+        Direction
+            Direction pointing from position_1 to position_2
+        """
+        direction_vector = position_2 - position_1
+        return cls(direction_vector)
 
-    def get_new_position(self, t):
+    @classmethod
+    def coordinate_axis(cls, dimension: int, n_dimensions: int):
         """
-        Calculate a position on the line (vector) between two positions using parameter t.
+        Create a Direction along a coordinate axis.
 
-        Parameters:
-        - t: float, parameter indicating the position along the line (0 <= t <= 1 for within the line segment)
+        Parameters
+        ----------
+        dimension : int
+            Which axis (0-indexed)
+        n_dimensions : int
+            Total number of dimensions
 
-        Returns:
-        - dict representing the new position in the search-space coordinate system
+        Returns
+        -------
+        Direction
+            Unit vector along the specified axis
         """
-        new_position = {}
-        for dim in self.position_1:
-            # Calculate the position along the line in each dimension
-            new_position[dim] = self.position_1[dim] + t * (
-                self.position_2[dim] - self.position_1[dim]
-            )
-        return new_position
+        direction_vector = np.zeros(n_dimensions)
+        direction_vector[dimension] = 1.0
+        return cls(direction_vector)