Merge pull request #4 from GiorgioMedico/dev2

documentation code corrections, supported py 3.11, 3.12, 3.13

Author: GiorgioMedico

.github/workflows/docs.yml

@@ -36,7 +36,7 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v5
       with:
-        python-version: '3.11'
+        python-version: '3.12'
         cache: 'pip'
 
     - name: Install dependencies

.github/workflows/pre-commit.yml

@@ -13,5 +13,5 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v5
       with:
-        python-version: '3.10'
+        python-version: '3.11'
     - uses: pre-commit/[email protected]

.github/workflows/publish.yml

@@ -12,7 +12,7 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v5
       with:
-        python-version: '3.10'
+        python-version: '3.12'
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip

.github/workflows/test.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.10', '3.11', '3.12']
+        python-version: ['3.11', '3.12', '3.13']
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
@@ -39,7 +39,7 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        python-version: ['3.10', '3.11', '3.12']
+        python-version: ['3.11', '3.12', '3.13']
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}

.pre-commit-config.yaml

@@ -2,7 +2,7 @@ default_language_version:
   python: python3
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: check-ast
       - id: check-builtin-literals
@@ -12,7 +12,7 @@ repos:
       - id: check-toml
 
 -   repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.12.7'
+    rev: 'v0.12.8'
     hooks:
     -   id: ruff
         types_or: [python, pyi, jupyter]

ALGORITHMS.md

@@ -690,7 +690,7 @@ from interpolatepy import PolynomialTrajectory, BoundaryCondition, TimeInterval
 # Define boundary conditions
 initial = BoundaryCondition(position=0, velocity=0, acceleration=0)
 final = BoundaryCondition(position=1, velocity=0, acceleration=0)
-interval = TimeInterval(t0=0, t1=2)
+interval = TimeInterval(start=0, end=2)
 
 # Generate quintic trajectory
 traj_func = PolynomialTrajectory.order_5_trajectory(initial, final, interval)
@@ -910,9 +910,9 @@ import numpy as np
 times = [0, 1, 2, 3]
 quats = [
     Quaternion.identity(),
-    Quaternion.from_angle_axis(np.pi/2, [1, 0, 0]),  # 90° about X
-    Quaternion.from_angle_axis(np.pi, [0, 1, 0]),    # 180° about Y  
-    Quaternion.from_angle_axis(np.pi/4, [0, 0, 1])   # 45° about Z
+    Quaternion.from_angle_axis(np.pi/2, np.array([1, 0, 0])),  # 90° about X
+    Quaternion.from_angle_axis(np.pi, np.array([0, 1, 0])),    # 180° about Y  
+    Quaternion.from_angle_axis(np.pi/4, np.array([0, 0, 1]))   # 45° about Z
 ]
 
 # Create C² continuous interpolator

README.md

@@ -61,7 +61,22 @@ bounds = TrajectoryBounds(v_bound=5.0, a_bound=10.0, j_bound=30.0)
 trajectory = DoubleSTrajectory(state, bounds)
 
 print(f"Duration: {trajectory.get_duration():.2f}s")
-trajectory.plot()
+
+# Manual plotting (DoubleSTrajectory doesn't have built-in plot method)
+t_eval = np.linspace(0, trajectory.get_duration(), 100)
+results = [trajectory.evaluate(t) for t in t_eval]
+positions = [r[0] for r in results]
+velocities = [r[1] for r in results]
+
+plt.figure(figsize=(10, 6))
+plt.subplot(2, 1, 1)
+plt.plot(t_eval, positions)
+plt.ylabel('Position')
+plt.title('S-Curve Trajectory')
+plt.subplot(2, 1, 2)
+plt.plot(t_eval, velocities)
+plt.ylabel('Velocity')
+plt.xlabel('Time')
 
 plt.show()
 ```
@@ -128,13 +143,14 @@ orientations = [
 times = [0.0, 2.0, 5.0]
 
 # Smooth quaternion trajectory with C² continuity
-quat_spline = QuaternionSpline(times, orientations, method="squad")
+quat_spline = QuaternionSpline(times, orientations, interpolation_method="squad")
 
 # Evaluate at any time
-orientation = quat_spline.evaluate(3.5)
-angular_velocity = quat_spline.evaluate_angular_velocity(3.5)
+orientation, segment = quat_spline.interpolate_at_time(3.5)
+# For angular velocity, use interpolate_with_velocity
+orientation_with_vel, angular_velocity, segment = quat_spline.interpolate_with_velocity(3.5)
 
-quat_spline.plot()
+# QuaternionSpline doesn't have built-in plotting - manual visualization needed
 plt.show()
 ```
 </details>
@@ -145,14 +161,15 @@ plt.show()
 ```python
 import numpy as np
 import matplotlib.pyplot as plt
-from interpolatepy import SmoothingCubicBSpline
+from interpolatepy import CubicSmoothingSpline
 
 # Fit smooth curve to noisy data
 t = np.linspace(0, 10, 50)
 q = np.sin(t) + 0.1 * np.random.randn(50)
 
-bspline = SmoothingCubicBSpline(t, q, smoothing=0.01)
-bspline.plot()
+# Use CubicSmoothingSpline with correct parameter name 'mu'
+spline = CubicSmoothingSpline(t, q, mu=0.01)
+spline.plot()
 plt.show()
 ```
 </details>
