InterpolatePy 3.1.0__tar.gz → 3.2.0__tar.gz

{interpolatepy-3.1.0 → interpolatepy-3.2.0}/InterpolatePy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: InterpolatePy
-Version: 3.1.0
+Version: 3.2.0
 Summary: A comprehensive Python library for generating smooth trajectories and curves with precise control over position, velocity, acceleration, and jerk profiles
 Author-email: Giorgio Medico <giorgio.medico11@gmail.com>
 Maintainer-email: Giorgio Medico <giorgio.medico11@gmail.com>

{interpolatepy-3.1.0 → interpolatepy-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: InterpolatePy
-Version: 3.1.0
+Version: 3.2.0
 Summary: A comprehensive Python library for generating smooth trajectories and curves with precise control over position, velocity, acceleration, and jerk profiles
 Author-email: Giorgio Medico <giorgio.medico11@gmail.com>
 Maintainer-email: Giorgio Medico <giorgio.medico11@gmail.com>

{interpolatepy-3.1.0 → interpolatepy-3.2.0}/cpp/src/bspline_interpolator.cpp

@@ -176,22 +176,32 @@ Eigen::MatrixXd BSplineInterpolator::compute_control_points(
             ++row;
         }
 
-        // Fill remaining rows with natural spline conditions
-        while (row < total_rows) {
-            int deriv_order = std::min(p - 1, 2);
-            double t = (row % 2 == 0) ? times[0] : times[n];
+        // Fill remaining rows with natural spline conditions (zero higher
+        // derivatives at the endpoints). Walk the (derivative order, endpoint)
+        // pairs from order 2 up to p-1, skipping any pair an explicit
+        // acceleration already pinned -- reusing one would duplicate a row and
+        // make the system rank-deficient.
+        const bool pinned[2] = {initial_acceleration_.has_value(),
+                                final_acceleration_.has_value()};
+        for (int deriv_order = 2; deriv_order < p && row < total_rows; ++deriv_order) {
+            for (int endpoint = 0; endpoint < 2 && row < total_rows; ++endpoint) {
+                if (deriv_order == 2 && pinned[endpoint]) {
+                    continue;
+                }
+                const double t = (endpoint == 0) ? times[0] : times[n];
 
-            const int span = temp_spline.find_knot_span(t);
-            const Eigen::MatrixXd ders =
-                temp_spline.basis_function_derivatives(t, span, deriv_order);
+                const int span = temp_spline.find_knot_span(t);
+                const Eigen::MatrixXd ders =
+                    temp_spline.basis_function_derivatives(t, span, deriv_order);
 
-            for (int j = 0; j <= p; ++j) {
-                int col = span - p + j;
-                if (col >= 0 && col < num_cp) {
-                    a_matrix(row, col) = ders(deriv_order, j);
+                for (int j = 0; j <= p; ++j) {
+                    int col = span - p + j;
+                    if (col >= 0 && col < num_cp) {
+                        a_matrix(row, col) = ders(deriv_order, j);
+                    }
                 }
+                ++row;
             }
-            ++row;
         }
     }
 
@@ -223,7 +233,10 @@ BSplineInterpolator::BSplineInterpolator(
 
     Eigen::MatrixXd pts = points;
     const int num_points = static_cast<int>(pts.rows());
-    const int min_points = degree + 1;
+    // The system has n+1 interpolation rows plus p-1 (odd p) or p (even p)
+    // boundary rows against the same number of control points, so it stays
+    // square and full rank down to two points.
+    const int min_points = 2;
 
     if (num_points < min_points) {
         throw std::invalid_argument(

{interpolatepy-3.1.0 → interpolatepy-3.2.0}/cpp/src/log_quaternion_interpolation.cpp

@@ -74,9 +74,6 @@ LogQuaternionInterpolation::LogQuaternionInterpolation(
     if (degree < 3 || degree > 5) {
         throw std::invalid_argument("Degree must be 3, 4, or 5");
     }
-    if (static_cast<int>(quaternions.size()) < degree + 1) {
-        throw std::invalid_argument("Need at least degree+1 quaternions");
-    }
     for (size_t i = 1; i < time_points.size(); ++i) {
         if (time_points[i] <= time_points[i - 1]) {
             throw std::invalid_argument("Time points must be strictly increasing");

{interpolatepy-3.1.0 → interpolatepy-3.2.0}/cpp/src/modified_log_quaternion_interpolation.cpp

@@ -45,9 +45,6 @@ ModifiedLogQuaternionInterpolation::ModifiedLogQuaternionInterpolation(
     if (degree < 3 || degree > 5) {
         throw std::invalid_argument("Degree must be 3, 4, or 5");
     }
-    if (static_cast<int>(quaternions.size()) < degree + 1) {
-        throw std::invalid_argument("Need at least degree+1 quaternions");
-    }
     for (size_t i = 1; i < time_points.size(); ++i) {
         if (time_points[i] <= time_points[i - 1]) {
             throw std::invalid_argument("Time points must be strictly increasing");

{interpolatepy-3.1.0 → interpolatepy-3.2.0}/cpp/tests/test_bspline_variants.cpp

@@ -9,6 +9,7 @@
 #include "test_data.hpp"
 
 #include <cmath>
+#include <string>
 
 using namespace interpolatecpp::bspline;
 using namespace interpolatecpp::test;
@@ -172,10 +173,24 @@ TEST_CASE("BSplineInterpolator degree validation", "[bspline_interpolator]") {
         REQUIRE_THROWS_AS(BSplineInterpolator(2, pts), std::invalid_argument);
     }
 
-    SECTION("Too few points") {
-        Eigen::MatrixXd few_pts(3, 2);
-        few_pts << 0, 0, 1, 1, 2, 4;
-        REQUIRE_THROWS_AS(BSplineInterpolator(5, few_pts), std::invalid_argument);
+    SECTION("Two points suffice for every degree") {
+        Eigen::MatrixXd two_pts(2, 2);
+        two_pts << 0, 0, 1, 2;
+        for (int degree : {3, 4, 5}) {
+            BSplineInterpolator bsi(degree, two_pts);
+            auto p0 = bsi.evaluate(bsi.u_min());
+            auto p1 = bsi.evaluate(bsi.u_max());
+            REQUIRE_THAT(p0(0), WithinAbs(0.0, kNumericalAtol));
+            REQUIRE_THAT(p0(1), WithinAbs(0.0, kNumericalAtol));
+            REQUIRE_THAT(p1(0), WithinAbs(1.0, kNumericalAtol));
+            REQUIRE_THAT(p1(1), WithinAbs(2.0, kNumericalAtol));
+        }
+    }
+
+    SECTION("Fewer than two points") {
+        Eigen::MatrixXd one_pt(1, 2);
+        one_pt << 0, 0;
+        REQUIRE_THROWS_AS(BSplineInterpolator(3, one_pt), std::invalid_argument);
     }
 }
 
@@ -556,3 +571,51 @@ TEST_CASE("BSpline variant inheritance", "[bspline_variants]") {
         REQUIRE(base.evaluate(0.5).allFinite());
     }
 }
+
+// ===== Explicit acceleration constraints =====
+
+// The generated natural boundary rows start at the second derivative, so they
+// must skip whichever endpoint an acceleration already pinned. Reusing one
+// duplicates a row and the QR solve silently returns an inconsistent answer.
+TEST_CASE("BSplineInterpolator honours explicit accelerations", "[bspline_variants]") {
+    const auto pts = make_quadratic_2d(5);
+    Eigen::VectorXd times(5);
+    times << 0, 1, 2, 3, 4;
+
+    Eigen::VectorXd a0(2);
+    a0 << 0.5, -0.5;
+    Eigen::VectorXd an(2);
+    an << -0.5, 0.5;
+    Eigen::VectorXd v0(2);
+    v0 << 1.0, 0.0;
+
+    for (int degree : {3, 4, 5}) {
+        SECTION("degree " + std::to_string(degree)) {
+            SECTION("initial acceleration only") {
+                BSplineInterpolator bsi(degree, pts, times, std::nullopt, std::nullopt, a0);
+                for (int i = 0; i < 5; ++i) {
+                    REQUIRE((bsi.evaluate(times[i]) - pts.row(i).transpose()).norm() < 1e-6);
+                }
+                REQUIRE((bsi.evaluate_derivative(times[0], 2) - a0).norm() < 1e-6);
+            }
+
+            SECTION("final acceleration only") {
+                BSplineInterpolator bsi(degree, pts, times, std::nullopt, std::nullopt,
+                                        std::nullopt, an);
+                REQUIRE((bsi.evaluate_derivative(times[4], 2) - an).norm() < 1e-6);
+            }
+
+            SECTION("both accelerations") {
+                BSplineInterpolator bsi(degree, pts, times, std::nullopt, std::nullopt, a0, an);
+                REQUIRE((bsi.evaluate_derivative(times[0], 2) - a0).norm() < 1e-6);
+                REQUIRE((bsi.evaluate_derivative(times[4], 2) - an).norm() < 1e-6);
+            }
+
+            SECTION("initial velocity and acceleration") {
+                BSplineInterpolator bsi(degree, pts, times, v0, std::nullopt, a0);
+                REQUIRE((bsi.evaluate_derivative(times[0], 1) - v0).norm() < 1e-6);
+                REQUIRE((bsi.evaluate_derivative(times[0], 2) - a0).norm() < 1e-6);
+            }
+        }
+    }
+}

{interpolatepy-3.1.0 → interpolatepy-3.2.0}/interpolatepy/b_spline_interpolate.py

@@ -102,7 +102,10 @@ class BSplineInterpolator(BSpline):
 
         # Validate number of points relative to degree
         num_points = len(points)
-        min_points = degree + 1
+        # The system has n+1 interpolation rows plus p-1 (odd p) or p (even p)
+        # boundary rows against the same number of control points, so it stays
+        # square and full rank down to two points.
+        min_points = 2
         if num_points < min_points:
             raise ValueError(
                 f"Not enough points for degree {degree} B-spline interpolation. "
@@ -342,14 +345,15 @@ class BSplineInterpolator(BSpline):
                 row += 1
 
             # If we still need more constraints, add natural spline conditions
-            # (zero second derivatives at endpoints)
-            while row < n + 1 + num_additional:
-                # For cubic splines, use zero second derivatives
-                # For higher degree, can use higher derivatives
-                deriv_order = min(p - 1, 2)
-
-                # Alternate between initial and final endpoints
-                t = times[0] if row % 2 == 0 else times[-1]
+            # (zero higher derivatives at the endpoints). Walk the
+            # (derivative order, endpoint) pairs from order 2 up to p-1, skipping
+            # any pair an explicit acceleration already pinned -- reusing one
+            # would duplicate a row and make the system rank-deficient.
+            pinned = (self.initial_acceleration is not None, self.final_acceleration is not None)
+            candidates = [(2, endpoint) for endpoint in (0, 1) if not pinned[endpoint]]
+            candidates += [(order, endpoint) for order in range(3, p) for endpoint in (0, 1)]
+            for deriv_order, endpoint in candidates[: n + 1 + num_additional - row]:
+                t = times[0] if endpoint == 0 else times[-1]
 
                 span = self.temp_spline.find_knot_span(t)
                 ders = self.temp_spline.basis_function_derivatives(t, span, deriv_order)

{interpolatepy-3.1.0 → interpolatepy-3.2.0}/interpolatepy/log_quat.py

@@ -38,11 +38,6 @@ def _validate_inputs(
         raise ValueError("At least 2 quaternions are required for interpolation")
     if degree not in _VALID_DEGREES:
         raise ValueError(f"Degree must be 3, 4, or 5, got {degree}")
-    if len(quaternions) < degree + 1:
-        raise ValueError(
-            f"Not enough quaternions for degree {degree} B-spline interpolation. "
-            f"Need at least {degree + 1} quaternions, got {len(quaternions)}"
-        )
     if not np.all(np.diff(time_points) > 0):
         raise ValueError("Time points must be strictly increasing")
 

{interpolatepy-3.1.0 → interpolatepy-3.2.0}/interpolatepy/version.py

@@ -2,4 +2,4 @@
 __version__ file.
 """
 
-__version__ = "3.1.0"
+__version__ = "3.2.0"

{interpolatepy-3.1.0 → interpolatepy-3.2.0}/tests/test_b_spline_variants.py

@@ -24,6 +24,7 @@ from typing import Any
 import numpy as np
 import pytest
 
+import interpolatepy
 from interpolatepy.b_spline_approx import ApproximationBSpline
 from interpolatepy.b_spline_cubic import CubicBSplineInterpolation
 from interpolatepy.b_spline_interpolate import BSplineInterpolator
@@ -480,10 +481,6 @@ class TestBSplineInterpolator:
         with pytest.raises(ValueError, match="Degree must be 3, 4, or 5"):
             BSplineInterpolator(2, data_points)
 
-        # Test insufficient points for degree 5
-        with pytest.raises(ValueError, match="Not enough points"):
-            BSplineInterpolator(5, data_points)  # Need at least 6 points for degree 5
-
         # Test only degree 3 to avoid complex constraints
         # Use more points to ensure system is well-conditioned
         sufficient_points = [[i, i] for i in range(8)]  # 8 points
@@ -1121,3 +1118,67 @@ class TestBSplineVariantsPerformance:
 if __name__ == "__main__":
     # Run tests with detailed output
     pytest.main(["-xvs", __file__])
+
+
+@pytest.mark.parametrize("degree", [3, 4, 5])
+@pytest.mark.parametrize("num_points", [2, 3, 6])
+@pytest.mark.parametrize(
+    "constraints",
+    [
+        {},
+        {"initial_velocity": [0.0, 0.0], "final_velocity": [0.0, 0.0]},
+        {"cyclic": True},
+    ],
+)
+def test_public_api_interpolates_from_two_points(
+    degree: int, num_points: int, constraints: dict[str, Any]
+) -> None:
+    """Any degree interpolates down to two points, on whichever backend is active.
+
+    Runs against ``interpolatepy.BSplineInterpolator``, which resolves to the C++
+    implementation when it is compiled in, so the two backends stay in step.
+    """
+    points = np.array([[float(i), float(i * i)] for i in range(num_points)])
+    times = [float(i) for i in range(num_points)]
+
+    spline = interpolatepy.BSplineInterpolator(degree, points, times=times, **constraints)
+
+    for t, expected in zip(times, points, strict=True):
+        assert np.allclose(spline.evaluate(t), expected, atol=1e-6)
+
+
+@pytest.mark.parametrize("degree", [3, 4, 5])
+@pytest.mark.parametrize(
+    "constraints",
+    [
+        {"initial_acceleration": [0.5, -0.5]},
+        {"final_acceleration": [0.5, -0.5]},
+        {"initial_acceleration": [0.5, -0.5], "final_acceleration": [-0.5, 0.5]},
+        {"initial_velocity": [1.0, 0.0], "initial_acceleration": [0.5, -0.5]},
+        {"final_velocity": [1.0, 0.0], "final_acceleration": [0.5, -0.5]},
+    ],
+)
+def test_acceleration_constraints_are_honoured(
+    degree: int, constraints: dict[str, Any]
+) -> None:
+    """Explicit accelerations must not collide with the generated natural rows.
+
+    The fallback boundary rows start at the second derivative, so they have to skip
+    whichever endpoint an acceleration already pinned; otherwise the row is repeated
+    and the system goes rank-deficient (Python) or solves inconsistently (C++).
+    """
+    points = np.array([[float(i), float(i * i)] for i in range(5)])
+    times = [float(i) for i in range(5)]
+
+    spline = interpolatepy.BSplineInterpolator(degree, points, times=times, **constraints)
+
+    for t, expected in zip(times, points, strict=True):
+        assert np.allclose(spline.evaluate(t), expected, atol=1e-6)
+
+    endpoints = {"initial": times[0], "final": times[-1]}
+    orders = {"velocity": 1, "acceleration": 2}
+    for name, value in constraints.items():
+        when, _, what = name.partition("_")
+        assert np.allclose(
+            spline.evaluate_derivative(endpoints[when], orders[what]), value, atol=1e-6
+        ), f"{name} not satisfied for degree {degree}"

{interpolatepy-3.1.0 → interpolatepy-3.2.0}/tests/test_log_quat.py

@@ -12,12 +12,15 @@ robust behavior across different use cases.
 import numpy as np
 import pytest
 
+import interpolatepy
 from interpolatepy.quat_core import Quaternion
 from interpolatepy.log_quat import (
     LogQuaternionInterpolation,
     ModifiedLogQuaternionInterpolation,
 )
 
+_NUMERICAL_ATOL = 1e-6
+
 
 class TestLogQuaternionInterpolation:
     """Test suite for LogQuaternionInterpolation (LQI) class."""
@@ -80,10 +83,6 @@ class TestLogQuaternionInterpolation:
         with pytest.raises(ValueError, match="Degree must be 3, 4, or 5"):
             LogQuaternionInterpolation(time_points, quaternions, degree=2)
 
-        # Not enough points for degree
-        with pytest.raises(ValueError, match="Not enough quaternions for degree"):
-            LogQuaternionInterpolation([0.0, 1.0], [Quaternion.identity(), Quaternion.identity()], degree=5)
-
         # Non-increasing time points
         bad_times = [0.0, 2.0, 1.0, 3.0, 4.0]
         with pytest.raises(ValueError, match="Time points must be strictly increasing"):
@@ -283,10 +282,6 @@ class TestModifiedLogQuaternionInterpolation:
         with pytest.raises(ValueError, match="Degree must be 3, 4, or 5"):
             ModifiedLogQuaternionInterpolation(time_points, quaternions, degree=2)
 
-        # Not enough points for degree
-        with pytest.raises(ValueError, match="Not enough quaternions for degree"):
-            ModifiedLogQuaternionInterpolation([0.0, 1.0], [Quaternion.identity(), Quaternion.identity()], degree=5)
-
         # Non-increasing time points
         bad_times = [0.0, 2.0, 1.0, 3.0, 4.0]
         with pytest.raises(ValueError, match="Time points must be strictly increasing"):
@@ -432,6 +427,30 @@ class TestModifiedLogQuaternionInterpolation:
         assert abs(abs(dot_product) - 1.0) < self.NUMERICAL_ATOL
 
 
+@pytest.mark.parametrize(
+    "cls_name", ["LogQuaternionInterpolation", "ModifiedLogQuaternionInterpolation"]
+)
+@pytest.mark.parametrize("degree", [3, 4, 5])
+@pytest.mark.parametrize("num_quats", [2, 3, 5])
+def test_public_api_interpolates_from_two_quaternions(
+    cls_name: str, degree: int, num_quats: int
+) -> None:
+    """Any degree interpolates down to two quaternions, on whichever backend is active.
+
+    Uses the ``interpolatepy`` public names, which resolve to the C++ implementation
+    when it is compiled in, so the two backends stay in step.
+    """
+    cls = getattr(interpolatepy, cls_name)
+    times = [float(i) for i in range(num_quats)]
+    quats = [Quaternion.from_euler_angles(0.3 * i, 0.2 * i, 0.1 * i) for i in range(num_quats)]
+
+    interp = cls(times, quats, degree=degree)
+
+    for t, expected in zip(times, quats, strict=True):
+        # Quaternions double-cover rotations, so compare |dot| against 1.
+        assert abs(abs(interp.evaluate(t).dot_prod(expected)) - 1.0) < _NUMERICAL_ATOL
+
+
 if __name__ == "__main__":
     # Run tests with detailed output
     pytest.main(["-xvs", __file__])