refactor how derivatives and values are handled

Author: SBlokhuizen

waveform_editor/tendencies/base.py

@@ -1,4 +1,5 @@
 from abc import abstractmethod
+from typing import Optional
 
 import numpy as np
 import param
@@ -55,6 +56,9 @@ class BaseTendency(param.Parameterized):
     start_value = param.Number(doc="Value at self.start")
     end_value = param.Number(doc="Value at self.end")
 
+    start_derivative = param.Number(doc="Derivative at self.start")
+    end_derivative = param.Number(doc="Derivative at self.end")
+
     time_error = param.ClassSelector(
         class_=Exception,
         default=None,
@@ -103,41 +107,24 @@ def set_next_tendency(self, next_tendency):
 
     @depends("values_changed", watch=True)
     def _calc_start_end_values(self):
-        self.start_value = self.get_start_value()
-        self.end_value = self.get_end_value()
-
-    @abstractmethod
-    def get_start_value(self) -> float:
-        """Returns the value of the tendency at the start."""
-        return 0.0
+        _, self.start_value = self.get_value(np.array([self.start]))
+        _, self.start_derivative = self.get_derivative(np.array([self.start]))
 
-    @abstractmethod
-    def get_end_value(self) -> float:
-        """Returns the value of the tendency at the end."""
-        return 0.0
-
-    @abstractmethod
-    def get_derivative_start(self) -> float:
-        """Returns the derivative of the tendency at the start."""
-        return 0.0
+        _, self.end_value = self.get_value(np.array([self.end]))
+        _, self.end_derivative = self.get_derivative(np.array([self.end]))
 
     @abstractmethod
-    def get_derivative_end(self) -> float:
-        """Returns the derivative of the tendency at the end."""
-        return 0.0
+    def get_value(
+        self, time: Optional[np.ndarray] = None
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Get the values on the provided time array."""
+        pass
 
     @abstractmethod
-    def generate(self, time) -> tuple[np.ndarray, np.ndarray]:
-        """Generate time and values based on the tendency. If no time array is provided,
-        a linearly spaced time array will be generated from the start to the end of the
-        tendency.
-
-        Args:
-            time: The time array on which to generate points.
-
-        Returns:
-            Tuple containing the time and its tendency values.
-        """
+    def get_derivative(
+        self, time: Optional[np.ndarray] = None
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Get the derivative values on the provided time array."""
         pass
 
     @depends(

waveform_editor/tendencies/constant.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 import numpy as np
 import param
 from param import depends
@@ -19,8 +21,10 @@ def __init__(self, **kwargs):
         self.value = 0.0
         super().__init__(**kwargs)
 
-    def generate(self, time=None):
-        """Generate time and values based on the tendency. If no time array is provided,
+    def get_value(
+        self, time: Optional[np.ndarray] = None
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Get the values onf the provided time array. If no time array is provided,
         a constant line containing the start and end points will be generated.
 
         Args:
@@ -34,21 +38,22 @@ def generate(self, time=None):
         values = self.value * np.ones(len(time))
         return time, values
 
-    def get_start_value(self) -> float:
-        """Returns the value of the tendency at the start."""
-        return self.value
-
-    def get_end_value(self) -> float:
-        """Returns the value of the tendency at the end."""
-        return self.value
+    def get_derivative(
+        self, time: Optional[np.ndarray] = None
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Get the derivative values on the provided time array. If no time array is
+        provided, a constant line containing the start and end points will be returned.
 
-    def get_derivative_start(self) -> float:
-        """Returns the derivative of the tendency at the start."""
-        return 0
+        Args:
+            time: The time array on which to generate points.
 
-    def get_derivative_end(self) -> float:
-        """Returns the derivative of the tendency at the end."""
-        return 0
+        Returns:
+            Tuple containing the time and its tendency values.
+        """
+        if time is None:
+            time = np.array([self.start, self.end])
+        derivatives = np.zeros(len(time))
+        return time, derivatives
 
     @depends(
         "prev_tendency.end_value",

waveform_editor/tendencies/linear.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 import numpy as np
 import param
 from param import depends
@@ -33,8 +35,10 @@ def __init__(self, **kwargs):
         self.rate = 0.0
         super().__init__(**kwargs)
 
-    def generate(self, time=None):
-        """Generate time and values based on the tendency. If no time array is provided,
+    def get_value(
+        self, time: Optional[np.ndarray] = None
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Get the values onf the provided time array. If no time array is provided,
         a line containing the start and end points will be generated.
 
         Args:
@@ -45,28 +49,26 @@ def generate(self, time=None):
         """
         if time is None:
             time = np.array([self.start, self.end])
-        time = np.array(time)
-
         normalized_time = (time - self.start) / (self.end - self.start)
-
         values = self.from_ + (self.to - self.from_) * normalized_time
         return time, values
 
-    def get_start_value(self) -> float:
-        """Returns the value of the tendency at the start."""
-        return self.from_
+    def get_derivative(
+        self, time: Optional[np.ndarray] = None
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Get the derivative values on the provided time array. If no time array is
+        a constant line containing the start and end points will be generated.
 
-    def get_end_value(self) -> float:
-        """Returns the value of the tendency at the end."""
-        return self.to
-
-    def get_derivative_start(self) -> float:
-        """Returns the derivative of the tendency at the start."""
-        return self.rate
+        Args:
+            time: The time array on which to generate points.
 
-    def get_derivative_end(self) -> float:
-        """Returns the derivative of the tendency at the end."""
-        return self.rate
+        Returns:
+            Tuple containing the time and its tendency values.
+        """
+        if time is None:
+            time = np.array([self.start, self.end])
+        derivatives = self.rate * np.ones(len(time))
+        return time, derivatives
 
     # Workaround: param doesn't like a @depends on both prev and next tendency
     _trigger = param.Event()
@@ -104,7 +106,7 @@ def _calc_values(self):
             if self.prev_tendency is None:
                 inputs[0] = 0
             else:
-                inputs[0] = self.prev_tendency.get_end_value()
+                inputs[0] = self.prev_tendency.get_value(self.start)
             num_inputs += 1
             start_value_set = False
         else:
@@ -113,7 +115,7 @@ def _calc_values(self):
         if num_inputs < 2 and inputs[2] is None:
             # To value is not provided, set to from_ or next start value
             if self.next_tendency is not None and self.next_tendency.start_value_set:
-                inputs[2] = self.next_tendency.get_start_value()
+                inputs[2] = self.next_tendency.get_value(self.end)
             else:
                 inputs[2] = inputs[0]
             num_inputs += 1

waveform_editor/waveform.py

@@ -33,7 +33,7 @@ def __init__(self, waveform):
         self._process_waveform(waveform)
         self.calc_length()
 
-    def generate(self, time=None):
+    def get_value(self, time=None):
         """Generate time and values based on the tendency. If no time array is provided,
         a constant line containing the start and end points will be generated.
 
@@ -47,7 +47,7 @@ def generate(self, time=None):
             times = []
             values = []
             for tendency in self.tendencies:
-                time, value = tendency.generate()
+                time, value = tendency.get_value()
                 times.extend(time)
                 values.extend(value)
             times = np.array(times)
@@ -60,30 +60,12 @@ def generate(self, time=None):
 
                 if np.any(mask):
                     relevant_times = times[mask]
-                    _, generated_values = tendency.generate(relevant_times)
+                    _, generated_values = tendency.get_value(relevant_times)
 
                     values[mask] = generated_values
 
         return times, values
 
-    def get_start_value(self) -> float:
-        """Returns the value of the tendency at the start."""
-        return self.generate(self.start)
-
-    def get_end_value(self) -> float:
-        """Returns the value of the tendency at the end."""
-        return self.generate(self.end)
-
-    def get_derivative_start(self) -> float:
-        """Returns the derivative of the tendency at the start."""
-        # TODO:
-        return 0
-
-    def get_derivative_end(self) -> float:
-        """Returns the derivative of the tendency at the end."""
-        # TODO:
-        return 0
-
     def calc_length(self):
         """Returns the length of the waveform."""
         return self.tendencies[-1].end - self.tendencies[0].start

waveform_editor/waveform_editor_gui.py

@@ -14,9 +14,7 @@
     value="""\
 waveform:
 - {type: linear, from: 0, to: 8, duration: 5}
-- {type: sine-wave, base: 8, amplitude: 2, frequency: 1, duration: 4}
 - {type: constant, value: 8, duration: 3}
-- {type: smooth, from: 8, to: 0, duration: 2}
 """,
     width=600,
     height=1200,
@@ -38,7 +36,7 @@ def update_plot(value):
     yaml_parser.tendencies = []
     yaml_parser.parse_waveforms_from_string(value)
 
-    return yaml_parser.plot_tendencies()
+    return yaml_parser.plot_tendencies(True)
 
 
 hv_dynamic_map = hv.DynamicMap(pn.bind(update_plot, value=code_editor.param.value))

waveform_editor/yaml_parser.py

@@ -36,7 +36,7 @@ def plot_tendencies(self, plot_time_points=False):
         Returns:
             A Holoviews Overlay object.
         """
-        times, values = self.waveform.generate()
+        times, values = self.waveform.get_value()
 
         overlay = hv.Overlay()