@@ -174,10 +191,22 @@ print(f"Duration: {trajectory.get_duration():.2f}s")
 
 # Evaluate trajectory
 t_eval = np.linspace(0, trajectory.get_duration(), 1000)
-positions = [trajectory.evaluate(t) for t in t_eval]
-velocities = [trajectory.evaluate_velocity(t) for t in t_eval]
-
-trajectory.plot()
+results = [trajectory.evaluate(t) for t in t_eval]
+positions = [r[0] for r in results]
+velocities = [r[1] for r in results]
+
+# Manual plotting
+plt.figure(figsize=(12, 8))
+plt.subplot(2, 1, 1)
+plt.plot(t_eval, positions)
+plt.ylabel('Position')
+plt.title('Industrial S-Curve Motion Profile')
+plt.grid(True)
+plt.subplot(2, 1, 2)
+plt.plot(t_eval, velocities)
+plt.ylabel('Velocity')
+plt.xlabel('Time')
+plt.grid(True)
 plt.show()
 ```
 </details>

docs/algorithms.md

@@ -349,10 +349,11 @@ The algorithm solves for total time considering all constraints and boundary con
 
     # Evaluate at midpoint
     t_mid = trajectory.get_duration() / 2
-    pos = trajectory.evaluate(t_mid)
-    vel = trajectory.evaluate_velocity(t_mid) 
-    acc = trajectory.evaluate_acceleration(t_mid)
-    jerk = trajectory.evaluate_jerk(t_mid)
+    result = trajectory.evaluate(t_mid)
+    pos = result[0]
+    vel = result[1]
+    acc = result[2]
+    jerk = result[3]
     ```
 
 ### Trapezoidal Trajectory

docs/api-reference.md

