InterpolatePy 3.3.0__tar.gz → 3.3.1__tar.gz

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/ALGORITHMS.md

@@ -1,6 +1,6 @@
 # InterpolatePy algorithm guide
 
-This page is a compact map of the algorithms exposed by InterpolatePy 3.3.0.
+This page is a compact map of the algorithms exposed by InterpolatePy 3.3.1.
 For constructor signatures and complete method documentation, use the
 [API reference](docs/api-reference.md). For worked code, use the
 [tutorials](docs/user-guide.md) and [`examples/`](examples/).

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: InterpolatePy
-Version: 3.3.0
+Version: 3.3.1
 Summary: A comprehensive Python library for generating smooth trajectories and curves with precise control over position, velocity, acceleration, and jerk profiles
 Keywords: interpolation,trajectory planning,motion profiles,robotics,b-splines,cubic splines,frenet frames,path generation,motion control
 Author-Email: Giorgio Medico <giorgio.medico11@gmail.com>
@@ -56,7 +56,7 @@ at import time.
 python -m pip install InterpolatePy
 ```
 
-InterpolatePy 3.3.0 requires Python 3.11 or newer, NumPy 1.26 or newer,
+InterpolatePy 3.3.1 requires Python 3.11 or newer, NumPy 1.26 or newer,
 and SciPy 1.11 or newer. Install plotting support when needed:
 
 ```bash

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/README.md

@@ -20,7 +20,7 @@ at import time.
 python -m pip install InterpolatePy
 ```
 
-InterpolatePy 3.3.0 requires Python 3.11 or newer, NumPy 1.26 or newer,
+InterpolatePy 3.3.1 requires Python 3.11 or newer, NumPy 1.26 or newer,
 and SciPy 1.11 or newer. Install plotting support when needed:
 
 ```bash

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/cpp/CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.21)
 if(DEFINED SKBUILD_PROJECT_VERSION)
     set(INTERPOLATECPP_VERSION "${SKBUILD_PROJECT_VERSION}")
 else()
