Mote Point::lerp to the point.rs file.

src/base/interpolation.rs

@@ -1,7 +1,6 @@
 use crate::storage::Storage;
 use crate::{
-    Allocator, DefaultAllocator, Dim, DimName, OPoint, OVector, One, RealField, Scalar, Unit,
+    Allocator, DefaultAllocator, Dim, OVector, One, RealField, Scalar, Unit, Vector, Zero,
-    Vector, Zero,
 };
 use simba::scalar::{ClosedAdd, ClosedMul, ClosedSub};
 
@@ -59,31 +58,6 @@ impl<T: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Stor
     }
 }
 
-/// # Interpolation
-impl<T: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: DimName> OPoint<T, D>
-where
-    DefaultAllocator: Allocator<T, D>,
-{
-    /// Returns `self * (1.0 - t) + rhs.coords * t`, i.e., the linear blend of the points x and y using the scalar value a.
-    ///
-    /// The value for a is not restricted to the range `[0, 1]`.
-    ///
-    /// # Examples:
-    ///
-    /// ```
-    /// # use nalgebra::Point3;
-    /// let x = Point3::new(1.0, 2.0, 3.0);
-    /// let y = Point3::new(10.0, 20.0, 30.0);
-    /// assert_eq!(x.lerp(&y, 0.1), Point3::new(1.9, 3.8, 5.7));
-    /// ```
-    #[must_use]
-    pub fn lerp(&self, rhs: &OPoint<T, D>, t: T) -> OPoint<T, D> {
-        OPoint {
-            coords: self.coords.lerp(&rhs.coords, t),
-        }
-    }
-}
-
 /// # Interpolation between two unit vectors
 impl<T: RealField, D: Dim, S: Storage<T, D>> Unit<Vector<T, D, S>> {
     /// Computes the spherical linear interpolation between two unit vectors.

src/geometry/point.rs

@@ -1,5 +1,5 @@
 use approx::{AbsDiffEq, RelativeEq, UlpsEq};
-use num::One;
+use num::{One, Zero};
 use std::cmp::Ordering;
 use std::fmt;
 use std::hash;
@@ -13,6 +13,7 @@ use crate::base::allocator::Allocator;
 use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
 use crate::base::iter::{MatrixIter, MatrixIterMut};
 use crate::base::{Const, DefaultAllocator, OVector, Scalar};
+use simba::scalar::{ClosedAdd, ClosedMul, ClosedSub};
 use std::mem::MaybeUninit;
 
 /// A point in an euclidean space.
@@ -221,6 +222,31 @@ where
         unsafe { res.assume_init() }
     }
 
+    /// Linear interpolation between two points.
+    ///
+    /// Returns `self * (1.0 - t) + rhs.coords * t`, i.e., the linear blend of the points
+    /// `self` and `rhs` using the scalar value `t`.
+    ///
+    /// The value for a is not restricted to the range `[0, 1]`.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # use nalgebra::Point3;
+    /// let a = Point3::new(1.0, 2.0, 3.0);
+    /// let b = Point3::new(10.0, 20.0, 30.0);
+    /// assert_eq!(a.lerp(&b, 0.1), Point3::new(1.9, 3.8, 5.7));
+    /// ```
+    #[must_use]
+    pub fn lerp(&self, rhs: &OPoint<T, D>, t: T) -> OPoint<T, D>
+    where
+        T: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul,
+    {
+        OPoint {
+            coords: self.coords.lerp(&rhs.coords, t),
+        }
+    }
+
     /// Creates a new point with the given coordinates.
     #[deprecated(note = "Use Point::from(vector) instead.")]
     #[inline]