@@ -135,7 +135,7 @@ bspline = BSplineInterpolator(
 # Evaluate curve
 t = 2.5
 position = bspline.evaluate(t)
-velocity = bspline.evaluate_velocity(t)
+velocity = bspline.evaluate_derivative(t, order=1)
 ```
 
 #### ApproximationBSpline {#approximation-b-spline}
@@ -193,10 +193,11 @@ trajectory = DoubleSTrajectory(state, bounds)
 
 # Evaluate trajectory
 t = trajectory.get_duration() / 2
-position = trajectory.evaluate(t)
-velocity = trajectory.evaluate_velocity(t)
-acceleration = trajectory.evaluate_acceleration(t)
-jerk = trajectory.evaluate_jerk(t)
+result = trajectory.evaluate(t)
+position = result[0]
+velocity = result[1]
+acceleration = result[2]
+jerk = result[3]
 
 print(f"Duration: {trajectory.get_duration():.2f}s")
 ```
@@ -215,7 +216,8 @@ print(f"Duration: {trajectory.get_duration():.2f}s")
 
 **Example:**
 ```python
-from interpolatepy import TrapezoidalTrajectory, TrajectoryParams
+from interpolatepy import TrapezoidalTrajectory
+from interpolatepy.trapezoidal import TrajectoryParams
 
 # Define trajectory parameters
 params = TrajectoryParams(
@@ -273,7 +275,7 @@ final = BoundaryCondition(
     jerk=0.0
 )
 
-interval = TimeInterval(t0=0.0, t1=2.0)
+interval = TimeInterval(start=0.0, end=2.0)
 
 # Generate 7th-order polynomial
 traj_func = PolynomialTrajectory.order_7_trajectory(initial, final, interval)
@@ -319,7 +321,7 @@ import numpy as np
 
 # Create quaternions
 q1 = Quaternion.identity()
-q2 = Quaternion.from_angle_axis(np.pi/2, [0, 0, 1])  # 90° about Z
+q2 = Quaternion.from_angle_axis(np.pi/2, np.array([0, 0, 1]))  # 90° about Z
 
 # SLERP interpolation
 t = 0.5
@@ -350,9 +352,9 @@ import numpy as np
 times = [0, 1, 2, 3]
 orientations = [
     Quaternion.identity(),
-    Quaternion.from_angle_axis(np.pi/2, [1, 0, 0]),
-    Quaternion.from_angle_axis(np.pi, [0, 1, 0]),
-    Quaternion.from_angle_axis(np.pi/4, [0, 0, 1])
+    Quaternion.from_angle_axis(np.pi/2, np.array([1, 0, 0])),
+    Quaternion.from_angle_axis(np.pi, np.array([0, 1, 0])),
+    Quaternion.from_angle_axis(np.pi/4, np.array([0, 0, 1]))
 ]
 
 # Create C² continuous quaternion spline
@@ -401,7 +403,7 @@ velocity = path.velocity(s)      # Unit tangent vector
 acceleration = path.acceleration(s)  # Zero for straight line
 
 # Evaluate multiple points
-s_values = np.linspace(0, path.total_length, 50)
+s_values = np.linspace(0, path.length, 50)
 trajectory = path.evaluate_at(s_values)
 ```
 

docs/examples.md

@@ -29,14 +29,21 @@ def plan_robot_trajectory():
     # Timing: approach, pick, lift, move, place, retract, home
     time_points = [0, 2, 3, 5, 7, 8, 10]
 
-    # Create splines for each joint
+    # Create splines for each joint with error handling
     joint_splines = {}
     for joint, angles in waypoints.items():
-        joint_splines[joint] = CubicSpline(
-            time_points,
-            np.radians(angles),  # Convert to radians
-            v0=0.0, vn=0.0      # Zero velocity at start/end
-        )
+        # Validate input data
+        if len(angles) != len(time_points):
+            raise ValueError(f"Joint {joint}: {len(angles)} angles != {len(time_points)} time points")
+        
+        try:
+            joint_splines[joint] = CubicSpline(
+                time_points,
+                np.radians(angles).tolist(),  # Convert to radians and ensure list format
+                v0=0.0, vn=0.0      # Zero velocity at start/end
+            )
+        except Exception as e:
+            raise RuntimeError(f"Failed to create spline for joint {joint}: {e}")
 
     return joint_splines, time_points
 
@@ -255,9 +262,10 @@ velocities = []
 accelerations = []
 
 for t in t_eval:
-    s = trajectory.evaluate(t)              # Path distance
-    v = trajectory.evaluate_velocity(t)     # Path velocity
-    a = trajectory.evaluate_acceleration(t) # Path acceleration
+    result = trajectory.evaluate(t)         # Get all derivatives
+    s = result[0]                          # Path distance  
+    v = result[1]                          # Path velocity
+    a = result[2]                          # Path acceleration
 
     pos = interpolate_position(s, waypoints, distances)
     path_positions.append(pos)
@@ -627,7 +635,7 @@ print(f"Maximum acceleration: {np.max(accelerations):.2f} units/s²")
 Advanced signal processing with smoothing splines:
 
 ```python
-from interpolatepy import CubicSmoothingSpline, smoothing_spline_with_tolerance, SplineConfig
+from interpolatepy import CubicSmoothingSpline
 import numpy as np
 import matplotlib.pyplot as plt
 
@@ -661,14 +669,13 @@ def analyze_experimental_data():
 t_true, signal_true, t_measured, signal_measured = analyze_experimental_data()
 
 # Apply different smoothing strategies
+from interpolatepy import CubicSpline
 smoothing_methods = {
-    'No Smoothing': CubicSmoothingSpline(t_measured.tolist(), signal_measured.tolist(), mu=0.0),
+    'No Smoothing': CubicSpline(t_measured.tolist(), signal_measured.tolist()),  # Use CubicSpline for exact interpolation
     'Light Smoothing': CubicSmoothingSpline(t_measured.tolist(), signal_measured.tolist(), mu=0.001),
     'Medium Smoothing': CubicSmoothingSpline(t_measured.tolist(), signal_measured.tolist(), mu=0.01),
     'Heavy Smoothing': CubicSmoothingSpline(t_measured.tolist(), signal_measured.tolist(), mu=0.1),
-    'Auto Smoothing': smoothing_spline_with_tolerance(
-        np.array(t_measured), np.array(signal_measured), tolerance=0.2, config=SplineConfig()
-    )[0]  # Extract just the spline from the tuple
+    'Auto Smoothing': CubicSmoothingSpline(t_measured.tolist(), signal_measured.tolist(), mu=0.05)  # Medium auto-smoothing
 }
 
 # Evaluate all methods
@@ -767,7 +774,21 @@ plt.grid(True)
 
 # Frequency domain analysis
 ax5 = plt.subplot(3, 3, 7)
-from scipy import fft
+try:
+    from scipy import fft
+except ImportError:
+    # Fallback for older SciPy versions
+    import scipy.fftpack as fft_module
+    class FFTCompat:
+        @staticmethod
+        def fft(x):
+            return fft_module.fft(x)
+        
+        @staticmethod  
+        def fftfreq(n, d=1.0):
+            return fft_module.fftfreq(n, d)
+    
+    fft = FFTCompat()
 
 # FFT of original noisy signal
 freqs = fft.fftfreq(len(t_measured), t_measured[1] - t_measured[0])
@@ -1084,8 +1105,9 @@ class AssemblyLineController:
 
                         for axis_name, traj in segment['axes'].items():
                             axis_idx = ['x', 'y', 'z'].index(axis_name)
-                            robot_pos[axis_idx] = traj.evaluate(segment_time)
-                            robot_vel[axis_idx] = traj.evaluate_velocity(segment_time)
+                            result = traj.evaluate(segment_time)
+                            robot_pos[axis_idx] = result[0]
+                            robot_vel[axis_idx] = result[1]
 
                         robot_status = 'moving'
                         break