fix(deep_causality_num): The slerp implementation has been corrected by removing the incorrect special case for antipodal quaternions and adding a check for nearly identical quaternions to use linear interpolation, preventing division by

zero. The corresponding test case has been updated to reflect the new
behavior. All tests pass.

Signed-off-by: Marvin Hansen <[email protected]>

Author: marvin-hansen

deep_causality_num/src/quaternion/arithmetic.rs

@@ -191,7 +191,8 @@ impl<F: Float> Div<F> for Quaternion<F> {
             y: self.y * inv_scalar,
             z: self.z * inv_scalar,
         }
-    }}
+    }
+}
 
 // Rem (Placeholder for now, as quaternion remainder is not standard)
 impl<F: Float> Rem for Quaternion<F> {

deep_causality_num/src/quaternion/rotation.rs

@@ -134,25 +134,16 @@ where
 
         let mut dot = q1.dot(&q2);
 
-        // If the quaternions are very close (dot product near 1 or -1)
-        if dot.abs() > F::one() - F::epsilon() {
-            // If they are antipodal and t = 0.5, return identity
-            if dot < F::zero() && t == F::from(0.5).unwrap() {
-                return Quaternion::identity();
-            }
-            // Otherwise, they are either identical or antipodal but t is not 0.5.
-            // In either case, linear interpolation is a good approximation.
-            return (q1 * (F::one() - t) + q2 * t).normalize();
-        }
-
-        // If the dot product is negative, the quaternions are "opposite"
-        // and slerp will take the long way around.
         // We can negate one of the quaternions to take the short way.
         if dot < F::zero() {
             q2 = -q2;
             dot = -dot;
         }
 
+        // If the quaternions are very close, use linear interpolation to avoid division by zero.
+        if dot > F::one() - F::epsilon() {
+            return (q1 * (F::one() - t) + q2 * t).normalize();
+        }
         // Clamp dot to avoid NaN from acos due to floating point inaccuracies
         dot = dot.clamp(-F::one(), F::one());
         let theta = dot.acos();

deep_causality_num/tests/quaternion/rotation_tests.rs

@@ -179,11 +179,11 @@ fn test_slerp_antipodal() {
     let q4 = Quaternion::new(0.0, 0.0, 0.0, -1.0); // -180 deg around Z
     let slerp_opposite = q3.slerp(&q4, 0.5);
 
-    // Should be identity or very close to it
-    assert!((slerp_opposite.w - 1.0).abs() < EPSILON);
+    // Should be q3 (0,0,0,1) after negation and linear interpolation
+    assert!((slerp_opposite.w - 0.0).abs() < EPSILON);
     assert!((slerp_opposite.x - 0.0).abs() < EPSILON);
     assert!((slerp_opposite.y - 0.0).abs() < EPSILON);
-    assert!((slerp_opposite.z - 0.0).abs() < EPSILON);
+    assert!((slerp_opposite.z - 1.0).abs() < EPSILON);
 }
 
 #[test]