chore: fix typos

Author: MarkusKnauer

README.md

@@ -71,7 +71,7 @@ User Command (natural language)
 
 | Tool | Paper Section | Purpose | Parameters |
 |------|--------------|---------|------------|
-| `SpeedUpRobot` / `SlowDownRobot` | IV-D, Eq. 3-4 | Temporal trajectory adjustment | speed_value, adaption_start, adaption_end |
+| `SpeedUpRobot` / `SlowDownRobot` | IV-D, Eq. 3-4 | Temporal trajectory adjustment | speed_value, adaptation_start, adaptation_end |
 | `AddViaPointsAtTime` | IV-D | Spatial trajectory correction via KMP via-points | input_values (times), output_values (positions) |
 | `AddRepulsionPoint` | IV-D, Eq. 5-6 | Obstacle avoidance via SDF-based correction | position, radius/dimensions |
 | `GetViaPoints` / `RemoveViaPoints*` | - | Via-point management | - |
@@ -203,7 +203,7 @@ model = KMPWrapper(demonstration_path="data/demonstrations.npz", force_retrain=T
 
 # Speed modulation: slow down between t=0.55 and t=0.72
 model.robot.change_predicting_frequency(
-    percentual_factor=50, adaption_start=0.55, adaption_end=0.72
+    percentage_factor=50, adaptation_start=0.55, adaptation_end=0.72
 )
 
 # Via-point insertion: add waypoint at camera position

examples/experiment_speed.py

@@ -104,11 +104,11 @@ def run():
 
     # Step 4: Apply speed modulation (what the LLM tool call does)
     # SlowDownRobot scales dt by factor (|gamma|+100)/100 = 1.5 for gamma=50
-    print(f"\nTool call: SlowDownRobot(slow_down_value=50, adaption_start={t_box:.2f}, adaption_end={t_station:.2f})")
+    print(f"\nTool call: SlowDownRobot(slow_down_value=50, adaptation_start={t_box:.2f}, adaptation_end={t_station:.2f})")
     tool = SlowDownRobot(
         slow_down_value=50,
-        adaption_start=round(t_box, 2),
-        adaption_end=round(t_station, 2),
+        adaptation_start=round(t_box, 2),
+        adaptation_end=round(t_station, 2),
     )
     result = tool.execute(model)
     print(f"Result: {result}")

irosa/robots/robot.py

@@ -80,36 +80,36 @@ def on_viapoints_added(self, positions_xyz: list[list]) -> None:
     def on_viapoints_removed(self, positions_xyz: list[list]) -> None:
         """Called when via-points are removed."""
 
-    def change_predicting_frequency(self, percentual_factor: int, adaption_start: float, adaption_end: float) -> None:
+    def change_predicting_frequency(self, percentage_factor: int, adaptation_start: float, adaptation_end: float) -> None:
         """Change execution speed for a time segment.
 
         Increasing delta_t slows the robot; decreasing delta_t speeds it up.
         If set to 50%, delta_t is increased by 1.5x (slowing down).
         If set to -50%, delta_t is decreased by 0.5x (speeding up).
 
-        :param percentual_factor: Speed change in percent (positive=slower, negative=faster)
-        :param adaption_start: Start time (0.0-1.0)
-        :param adaption_end: End time (0.0-1.0)
+        :param percentage_factor: Speed change in percent (positive=slower, negative=faster)
+        :param adaptation_start: Start time (0.0-1.0)
+        :param adaptation_end: End time (0.0-1.0)
         """
         if len(self.predicting_frequency) == 0:
             raise RuntimeError("The predicting frequency was not set, please set it first")
 
-        factor = (abs(percentual_factor) + 100) / 100
-        if percentual_factor < 0:
+        factor = (abs(percentage_factor) + 100) / 100
+        if percentage_factor < 0:
             factor = 1 / factor
 
-        if not (0.0 <= adaption_start <= 1.0):
-            raise ValueError("adaption_start has to be a value between 0.0 and 1.0")
-        if not (0.0 <= adaption_end <= 1.0):
-            raise ValueError("adaption_end has to be a value between 0.0 and 1.0")
-        if adaption_end <= adaption_start:
-            raise ValueError("adaption_end has to be a larger value than adaption_start")
+        if not (0.0 <= adaptation_start <= 1.0):
+            raise ValueError("adaptation_start has to be a value between 0.0 and 1.0")
+        if not (0.0 <= adaptation_end <= 1.0):
+            raise ValueError("adaptation_end has to be a value between 0.0 and 1.0")
+        if adaptation_end <= adaptation_start:
+            raise ValueError("adaptation_end has to be a larger value than adaptation_start")
 
         new_pred_frequency = self.predicting_frequency.copy()
         for idx, val_time in enumerate(self.timesteps):
-            if val_time < adaption_start:
+            if val_time < adaptation_start:
                 continue
-            if val_time > adaption_end:
+            if val_time > adaptation_end:
                 break
             new_pred_frequency[idx] = abs(self.predicting_frequency[idx] * factor)
 

irosa/tool_definitions/kmp.py

@@ -38,7 +38,7 @@ class AddViaPointsAtTime(Tool):
     """If you want to add several via-points at specific times, use this function.
     Add multiple via-points at specific times with specific positions.
     :param input_values: List of floats representing the times of the viapoints
-    :param output_values: List of lists of floats representing the positions of the viapoint
+    :param output_values: List of lists of floats representing the positions of the viapoints
     """
 
     input_values: list[float]

irosa/tool_definitions/robot.py

@@ -24,53 +24,53 @@
 
 class SpeedUpRobot(Tool):
     """If you want to speed up the robot, use this function. The default is to speed up
-    for the whole time period, so use 0.0 for adaption_start and 1.0 for adaption_end.
-    :param speed_up_value: percentual speedup of the robot. Default value is 40 for 40 percent.
-    :param adaption_start: Start time from when you want to speed up the robot, ranges from 0.0 to 1.0,
+    for the whole time period, so use 0.0 for adaptation_start and 1.0 for adaptation_end.
+    :param speed_up_value: percentage speedup of the robot. Default value is 40 for 40 percent.
+    :param adaptation_start: Start time from when you want to speed up the robot, ranges from 0.0 to 1.0,
     where 0.0 is the start and 1.0 is the end time.
-    :param adaption_end: Time when you want to stop the speedup of the robot, ranges from 0.0 to 1.0
-    and has to be bigger than the adaption_start.
+    :param adaptation_end: Time when you want to stop the speedup of the robot, ranges from 0.0 to 1.0
+    and has to be bigger than the adaptation_start.
     """
 
     speed_up_value: int
-    adaption_start: float
-    adaption_end: float
+    adaptation_start: float
+    adaptation_end: float
 
     def execute(self, kmp: KMPWrapper) -> str:
         if kmp.robot is None:
             raise ToolArgsValidationError("No robot configured for speed modulation")
         try:
-            kmp.robot.change_predicting_frequency(-self.speed_up_value, self.adaption_start, self.adaption_end)
+            kmp.robot.change_predicting_frequency(-self.speed_up_value, self.adaptation_start, self.adaptation_end)
         except Exception as e:
             raise ToolArgsValidationError(f"Error speeding up robot: {e}") from e
         return (
             f"IROSA: Increased robot speed by {self.speed_up_value} percent"
-            f" at the range {self.adaption_start} - {self.adaption_end}"
+            f" at the range {self.adaptation_start} - {self.adaptation_end}"
         )
 
 
 class SlowDownRobot(Tool):
     """If you want to slow down the robot, use this function. The default is to slow down
-    for the whole time period, so use 0.0 for adaption_start and 1.0 for adaption_end.
-    :param slow_down_value: percentual slowdown of the robot, default value is 80. Only values > 0 are allowed.
-    :param adaption_start: Start time from when you want to slow down the robot,
+    for the whole time period, so use 0.0 for adaptation_start and 1.0 for adaptation_end.
+    :param slow_down_value: percentage slowdown of the robot, default value is 80. Only values > 0 are allowed.
+    :param adaptation_start: Start time from when you want to slow down the robot,
         ranges from 0.0 to 1.0, where 0.0 is the start and 1.0 is the end time.
-    :param adaption_end: Time when you want to stop the slowdown of the robot,
-        ranges from 0.0 to 1.0 and has to be bigger than the adaption_start.
+    :param adaptation_end: Time when you want to stop the slowdown of the robot,
+        ranges from 0.0 to 1.0 and has to be bigger than the adaptation_start.
     """
 
     slow_down_value: int
-    adaption_start: float
-    adaption_end: float
+    adaptation_start: float
+    adaptation_end: float
 
     def execute(self, kmp: KMPWrapper) -> str:
         if kmp.robot is None:
             raise ToolArgsValidationError("No robot configured for speed modulation")
         try:
-            kmp.robot.change_predicting_frequency(self.slow_down_value, self.adaption_start, self.adaption_end)
+            kmp.robot.change_predicting_frequency(self.slow_down_value, self.adaptation_start, self.adaptation_end)
         except Exception as e:
             raise ToolArgsValidationError(f"Error slowing down the robot: {e}") from e
         return (
             f"IROSA: Decreased robot speed by {self.slow_down_value} percent"
-            f" at the range {self.adaption_start} - {self.adaption_end}"
+            f" at the range {self.adaptation_start} - {self.adaptation_end}"
         )

results/experiment1_speed.png

@@ -46,8 +46,8 @@ def test_tool_schema_generation():
     schema = SpeedUpRobot.to_openai_tool()
     params = schema["function"]["parameters"]
     assert "speed_up_value" in params["properties"]
-    assert "adaption_start" in params["properties"]
-    assert "adaption_end" in params["properties"]
+    assert "adaptation_start" in params["properties"]
+    assert "adaptation_end" in params["properties"]
 
 
 def test_slow_down_schema():