-    set(INTERPOLATECPP_VERSION "3.3.0")
+    set(INTERPOLATECPP_VERSION "3.3.1")
 endif()
 
 project(InterpolateCpp

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/cpp/src/cubic_bspline_interpolation.cpp

@@ -111,19 +111,18 @@ Eigen::MatrixXd CubicBSplineInterpolation::calculate_control_points(
         const double b3_k1 = basis_vals[1];
         const double b3_k2 = basis_vals[2];
 
+        // Independent tests, not if/else: at n == 2 the only row is both first and last.
+        main_diag[k - 1] = b3_k1;
+        rhs.row(k - 1) = interpolation_points_.row(k);
         if (k == 1) {
-            main_diag[0] = b3_k1;
-            upper_diag[0] = b3_k2;
-            rhs.row(0) = interpolation_points_.row(k) - b3_k * cp.row(1);
-        } else if (k == n - 1) {
-            lower_diag[k - 2] = b3_k;
-            main_diag[k - 1] = b3_k1;
-            rhs.row(k - 1) = interpolation_points_.row(k) - b3_k2 * cp.row(n + 1);
+            rhs.row(k - 1) -= b3_k * cp.row(1);
         } else {
             lower_diag[k - 2] = b3_k;
-            main_diag[k - 1] = b3_k1;
+        }
+        if (k == n - 1) {
+            rhs.row(k - 1) -= b3_k2 * cp.row(n + 1);
+        } else {
             upper_diag[k - 1] = b3_k2;
-            rhs.row(k - 1) = interpolation_points_.row(k);
         }
     }
 

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/cpp/src/modified_log_quaternion_interpolation.cpp

@@ -1,6 +1,8 @@
 #include <interpolatecpp/quat/modified_log_quaternion_interpolation.hpp>
 
+#include <algorithm>
 #include <cmath>
+#include <numbers>
 #include <stdexcept>
 
 namespace interpolatecpp::quat {
@@ -15,6 +17,19 @@ void ModifiedLogQuaternionInterpolation::ensure_quaternion_continuity() {
     }
 }
 
+namespace {
+
+// Unlike to_axis_angle(), keeps the sign of w so the angle spans [0, 2*pi].
+std::pair<Eigen::Vector3d, double> axis_angle_raw(const Quaternion& q, double eps) {
+    const double s = q.w();
+    const double sin_half = std::sqrt(std::max(0.0, 1.0 - s * s));
+    const Eigen::Vector3d axis =
+        sin_half < eps ? Eigen::Vector3d::UnitX() : Eigen::Vector3d(q.vec() / sin_half);
+    return {axis, 2.0 * std::acos(std::clamp(s, -1.0, 1.0))};
+}
+
+}  // namespace
+
 std::pair<Eigen::VectorXd, Eigen::MatrixXd>
 ModifiedLogQuaternionInterpolation::transform_to_theta_xyz() const {
     const int n = static_cast<int>(quaternions_.size());
@@ -22,11 +37,34 @@ ModifiedLogQuaternionInterpolation::transform_to_theta_xyz() const {
     Eigen::MatrixXd xyz_values(n, 3);
 
     for (int i = 0; i < n; ++i) {
-        auto [axis, angle] = quaternions_[i].to_axis_angle();
+        auto [axis, angle] = axis_angle_raw(quaternions_[i], kEpsilon);
+        // Keep the axis on the previous sample's side so theta stays on one branch.
+        if (i > 0 && axis.dot(xyz_values.row(i - 1).transpose()) < 0.0) {
+            axis = -axis;
+            angle = 2.0 * std::numbers::pi - angle;
+        }
         theta_values[i] = angle;
         xyz_values.row(i) = axis.transpose();
     }
 
+    // Same algorithm as np.unwrap, so jumps of exactly pi resolve identically.
+    constexpr double pi = std::numbers::pi;
+    double correction = 0.0;
+    double prev_raw = theta_values[0];
+    for (int i = 1; i < n; ++i) {
+        const double raw = theta_values[i];
+        const double dd = raw - prev_raw;
+        prev_raw = raw;
+        if (std::abs(dd) >= pi) {
+            double dd_mod = dd + pi - 2.0 * pi * std::floor((dd + pi) / (2.0 * pi)) - pi;
+            if (dd_mod == -pi && dd > 0.0) {
+                dd_mod = pi;
+            }
+            correction += dd_mod - dd;
+        }
+        theta_values[i] = raw + correction;
+    }
+
     return {theta_values, xyz_values};
 }
 

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/docs/algorithms.md

@@ -1,6 +1,6 @@
 # Algorithms
 
-This guide summarizes the numerical families in InterpolatePy 3.3.0 and helps
+This guide summarizes the numerical families in InterpolatePy 3.3.1 and helps
 select between them. The [API reference](api-reference.md) supplies signatures;
 the tutorials supply complete code.
 

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/docs/api-reference.md

@@ -1,6 +1,6 @@
 # API reference
 
-This page documents the supported Python API for InterpolatePy 3.3.0. Import
+This page documents the supported Python API for InterpolatePy 3.3.1. Import
 these objects from `interpolatepy` unless a module-qualified exception is shown.
 
 !!! note "Backend-dependent class identity"

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/docs/changelog.md

@@ -3,6 +3,16 @@
 This changelog records released InterpolatePy behavior. Dates and versions match
 the repository tags. The project follows [Semantic Versioning](https://semver.org/).
 
+## 3.3.1 — 2026-09-27
+
+### Fixed
+
+- C++ `CubicBSplineInterpolation` now applies the end-velocity correction with
+  three waypoints, matching the Python implementation.
+- C++ `ModifiedLogQuaternionInterpolation` now keeps the rotation axis on one
+  side and unwraps the angle like the Python implementation, fixing rotations
+  past π and varying-axis sequences.
+
 ## 3.3.0 — 2026-09-19
 
 ### Added

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/docs/index.md

@@ -5,7 +5,7 @@
 [![Python](https://img.shields.io/badge/python-3.11+-blue)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/GiorgioMedico/InterpolatePy/blob/main/LICENSE)
 
-InterpolatePy 3.3.0 provides trajectory planning and interpolation for scalar
+InterpolatePy 3.3.1 provides trajectory planning and interpolation for scalar
 motion, parametric curves, 3D paths, and rotations. It runs with a NumPy/SciPy
 implementation by default and can transparently use an optional C++20 backend.
 

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/docs/troubleshooting.md

@@ -22,7 +22,7 @@ Check the installed version:
 python -c "import interpolatepy as ip; print(ip.__version__)"
 ```
 
-This documentation targets 3.3.0. Import public algorithms from `interpolatepy`.
+This documentation targets 3.3.1. Import public algorithms from `interpolatepy`.
 The trapezoidal `TrajectoryParams` is the intentional exception:
 
 ```python

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/pyproject.toml

@@ -10,7 +10,7 @@ maintainers = [
 ]
 description = "A comprehensive Python library for generating smooth trajectories and curves with precise control over position, velocity, acceleration, and jerk profiles"
 readme = "README.md"
-version = "3.3.0"
+version = "3.3.1"
 license = "MIT"
 license-files = ["LICENSE"]
 requires-python = ">=3.11"

interpolatepy-3.3.1/tests/test_cpp_parity.py

@@ -0,0 +1,143 @@
+"""Parity of the C++ backend against the pure-Python reference at small n."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.testing as npt
+import pytest
+
+import interpolatepy as ip
+from interpolatepy.bsplines.cubic import CubicBSplineInterpolation as PyCubicBSplineInterpolation
+from interpolatepy.bsplines.smoothing import BSplineParams as PyBSplineParams
+from interpolatepy.bsplines.smoothing import SmoothingCubicBSpline as PySmoothingCubicBSpline
+from interpolatepy.quaternion import logarithmic as py_logarithmic
+from interpolatepy.quaternion.core import Quaternion as PyQuaternion
+from interpolatepy.splines.acceleration1 import CubicSplineWithAcceleration1 as PyCubicSplineWithAcceleration1
+from interpolatepy.splines.acceleration2 import CubicSplineWithAcceleration2 as PyCubicSplineWithAcceleration2
+from interpolatepy.splines.acceleration2 import SplineParameters as PySplineParameters
+from interpolatepy.splines.cubic import CubicSpline as PyCubicSpline
+from interpolatepy.splines.smoothing import CubicSmoothingSpline as PyCubicSmoothingSpline
+
+pytestmark = pytest.mark.skipif(not ip.HAS_CPP, reason="C++ backend not available")
+
+TOL = 1e-9
+METHODS = ["equally_spaced", "chord_length", "centripetal"]
+FIELD_POINTS = [[0.0, 0.0, 0.0], [0.5, 0.2, 0.4], [1.0, 0.0, 1.0]]
+
+
+def _points(n: int) -> np.ndarray:
+    extra = [[1.4, 0.6, 0.7], [2.0, 0.1, 0.3], [2.3, -0.5, 0.9]]
+    return np.array(FIELD_POINTS + extra[: n - 3])
+
+
+def _bspline_grid(curve: Any) -> np.ndarray:
+    return np.array([curve.evaluate(u) for u in np.linspace(curve.u_min, curve.u_max, 201)])
+
+
+class TestCubicBSplineInterpolationParity:
+    @pytest.mark.parametrize("n", [3, 4, 5, 6])
+    @pytest.mark.parametrize("method", METHODS)
+    @pytest.mark.parametrize("velocities", [False, True])
+    def test_matches_python_and_hits_waypoints(self, n: int, method: str, velocities: bool) -> None:
+        points = _points(n)
+        kwargs: dict[str, Any] = {"v0": [0.3, -0.2, 0.5], "vn": [-0.4, 0.1, 0.2]} if velocities else {}
+        cpp = ip.CubicBSplineInterpolation(points, method=method, **kwargs)
+        py = PyCubicBSplineInterpolation(points, method=method, **kwargs)
+
+        npt.assert_allclose(cpp.control_points, py.control_points, atol=TOL)
+        npt.assert_allclose(_bspline_grid(cpp), _bspline_grid(py), atol=TOL)
+        for u, point in zip(cpp.u_bars, points):
+            npt.assert_allclose(cpp.evaluate(u), point, atol=TOL)
+
+    @pytest.mark.parametrize("method", METHODS)
+    def test_auto_derivatives_three_points(self, method: str) -> None:
+        cpp = ip.CubicBSplineInterpolation(FIELD_POINTS, method=method, auto_derivatives=True)
+        py = PyCubicBSplineInterpolation(FIELD_POINTS, method=method, auto_derivatives=True)
+        npt.assert_allclose(_bspline_grid(cpp), _bspline_grid(py), atol=TOL)
+
+
+class TestSmallestNSplineParity:
+    """Tridiagonal/banded solvers with boundary-row corrections, at their smallest n."""
+
+    t = np.linspace(0.0, 1.0, 301)
+
+    @pytest.mark.parametrize(("v0", "vn"), [(0.0, 0.0), (0.7, -0.3)])
+    def test_cubic_spline(self, v0: float, vn: float) -> None:
+        args = ([0.0, 1.0, 2.5], [0.0, 1.0, 0.2])
+        cpp, py = ip.CubicSpline(*args, v0=v0, vn=vn), PyCubicSpline(*args, v0=v0, vn=vn)
+        t = self.t * 2.5
+        npt.assert_allclose(cpp.evaluate(t), py.evaluate(t), atol=TOL)
+
+    @pytest.mark.parametrize("n", [3, 4])
+    def test_cubic_spline_with_acceleration1(self, n: int) -> None:
+        args = ([0.0, 1.0, 2.5, 3.0][:n], [0.0, 1.0, 0.2, 0.8][:n])
+        kw: dict[str, Any] = {"v0": 0.4, "vn": -0.2, "a0": 0.1, "an": 0.3}
+        cpp, py = ip.CubicSplineWithAcceleration1(*args, **kw), PyCubicSplineWithAcceleration1(*args, **kw)
+        t = self.t * args[0][-1]
+        npt.assert_allclose(cpp.evaluate(t), py.evaluate(t), atol=TOL)
+
+    @pytest.mark.parametrize("n", [2, 3])
+    def test_cubic_spline_with_acceleration2(self, n: int) -> None:
+        args = ([0.0, 1.0, 2.5][:n], [0.0, 1.0, 0.2][:n])
+        kw: dict[str, Any] = {"v0": 0.4, "vn": -0.2, "a0": 0.1, "an": 0.3}
+        cpp = ip.CubicSplineWithAcceleration2(*args, ip.SplineParameters(**kw))
+        py = PyCubicSplineWithAcceleration2(*args, PySplineParameters(**kw))
+        t = self.t * args[0][-1]
+        npt.assert_allclose(cpp.evaluate(t), py.evaluate(t), atol=TOL)
+
+    def test_cubic_smoothing_spline(self) -> None:
+        args = ([0.0, 1.0, 2.5], [0.0, 1.0, 0.2])
+        kw: dict[str, Any] = {"mu": 0.6, "v0": 0.4, "vn": -0.2}
+        cpp, py = ip.CubicSmoothingSpline(*args, **kw), PyCubicSmoothingSpline(*args, **kw)
+        t = self.t * 2.5
+        npt.assert_allclose(cpp.evaluate(t), py.evaluate(t), atol=TOL)
+
+    @pytest.mark.parametrize("enforce_endpoints", [False, True])
+    @pytest.mark.parametrize("method", METHODS)
+    def test_smoothing_cubic_bspline(self, enforce_endpoints: bool, method: str) -> None:
+        kw: dict[str, Any] = {
+            "mu": 0.7,
+            "method": method,
+            "enforce_endpoints": enforce_endpoints,
+            "v0": [0.3, 0.0, 0.1],
+        }
+        cpp = ip.SmoothingCubicBSpline(FIELD_POINTS, ip.BSplineParams(**kw))
+        py = PySmoothingCubicBSpline(FIELD_POINTS, PyBSplineParams(**kw))
+        npt.assert_allclose(_bspline_grid(cpp), _bspline_grid(py), atol=TOL)
+
+
+def _z_rotation(angle: float) -> PyQuaternion:
+    return PyQuaternion(np.cos(angle / 2.0), 0.0, 0.0, np.sin(angle / 2.0))
+
+
+def _as_array(q: PyQuaternion) -> np.ndarray:
+    return np.array([q.w, q.x, q.y, q.z])
+
+
+@pytest.mark.parametrize("name", ["ModifiedLogQuaternionInterpolation", "LogQuaternionInterpolation"])
+class TestLogQuaternionParity:
+    times = (0.0, 0.2, 0.4, 0.6, 0.8, 1.0)
+
+    def _pair(self, name: str, quats: list[PyQuaternion]) -> tuple[Any, Any]:
+        return getattr(ip, name)(self.times, quats), getattr(py_logarithmic, name)(self.times, quats)
+
+    def test_rotation_past_pi_is_monotone(self, name: str) -> None:
+        quats = [_z_rotation(a) for a in np.linspace(0.0, 3.6, len(self.times))]
+        cpp, py = self._pair(name, quats)
+        t = np.linspace(0.0, 1.0, 241)
+        cpp_q = np.array([_as_array(cpp.evaluate(ti)) for ti in t])
+        npt.assert_allclose(cpp_q, [_as_array(py.evaluate(ti)) for ti in t], atol=TOL)
+
+        angles = np.unwrap(2.0 * np.arctan2(cpp_q[:, 3], cpp_q[:, 0]))
+        assert np.all(np.diff(angles) > 0.0)
+        npt.assert_allclose(angles[-1], 3.6, atol=TOL)
+
+    def test_varying_axis_matches_python(self, name: str) -> None:
+        rng = np.random.default_rng(7)
+        quats = [PyQuaternion(*(q / np.linalg.norm(q))) for q in rng.normal(size=(len(self.times), 4))]
+        cpp, py = self._pair(name, quats)
+        for ti in np.linspace(0.0, 1.0, 241):
+            npt.assert_allclose(_as_array(cpp.evaluate(ti)), _as_array(py.evaluate(ti)), atol=TOL)
+            npt.assert_allclose(cpp.evaluate_velocity(ti), py.evaluate_velocity(ti), atol=1e-8)

{interpolatepy-3.3.0 → interpolatepy-3.3.1}/uv.lock

@@ -652,7 +652,7 @@ wheels = [
 
 [[package]]
 name = "interpolatepy"
-version = "3.3.0"
+version = "3.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },