Make vector projections independent of direction scale (#242)

`project(v1, v2)` currently multiplies by `dot(v1, v2)` without dividing
by `dot(v2, v2)`. As a result, projecting `[3,1,4]` onto `[2,2,0]`
returns `[16,16,0]` instead of `[2,2,0]`; `orthogonalize()` then
produces a vector that is not perpendicular to its reference direction.
List/tuple direction inputs also raise TypeError.

Convert the documented array-like arguments to vectors and compute the
full projection formula. Rescale the direction before dot products so
very small/large directions do not underflow/overflow. Keep the
historical zero-direction result.

Validation: two regressions fail before the fix; the zero-direction
control passes. Tests cover signed/scaled directions, list/tuple inputs,
scales1e-200 and1e200, and normalized/unnormalized perpendicular
results. All184 base+pose3d tests pass with1 skip and8 existing
warnings; repository-pinned Black23.10.0 and `git diff --check` pass.

Prepared with AI assistance.

Author: xiehuanyi

spatialmath/base/vectors.py

@@ -829,7 +829,14 @@ def project(v1: ArrayLike3, v2: ArrayLike3) -> ArrayLike3:
     :return: vector projection of v1 onto v2 (parrallel to v2)
     :rtype: ndarray(n)
     """
-    return np.dot(v1, v2) * v2
+    v1 = getvector(v1)
+    v2 = getvector(v2)
+    scale = np.max(np.abs(v2))
+    if scale == 0:
+        return np.zeros_like(v2)
+    # Normalize the scale before dot products to avoid over/underflow.
+    v2 = v2 / scale
+    return (np.dot(v1, v2) / np.dot(v2, v2)) * v2
 
 
 def orthogonalize(v1: ArrayLike3, v2: ArrayLike3, normalize: bool = True) -> ArrayLike3:

tests/base/test_vectors.py

@@ -33,6 +33,23 @@ class TestVector(unittest.TestCase):
     def tearDownClass(cls):
         plt.close("all")
 
+    def test_project_nonunit_direction(self):
+        for scale in (1, 2, -3, 1e-200, 1e200):
+            direction = np.array([scale, scale, 0])
+            nt.assert_allclose(project([3, 1, 4], direction), [2, 2, 0])
+        nt.assert_allclose(project((3, 1, 4), (2, 2, 0)), [2, 2, 0])
+
+    def test_orthogonalize_nonunit_direction(self):
+        result = orthogonalize([3, 1, 4], [2, 2, 0], normalize=False)
+        nt.assert_allclose(result, [1, -1, 4])
+        self.assertAlmostEqual(np.dot(result, [2, 2, 0]), 0)
+        normalized = orthogonalize([3, 1, 4], [2, 2, 0])
+        self.assertAlmostEqual(np.linalg.norm(normalized), 1)
+        self.assertAlmostEqual(np.dot(normalized, [2, 2, 0]), 0)
+
+    def test_project_zero_direction(self):
+        nt.assert_array_equal(project([1, 2, 3], [0, 0, 0]), [0, 0, 0])
+
     def test_unit(self):
         nt.assert_array_almost_equal(unitvec([1, 0, 0]), np.r_[1, 0, 0])
         nt.assert_array_almost_equal(unitvec([0, 1, 0]), np.r_[0, 1, 0])