rational-linkages 2.1.0__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 2.2.3__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

rational_linkages/CollisionAnalyser.py

@@ -1,8 +1,8 @@
 import numpy
-import sympy
-from scipy.optimize import minimize
 
-from . import LineSegment
+from sympy import symbols, Poly
+
+from .Linkage import LineSegment
 from .DualQuaternion import DualQuaternion
 from .NormalizedLine import NormalizedLine
 from .PointHomogeneous import PointHomogeneous, PointOrbit
@@ -47,11 +47,11 @@ class CollisionAnalyser:
 
         relative_motions = branch0 + branch1[::-1]
 
-        t = sympy.symbols('t')
+        t = symbols('t')
 
         motions = []
         for motion in relative_motions:
-            motions.append(RationalCurve([sympy.Poly(c, t, greedy=False)
+            motions.append(RationalCurve([Poly(c, t, greedy=False)
                                           for c in motion],
                                          metric=self.metric))
         return motions
@@ -296,6 +296,11 @@ class CollisionAnalyser:
         """
         Optimize the link control points to avoid collisions with the bounding orbits.
         """
+        try:
+            from scipy.optimize import minimize  # lazy import
+        except ImportError:
+            raise RuntimeError("Scipy import failed. Check its installation.")
+
         def flatten_cps(cps):
             return numpy.array([cp.normalized_in_3d() for cp in cps]).flatten()
 
@@ -348,11 +353,11 @@ class CollisionAnalyser:
         :param min_splits: Minimum number of splits for the bezier curves.
         """
 
-        t = sympy.symbols('t')
+        t = symbols('t')
         motions = []
         for i, idx in enumerate(reduced_indices):
             rel_motion = self.mechanism.relative_motion(segment_id_number, idx)
-            motions.append(RationalCurve([sympy.Poly(c, t, greedy=False)
+            motions.append(RationalCurve([Poly(c, t, greedy=False)
                                           for c in rel_motion],
                                          metric=self.metric))
 

rational_linkages/CollisionFreeOptimization.py

@@ -30,7 +30,10 @@ class CollisionFreeOptimization:
             parameters of the points, result of the optimization
         :rtype: tuple
         """
-        from scipy.optimize import minimize
+        try:
+            from scipy.optimize import minimize  # lazy import
+        except ImportError:
+            raise RuntimeError("Scipy import failed. Check its installation.")
 
         # get the axes represented as normalized lines
         if len(self.mechanism.factorizations) == 1:

rational_linkages/DualQuaternion.py

@@ -226,10 +226,13 @@ class DualQuaternion:
         :return: DualQuaternion with rational elements
         :rtype: DualQuaternion
         """
-        from sympy import Rational, nsimplify
+        from sympy import Rational
 
         if study_parameters is not None:
-            rational_numbers = [nsimplify(x, tolerance=1*(-10)) for x in study_parameters]
+            rational_numbers = [x if isinstance(x, Expr)
+                                else Rational(*x) if isinstance(x, tuple)
+                                else Rational(x)
+                                for x in study_parameters]
         else:
             rational_numbers = [Rational(1), Rational(0), Rational(0), Rational(0),
                                 Rational(0), Rational(0), Rational(0), Rational(0)]

rational_linkages/FactorizationProvider.py

@@ -3,7 +3,8 @@ from warnings import warn
 
 import biquaternion_py
 import numpy as np
-import sympy as sp
+
+from sympy import Symbol, Rational
 
 from .DualQuaternion import DualQuaternion
 from .MotionFactorization import MotionFactorization
@@ -45,7 +46,7 @@ class FactorizationProvider:
 
         :warning: If the given curve has not only rational numbers as input.
         """
-        t = sp.Symbol("t")
+        t = Symbol("t")
 
         if isinstance(curve, RationalCurve):
             bi_quat = biquaternion_py.BiQuaternion(curve.extract_expressions())
@@ -58,7 +59,7 @@ class FactorizationProvider:
             poly_coeffs = bi_poly.all_coeffs()
             for i in range(len(poly_coeffs)):
                 for j in range(len(poly_coeffs[i].args)):
-                    if not isinstance(poly_coeffs[i].args[j], sp.Rational):
+                    if not isinstance(poly_coeffs[i].args[j], Rational):
                         warn('The given curve has not only rational numbers as input. The factorization will be performed with floating point numbers, but may be instable.')
                         break
 
@@ -92,7 +93,7 @@ class FactorizationProvider:
                          'as input. The factorization will be performed with floating '
                          'point numbers, but may be instable.')
 
-        t = sp.Symbol("t")
+        t = Symbol("t")
 
         bi_poly = t - biquaternion_py.BiQuaternion(factorization.dq_axes[0].array())
         for i in range(1, factorization.number_of_factors):
@@ -147,7 +148,7 @@ class FactorizationProvider:
         :return: The rotation axis of the factor.
         :rtype: DualQuaternion
         """
-        t = sp.Symbol("t")
+        t = Symbol("t")
         t_dq = DualQuaternion([t, 0, 0, 0, 0, 0, 0, 0])
 
         factor_dq = DualQuaternion(factor.poly.coeffs)

rational_linkages/MiniBall.py

@@ -1,5 +1,4 @@
 import numpy as np
-from scipy.optimize import minimize
 
 from .AffineMetric import AffineMetric
 from .PointHomogeneous import PointHomogeneous
@@ -55,6 +54,14 @@ class MiniBall:
         return PointHomogeneous(center), radius_squared
 
     def get_ball_minimize(self):
+        """
+        Find the smallest ball containing all given points using optimization
+        """
+        try:
+            from scipy.optimize import minimize  # lazy import
+        except ImportError:
+            raise RuntimeError("Scipy import failed. Check the package installation.")
+
         def objective_function(x):
             """
             Objective function to minimize the squared radius r^2 of the ball

rational_linkages/MotionApproximation.py

@@ -1,13 +1,17 @@
 from typing import Union
 
 import numpy as np
-from scipy.optimize import minimize
 
 from .AffineMetric import AffineMetric
 from .DualQuaternion import DualQuaternion
 from .PointHomogeneous import PointHomogeneous
 from .RationalCurve import RationalCurve
 
+try:
+    from scipy.optimize import minimize  # lazy import, optional dependency
+except ImportError:
+    minimize = None
+
 ### NOT YET in the documentation ### TODO: add to docs