Moved position clipping to Coordinate base class

Moved value update to Coordinate base class

Author: HaaLeo

.vscode/extensions.json

@@ -2,6 +2,7 @@
     "recommendations": [
         "ms-python.python",
         "streetsidesoftware.code-spell-checker",
-        "njpwerner.autodocstring"
+        "njpwerner.autodocstring",
+        "gruntfuggly.todo-tree"
     ]
 }

swarmlib/cuckoosearch/cuckoo.py

@@ -19,8 +19,6 @@ def levy_flight(start: Tuple[float, float], alpha: float, param_lambda: float) -
         Arguments:
             start {Tuple[float, float]} -- The cuckoo's start position
             alpha {float} -- The step size
-
-        Keyword Arguments:
             param_lambda {float} -- lambda parameter of the levy distribution
 
         Returns:

swarmlib/cuckoosearch/nest.py

@@ -5,8 +5,6 @@
 
 from typing import Tuple
 
-import numpy as np
-
 from ..util.coordinate import Coordinate
 
 
@@ -28,8 +26,7 @@ def abandoned(self) -> bool:
 
     def abandon(self) -> None:
         self.__abandoned = True
-        self._position = np.random.uniform(self._lower_boundary, self._upper_boundary, 2)
-        self._value = self._function(self._position)
+        self._initialize()
 
     def update_pos(self, new_position: Tuple[float, float]) -> None:
         """
@@ -40,8 +37,8 @@ def update_pos(self, new_position: Tuple[float, float]) -> None:
         """
 
         new_value = self._function(new_position)
-        if new_value < self._value:
+        if new_value < self.value:
             if self.__abandoned:
                 self.__abandoned = False
-            self._value = new_value
+            # Value is updated automatically in base class
             self._position = new_position

swarmlib/fireflyalgorithm/firefly.py

@@ -18,11 +18,6 @@ def __init__(self, **kwargs):
         self.__alpha = kwargs.get('alpha', 0.25)
         self.__beta = kwargs.get('beta', 1)
         self.__gamma = kwargs.get('gamma', 0.97)
-        self.__upper_boundary = kwargs.get('upper_boundary', 0.)
-        self.__lower_boundary = kwargs.get('lower_boundary', 4.)
-
-    def update_intensity(self):
-        self._value = self._function(self._position)
 
     def move_towards(self, better_position):
         # euclidean distance
@@ -33,7 +28,5 @@ def move_towards(self, better_position):
             self.__beta*np.exp(-self.__gamma*(distance**2)) * (better_position-self._position) + \
             self.__alpha*(random.uniform(0, 1)-0.5)
 
-        self._position = np.clip(self._position, a_min=self.__lower_boundary, a_max=self.__upper_boundary)
-
     def random_walk(self, area):
         self._position = np.array([np.random.uniform(cord-area, cord+area) for cord in self._position])

swarmlib/fireflyalgorithm/firefly_problem.py

@@ -35,10 +35,6 @@ def __init__(self, **kwargs):
             for _ in range(kwargs['firefly_number'])
         ]
 
-        # Initialize intensity
-        for firefly in self.__fireflies:
-            firefly.update_intensity()
-
         # Initialize visualizer for plotting
         self.__visualizer = Visualizer(**kwargs)
         self.__visualizer.add_data(positions=[firefly.position for firefly in self.__fireflies])
@@ -51,7 +47,6 @@ def solve(self):
                 for j in self.__fireflies:
                     if j.value < i.value:
                         i.move_towards(j.position)
-                        i.update_intensity()
 
             current_best = min(self.__fireflies, key=lambda firefly: firefly.value)
             if not best or current_best.value < best.value:
@@ -61,7 +56,6 @@ def solve(self):
 
             # randomly walk the best firefly
             current_best.random_walk(0.1)
-            current_best.update_intensity()
 
             # Add data for visualization
             self.__visualizer.add_data(positions=[firefly.position for firefly in self.__fireflies])

swarmlib/pso/particle.py

@@ -25,7 +25,7 @@ def __init__(self, **kwargs):
 
         # Local best
         self.__best_position = self._position
-        self.__best_value = self._value
+        self.__best_value = self.value
 
     @property
     def velocity(self) -> float:
@@ -49,15 +49,12 @@ def step(self, global_best_pos: Tuple[float, float]) -> None:
         self.__clip_velocity()
 
         # Update position and clip it to boundaries
-        self._position = np.clip(self._position + self.__velocity, a_min=self._lower_boundary, a_max=self._upper_boundary)
-
-        # Update value
-        self._value = self._function(self._position)
+        self._position = self._position + self.__velocity
 
         # Update local best
-        if self._value < self.__best_value:
+        if self.value < self.__best_value:
             self.__best_position = self._position
-            self.__best_value = self._value
+            self.__best_value = self.value
 
     def __clip_velocity(self):
         norm = np.linalg.norm(self.__velocity)

swarmlib/util/coordinate.py

@@ -10,17 +10,53 @@
 
 class Coordinate:
     def __init__(self, **kwargs) -> None:
-        self._lower_boundary = kwargs.get('lower_boundary', 0.)
-        self._upper_boundary = kwargs.get('upper_boundary', 4.)
+        """
+        Initializes a new random coordinate.
+        """
+        self.__lower_boundary = kwargs.get('lower_boundary', 0.)
+        self.__upper_boundary = kwargs.get('upper_boundary', 4.)
         self._function = kwargs['function']
 
-        self._position = np.random.uniform(self._lower_boundary, self._upper_boundary, 2)
-        self._value = self._function(self._position)
+        self.__value = None
+        self.__position = None
+        self._initialize()
+
+    def _initialize(self) -> None:
+        """
+        Initialize a new random position and its value
+        """
+        self._position = np.random.uniform(self.__lower_boundary, self.__upper_boundary, 2)
+
 
     @property
     def position(self) -> Tuple[float, float]:
+        """
+        Get the coordinate's position
+
+        Returns:
+            Tuple[float, float]: the Position
+        """
         return self._position
 
+    # Internal Getter
+    @property
+    def _position(self) -> Tuple[float, float]:
+        return self.__position
+
+    # Internal Setter for automatic position clipping and value update
+    @_position.setter
+    def _position(self, new_pos: Tuple[float, float]) -> None:
+        """
+        Set the coordinate's new position.
+        Also updates checks whether the position is within the set boundaries
+        and updates the coordinate's value.
+
+        Args:
+            value (Tuple[float, float]): The new coordinate position
+        """
+        self.__position = np.clip(new_pos, a_min=self.__lower_boundary, a_max=self.__upper_boundary)
+        self.__value = self._function(self.__position)
+
     @property
     def value(self) -> float:
-        return self._value
+        return self.__value