Merge PR #210: fix: Twist3 * SpatialVector raised ValueError instead of dispatching

Author: taughz

spatialmath/twist.py

@@ -1107,14 +1107,18 @@ def __mul__(
         Twist3    scalar                Twist3               element-wise product
         scalar    Twist3                Twist3               element-wise product
         Twist3    SE3                   Twist3               exponential x SE3
+        Twist3    SpatialVector         SpatialVector        adjoint/coadjoint product
         ========  ====================  ===================  ========================
 
         .. note::
 
             #. scalar x Twist is handled by ``__rmul__``
             #. scalar multiplication is commutative but the result is not a group
                operation so the result will be a matrix
-            #. Any other input combinations result in a ValueError.
+            #. ``Twist3 * SpatialVector`` (velocity, acceleration, force, momentum)
+               is handled by falling back to
+               :meth:`~spatialmath.spatialvector.SpatialVector.__rmul__`.
+            #. Any other input combination raises a ``TypeError``.
 
         For pose composition the ``left`` and ``right`` operands may be a sequence
 
@@ -1147,7 +1151,11 @@ def __mul__(
             # return Twist(left.S * right)
             return Twist3(left.binop(right, lambda x, y: x * y))
         else:
-            raise ValueError("twist *, incorrect right operand")
+            # not a type we handle directly -- return NotImplemented so Python
+            # falls back to right.__rmul__(left), which SpatialVector (velocity,
+            # acceleration, force, momentum) defines. If right has no __rmul__
+            # either, Python raises its own TypeError.
+            return NotImplemented
 
     def __rmul__(
         right, left

tests/test_spatialvector.py

@@ -225,8 +225,23 @@ def test_products(self):
         # v x v = a  *, v x F6 = a
         # a x I, I x a
         # v x I, I x v
-        # twist x v, twist x a, twist x F
-        pass
+
+        # twist x v, twist x a, twist x F, twist x momentum
+        T = SE3(1, 2, 3) * SE3.Rx(0.3)
+        S = Twist3(T)
+
+        v = SpatialVelocity([1, 2, 3, 4, 5, 6])
+        a = SpatialAcceleration([1, 2, 3, 4, 5, 6])
+        f = SpatialForce([1, 2, 3, 4, 5, 6])
+        m = SpatialMomentum([1, 2, 3, 4, 5, 6])
+
+        # Twist3 * X must agree with the equivalent SE3 * X: same
+        # underlying transform, two ways of expressing it.
+        for x in (v, a, f, m):
+            result = S * x
+            expected = T * x
+            self.assertIsInstance(result, type(x))
+            nt.assert_almost_equal(result.A, expected.A)
 
     def test_spatial_transform_duality(self):
         # A pose transform acts on motion (velocity/acceleration) by the