Add points.

This adds the Pnt{1,2,3,4,5,6} structures.
This adds the traits:
  − AnyPnt
  − FloatPnt
  − PntExt
  − FloatPntExt
  − Orig (to return the zero point)
  − PntAsVec
  − VecAsPnt
This adds operator overloading:
  − Pnt + Vec
  − Pnt - Vec
  − Pnt * Scalar
  − Pnt / Scalar
  − Pnt + Scalar
  − Pnt - Scalar
  − Iso * Pnt
  − Rot * Pnt
  − Pnt * Iso
  − Pnt * Rot
This changes some behavior:
  − Iso multiplication with a Vec does not translate the vector any more.
  − ToHomogeneous adds a 0.0 at the end of a Vec and a 1.0 at the end of a Pnt.
  − FromHomogeneous performs w-normalization on a Pnt, but not on a Vec.
  − The Translate<Vec> trait is never implemented (i-e. a Vec is not to be translated).

cc #25

.gitignore

@@ -4,3 +4,4 @@ doc
 lib
 TODO
 target/
+Cargo.lock

src/lib.rs

@@ -115,6 +115,7 @@ pub use traits::{
     Absolute,
     AbsoluteRotate,
     AnyVec,
+    AnyPnt,
     ApproxEq,
     Basis,
     Cast,
@@ -128,6 +129,8 @@ pub use traits::{
     Dim,
     Dot,
     Eye,
+    FloatPnt,
+    FloatPntExt,
     FloatVec,
     FloatVecExt,
     FromHomogeneous,
@@ -139,9 +142,13 @@ pub use traits::{
     Mat,
     Mean,
     Norm,
+    Orig,
     Outer,
     PartialOrd,
     PartialOrdering,
+    PntAsVec,
+    PntExt,
+    Projector,
     RMul,
     Rotate, Rotation, RotationMatrix, RotationWithTranslation,
     Row,
@@ -152,6 +159,7 @@ pub use traits::{
     Translate, Translation,
     Transpose,
     UniformSphereSample,
+    VecAsPnt,
     VecExt
 };
 
@@ -163,7 +171,8 @@ pub use structs::{
     Mat1, Mat2, Mat3, Mat4,
     Mat5, Mat6,
     Rot2, Rot3, Rot4,
-    Vec0, Vec1, Vec2, Vec3, Vec4, Vec5, Vec6
+    Vec0, Vec1, Vec2, Vec3, Vec4, Vec5, Vec6,
+    Pnt0, Pnt1, Pnt2, Pnt3, Pnt4, Pnt5, Pnt6
 };
 
 pub use linalg::{
@@ -337,6 +346,27 @@ pub fn one<T: One>() -> T {
 //
 //
 
+/// Returns the trivial origin of an affine space.
+#[inline(always)]
+pub fn orig<T: Orig>() -> T {
+    Orig::orig()
+}
+
+/*
+ * FloatPnt
+ */
+/// Returns the distance between two points.
+#[inline(always)]
+pub fn dist<N: Float, P: FloatPnt<N, V>, V: Norm<N>>(a: &P, b: &P) -> N {
+    FloatPnt::<N, V>::dist(a, b)
+}
+
+/// Returns the squared distance between two points.
+#[inline(always)]
+pub fn sqdist<N: Float, P: FloatPnt<N, V>, V: Norm<N>>(a: &P, b: &P) -> N {
+    FloatPnt::<N, V>::sqdist(a, b)
+}
+
 /*
  * Perspective
  */
@@ -405,46 +435,46 @@ pub fn append_translation<V, M: Translation<V>>(m: &M, v: &V) -> M {
 }
 
 /*
- * Translate<V>
+ * Translate<P>
  */
 
-/// Applies a translation to a vector.
+/// Applies a translation to a point.
 ///
 /// ```rust
 /// extern crate "nalgebra" as na;
-/// use na::{Vec3, Iso3};
+/// use na::{Pnt3, Vec3, Iso3};
 ///
 /// fn main() {
 ///     let t  = Iso3::new(Vec3::new(1.0f64, 1.0, 1.0), na::zero());
-///     let v  = Vec3::new(2.0, 2.0, 2.0);
+///     let p  = Pnt3::new(2.0, 2.0, 2.0);
 ///
-///     let tv = na::translate(&t, &v);
+///     let tp = na::translate(&t, &p);
 ///
-///     assert!(tv == Vec3::new(3.0, 3.0, 3.0))
+///     assert!(tp == Pnt3::new(3.0, 3.0, 3.0))
 /// }
 /// ```
 #[inline(always)]
-pub fn translate<V, M: Translate<V>>(m: &M, v: &V) -> V {
+pub fn translate<P, M: Translate<P>>(m: &M, p: &P) -> P {
-    m.translate(v)
+    m.translate(p)
 }
 
-/// Applies an inverse translation to a vector.
+/// Applies an inverse translation to a point.
 ///
 /// ```rust
 /// extern crate "nalgebra" as na;
-/// use na::{Vec3, Iso3};
+/// use na::{Pnt3, Vec3, Iso3};
 ///
 /// fn main() {
 ///     let t  = Iso3::new(Vec3::new(1.0f64, 1.0, 1.0), na::zero());
-///     let v  = Vec3::new(2.0, 2.0, 2.0);
+///     let p  = Pnt3::new(2.0, 2.0, 2.0);
 ///
-///     let tv = na::inv_translate(&t, &v);
+///     let tp = na::inv_translate(&t, &p);
 ///
-///     assert!(na::approx_eq(&tv, &Vec3::new(1.0, 1.0, 1.0)))
+///     assert!(na::approx_eq(&tp, &Pnt3::new(1.0, 1.0, 1.0)))
 /// }
 #[inline(always)]
-pub fn inv_translate<V, M: Translate<V>>(m: &M, v: &V) -> V {
+pub fn inv_translate<P, M: Translate<P>>(m: &M, p: &P) -> P {
-    m.inv_translate(v)
+    m.inv_translate(p)
 }
 
 /*
@@ -666,12 +696,6 @@ pub fn dot<V: Dot<N>, N>(a: &V, b: &V) -> N {
     Dot::dot(a, b)
 }
 
-/// Computes a subtraction followed by a dot product.
-#[inline(always)]
-pub fn sub_dot<V: Dot<N>, N>(a: &V, b: &V, c: &V) -> N {
-    Dot::sub_dot(a, b, c)
-}
-
 /*
  * Norm<N>
  */

src/na.rs

@@ -431,13 +431,6 @@ pub fn dot<V: Dot<N>, N>(a: &V, b: &V) -> N {
     super::dot(a, b)
 }
 
-/// Computes a subtraction followed by a dot product.
-#[inline(always)]
-#[deprecated = "use the root module `nalgebra::` directly instead of the `nalgebra::na::` module (you may create an alias `extern crate \"nalgebra\" as na;` when importing the crate)"]
-pub fn sub_dot<V: Dot<N>, N>(a: &V, b: &V, c: &V) -> N {
-    super::sub_dot(a, b, c)
-}
-
 /*
  * Norm<N>
  */

src/structs/dvec_macros.rs

@@ -220,17 +220,6 @@ macro_rules! dvec_impl(
 
                 res
             }
-
-            #[inline]
-            fn sub_dot(a: &$dvec<N>, b: &$dvec<N>, c: &$dvec<N>) -> N {
-                let mut res: N = Zero::zero();
-
-                for i in range(0u, a.len()) {
-                    res = res + unsafe { (a.unsafe_at(i) - b.unsafe_at(i)) * c.unsafe_at(i) };
-                }
-
-                res
-            }
         }
 
         impl<N: Float + Clone> Norm<N> for $dvec<N> {

src/structs/iso.rs

@@ -11,6 +11,7 @@ use traits::geometry::{RotationMatrix, Rotation, Rotate, AbsoluteRotate, Transfo
                        Translate, Translation, ToHomogeneous};
 
 use structs::vec::{Vec1, Vec2, Vec3, Vec4, Vec2MulRhs, Vec3MulRhs, Vec4MulRhs};
+use structs::pnt::{Pnt2, Pnt3, Pnt4, Pnt2MulRhs, Pnt3MulRhs, Pnt4MulRhs};
 use structs::rot::{Rot2, Rot3, Rot4};
 
 
@@ -104,14 +105,16 @@ rand_impl!(Iso2)
 approx_eq_impl!(Iso2)
 to_homogeneous_impl!(Iso2, Mat3)
 inv_impl!(Iso2)
-transform_impl!(Iso2, Vec2)
+transform_impl!(Iso2TransformRhs, Iso2, Vec2, Pnt2)
 transformation_impl!(Iso2)
 rotate_impl!(Iso2, Vec2)
 translation_impl!(Iso2, Vec2)
-translate_impl!(Iso2, Vec2)
+translate_impl!(Iso2, Pnt2)
 iso_mul_iso_impl!(Iso2, Iso2MulRhs)
 iso_mul_vec_impl!(Iso2, Vec2, Iso2MulRhs)
 vec_mul_iso_impl!(Iso2, Vec2, Vec2MulRhs)
+iso_mul_pnt_impl!(Iso2, Pnt2, Iso2MulRhs)
+pnt_mul_iso_impl!(Iso2, Pnt2, Pnt2MulRhs)
 
 iso_impl!(Iso3, Rot3, Vec3, Vec3)
 double_dispatch_binop_decl_trait!(Iso3, Iso3MulRhs)
@@ -125,14 +128,16 @@ rand_impl!(Iso3)
 approx_eq_impl!(Iso3)
 to_homogeneous_impl!(Iso3, Mat4)
 inv_impl!(Iso3)
-transform_impl!(Iso3, Vec3)
+transform_impl!(Iso3TransformRhs, Iso3, Vec3, Pnt3)
 transformation_impl!(Iso3)
 rotate_impl!(Iso3, Vec3)
 translation_impl!(Iso3, Vec3)
-translate_impl!(Iso3, Vec3)
+translate_impl!(Iso3, Pnt3)
 iso_mul_iso_impl!(Iso3, Iso3MulRhs)
 iso_mul_vec_impl!(Iso3, Vec3, Iso3MulRhs)
 vec_mul_iso_impl!(Iso3, Vec3, Vec3MulRhs)
+iso_mul_pnt_impl!(Iso3, Pnt3, Iso3MulRhs)
+pnt_mul_iso_impl!(Iso3, Pnt3, Pnt3MulRhs)
 
 // iso_impl!(Iso4, Rot4, Vec4, Vec4)
 double_dispatch_binop_decl_trait!(Iso4, Iso4MulRhs)
@@ -146,11 +151,13 @@ absolute_rotate_impl!(Iso4, Vec4)
 approx_eq_impl!(Iso4)
 to_homogeneous_impl!(Iso4, Mat5)
 inv_impl!(Iso4)
-transform_impl!(Iso4, Vec4)
+transform_impl!(Iso4TransformRhs, Iso4, Vec4, Pnt4)
 transformation_impl!(Iso4)
 rotate_impl!(Iso4, Vec4)
 translation_impl!(Iso4, Vec4)
-translate_impl!(Iso4, Vec4)
+translate_impl!(Iso4, Pnt4)
 iso_mul_iso_impl!(Iso4, Iso4MulRhs)
 iso_mul_vec_impl!(Iso4, Vec4, Iso4MulRhs)
 vec_mul_iso_impl!(Iso4, Vec4, Vec4MulRhs)
+iso_mul_pnt_impl!(Iso4, Pnt4, Iso4MulRhs)
+pnt_mul_iso_impl!(Iso4, Pnt4, Pnt4MulRhs)

src/structs/iso_macros.rs

@@ -77,13 +77,35 @@ macro_rules! iso_mul_vec_impl(
         impl<N: Num + Clone> $tmul<N, $tv<N>> for $tv<N> {
             #[inline]
             fn binop(left: &$t<N>, right: &$tv<N>) -> $tv<N> {
-                left.translation + left.rotation * *right
+                left.rotation * *right
             }
         }
     )
 )
 
 macro_rules! vec_mul_iso_impl(
+    ($t: ident, $tv: ident, $tmul: ident) => (
+        impl<N: Clone + Num> $tmul<N, $tv<N>> for $t<N> {
+            #[inline]
+            fn binop(left: &$tv<N>, right: &$t<N>) -> $tv<N> {
+                left * right.rotation
+            }
+        }
+    )
+)
+
+macro_rules! iso_mul_pnt_impl(
+    ($t: ident, $tv: ident, $tmul: ident) => (
+        impl<N: Num + Clone> $tmul<N, $tv<N>> for $tv<N> {
+            #[inline]
+            fn binop(left: &$t<N>, right: &$tv<N>) -> $tv<N> {
+                left.rotation * *right + left.translation
+            }
+        }
+    )
+)
+
+macro_rules! pnt_mul_iso_impl(
     ($t: ident, $tv: ident, $tmul: ident) => (
         impl<N: Clone + Num> $tmul<N, $tv<N>> for $t<N> {
             #[inline]
@@ -254,16 +276,49 @@ macro_rules! transformation_impl(
 )
 
 macro_rules! transform_impl(
-    ($t: ident, $tv: ident) => (
+    ($trhs: ident, $t: ident, $tv: ident, $tp: ident) => (
-        impl<N: Num + Clone> Transform<$tv<N>> for $t<N> {
+        /*
+         * FIXME: we use the double dispatch trick here so that we can transform vectors _and_
+         * points. Remove this as soon as rust supports multidispatch.
+         */
+        pub trait $trhs<N> {
+            fn transform(left: &$t<N>, right: &Self) -> Self;
+            fn inv_transform(left: &$t<N>, right: &Self) -> Self;
+        }
+
+        impl<N, V: $trhs<N>> Transform<V> for $t<N> {
+            #[inline(always)]
+            fn transform(&self, other: &V) -> V {
+                $trhs::transform(self, other)
+            }
+
+            #[inline(always)]
+            fn inv_transform(&self, other: &V) -> V {
+                $trhs::inv_transform(self, other)
+            }
+        }
+
+        impl<N: Num + Clone> $trhs<N> for $tv<N> {
             #[inline]
-            fn transform(&self, v: &$tv<N>) -> $tv<N> {
+            fn transform(t: &$t<N>, v: &$tv<N>) -> $tv<N> {
-                self.rotation.transform(v) + self.translation
+                t.rotation.transform(v)
             }
 
             #[inline]
-            fn inv_transform(&self, v: &$tv<N>) -> $tv<N> {
+            fn inv_transform(t: &$t<N>, v: &$tv<N>) -> $tv<N> {
-                self.rotation.inv_transform(&(v - self.translation))
+                t.rotation.inv_transform(v)
+            }
+        }
+
+        impl<N: Num + Clone> $trhs<N> for $tp<N> {
+            #[inline]
+            fn transform(t: &$t<N>, p: &$tp<N>) -> $tp<N> {
+                t.rotation.transform(p) + t.translation
+            }
+
+            #[inline]
+            fn inv_transform(t: &$t<N>, p: &$tp<N>) -> $tp<N> {
+                t.rotation.inv_transform(&(p - t.translation))
             }
         }
     )

src/structs/mat.rs

@@ -8,12 +8,13 @@ use traits::operations::ApproxEq;
 use std::slice::{Items, MutItems};
 use structs::vec::{Vec1, Vec2, Vec3, Vec4, Vec5, Vec6,
                    Vec1MulRhs, Vec4MulRhs, Vec5MulRhs, Vec6MulRhs};
+use structs::pnt::{Pnt1, Pnt4, Pnt5, Pnt6, Pnt1MulRhs, Pnt4MulRhs, Pnt5MulRhs, Pnt6MulRhs};
 use structs::dvec::{DVec1, DVec2, DVec3, DVec4, DVec5, DVec6};
 
 use traits::structure::{Cast, Row, Col, Iterable, IterableMut, Dim, Indexable,
                         Eye, ColSlice, RowSlice, Diag};
 use traits::operations::{Absolute, Transpose, Inv, Outer};
-use traits::geometry::{ToHomogeneous, FromHomogeneous};
+use traits::geometry::{ToHomogeneous, FromHomogeneous, Orig};
 
 
 /// Special identity matrix. All its operation are no-ops.
@@ -112,8 +113,10 @@ dim_impl!(Mat1, 1)
 indexable_impl!(Mat1, 1)
 index_impl!(Mat1, Vec1, 1)
 mat_mul_mat_impl!(Mat1, Mat1MulRhs, 1)
-mat_mul_vec_impl!(Mat1, Vec1, Mat1MulRhs, 1)
+mat_mul_vec_impl!(Mat1, Vec1, Mat1MulRhs, 1, Zero::zero)
-vec_mul_mat_impl!(Mat1, Vec1, Vec1MulRhs, 1)
+vec_mul_mat_impl!(Mat1, Vec1, Vec1MulRhs, 1, Zero::zero)
+mat_mul_pnt_impl!(Mat1, Pnt1, Mat1MulRhs, 1, Orig::orig)
+pnt_mul_mat_impl!(Mat1, Pnt1, Pnt1MulRhs, 1, Orig::orig)
 // (specialized) inv_impl!(Mat1, 1)
 transpose_impl!(Mat1, 1)
 approx_eq_impl!(Mat1)
@@ -501,8 +504,10 @@ indexable_impl!(Mat4, 4)
 index_impl!(Mat4, Vec4, 4)
 at_fast_impl!(Mat4, 4)
 mat_mul_mat_impl!(Mat4, Mat4MulRhs, 4)
-mat_mul_vec_impl!(Mat4, Vec4, Mat4MulRhs, 4)
+mat_mul_vec_impl!(Mat4, Vec4, Mat4MulRhs, 4, Zero::zero)
-vec_mul_mat_impl!(Mat4, Vec4, Vec4MulRhs, 4)
+vec_mul_mat_impl!(Mat4, Vec4, Vec4MulRhs, 4, Zero::zero)
+mat_mul_pnt_impl!(Mat4, Pnt4, Mat4MulRhs, 4, Orig::orig)
+pnt_mul_mat_impl!(Mat4, Pnt4, Pnt4MulRhs, 4, Orig::orig)
 inv_impl!(Mat4, 4)
 transpose_impl!(Mat4, 4)
 approx_eq_impl!(Mat4)
@@ -686,8 +691,10 @@ indexable_impl!(Mat5, 5)
 index_impl!(Mat5, Vec5, 5)
 at_fast_impl!(Mat5, 5)
 mat_mul_mat_impl!(Mat5, Mat5MulRhs, 5)
-mat_mul_vec_impl!(Mat5, Vec5, Mat5MulRhs, 5)
+mat_mul_vec_impl!(Mat5, Vec5, Mat5MulRhs, 5, Zero::zero)
-vec_mul_mat_impl!(Mat5, Vec5, Vec5MulRhs, 5)
+vec_mul_mat_impl!(Mat5, Vec5, Vec5MulRhs, 5, Zero::zero)
+mat_mul_pnt_impl!(Mat5, Pnt5, Mat5MulRhs, 5, Orig::orig)
+pnt_mul_mat_impl!(Mat5, Pnt5, Pnt5MulRhs, 5, Orig::orig)
 inv_impl!(Mat5, 5)
 transpose_impl!(Mat5, 5)
 approx_eq_impl!(Mat5)
@@ -923,8 +930,10 @@ indexable_impl!(Mat6, 6)
 index_impl!(Mat6, Vec6, 6)
 at_fast_impl!(Mat6, 6)
 mat_mul_mat_impl!(Mat6, Mat6MulRhs, 6)
-mat_mul_vec_impl!(Mat6, Vec6, Mat6MulRhs, 6)
+mat_mul_vec_impl!(Mat6, Vec6, Mat6MulRhs, 6, Zero::zero)
-vec_mul_mat_impl!(Mat6, Vec6, Vec6MulRhs, 6)
+vec_mul_mat_impl!(Mat6, Vec6, Vec6MulRhs, 6, Zero::zero)
+mat_mul_pnt_impl!(Mat6, Pnt6, Mat6MulRhs, 6, Orig::orig)
+pnt_mul_mat_impl!(Mat6, Pnt6, Pnt6MulRhs, 6, Orig::orig)
 inv_impl!(Mat6, 6)
 transpose_impl!(Mat6, 6)
 approx_eq_impl!(Mat6)

src/structs/mat_macros.rs

@@ -381,11 +381,11 @@ macro_rules! mat_mul_mat_impl(
 )
 
 macro_rules! vec_mul_mat_impl(
-  ($t: ident, $v: ident, $trhs: ident, $dim: expr) => (
+  ($t: ident, $v: ident, $trhs: ident, $dim: expr, $zero: expr) => (
     impl<N: Clone + Num> $trhs<N, $v<N>> for $t<N> {
         #[inline]
         fn binop(left: &$v<N>, right: &$t<N>) -> $v<N> {
-            let mut res : $v<N> = Zero::zero();
+            let mut res : $v<N> = $zero();
 
             for i in range(0u, $dim) {
                 for j in range(0u, $dim) {
@@ -403,11 +403,11 @@ macro_rules! vec_mul_mat_impl(
 )
 
 macro_rules! mat_mul_vec_impl(
-  ($t: ident, $v: ident, $trhs: ident, $dim: expr) => (
+  ($t: ident, $v: ident, $trhs: ident, $dim: expr, $zero: expr) => (
     impl<N: Clone + Num> $trhs<N, $v<N>> for $v<N> {
         #[inline]
         fn binop(left: &$t<N>, right: &$v<N>) -> $v<N> {
-            let mut res : $v<N> = Zero::zero();
+            let mut res : $v<N> = $zero();
 
             for i in range(0u, $dim) {
                 for j in range(0u, $dim) {
@@ -424,6 +424,18 @@ macro_rules! mat_mul_vec_impl(
   )
 )
 
+macro_rules! pnt_mul_mat_impl(
+  ($t: ident, $v: ident, $trhs: ident, $dim: expr, $zero: expr) => (
+      vec_mul_mat_impl!($t, $v, $trhs, $dim, $zero)
+  )
+)
+
+macro_rules! mat_mul_pnt_impl(
+  ($t: ident, $v: ident, $trhs: ident, $dim: expr, $zero: expr) => (
+      mat_mul_vec_impl!($t, $v, $trhs, $dim, $zero)
+  )
+)
+
 macro_rules! inv_impl(
   ($t: ident, $dim: expr) => (
     impl<N: Clone + Num>

src/structs/mod.rs

@@ -3,6 +3,7 @@
 pub use self::dmat::DMat;
 pub use self::dvec::{DVec, DVec1, DVec2, DVec3, DVec4, DVec5, DVec6};
 pub use self::vec::{Vec0, Vec1, Vec2, Vec3, Vec4, Vec5, Vec6};
+pub use self::pnt::{Pnt0, Pnt1, Pnt2, Pnt3, Pnt4, Pnt5, Pnt6};
 pub use self::mat::{Identity, Mat1, Mat2, Mat3, Mat4, Mat5, Mat6};
 pub use self::rot::{Rot2, Rot3, Rot4};
 pub use self::iso::{Iso2, Iso3, Iso4};
@@ -22,6 +23,8 @@ mod dvec_macros;
 mod dvec;
 mod vec_macros;
 mod vec;
+mod pnt_macros;
+mod pnt;
 mod mat_macros;
 mod mat;
 mod rot_macros;

src/structs/pnt.rs

@@ -0,0 +1,593 @@
+//! Points with dimensions known at compile-time.
+
+#![allow(missing_doc)] // we allow missing to avoid having to document the vector components.
+
+use std::mem;
+use std::num::{Zero, One, Bounded};
+use std::slice::{Items, MutItems};
+use std::iter::{Iterator, FromIterator};
+use traits::operations::{ApproxEq, PartialOrd, PartialOrdering, PartialLess, PartialEqual,
+                         PartialGreater, NotComparable};
+use traits::structure::{Cast, Dim, Indexable, Iterable, IterableMut, PntAsVec};
+use traits::geometry::{Orig, FromHomogeneous, ToHomogeneous};
+use structs::vec::{Vec1, Vec2, Vec3, Vec4, Vec5, Vec6};
+
+
+/// Point of dimension 0.
+#[deriving(Eq, PartialEq, Decodable, Clone, Rand, Show)]
+pub struct Pnt0<N>;
+
+impl<N> Pnt0<N> {
+    /// Creates a new vector.
+    #[inline]
+    pub fn new() -> Pnt0<N> {
+        Pnt0
+    }
+
+    /// Creates a new vector. The parameter is not taken in account.
+    #[inline]
+    pub fn new_repeat(_: N) -> Pnt0<N> {
+        Pnt0
+    }
+}
+
+/// Point of dimension 1.
+#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
+pub struct Pnt1<N> {
+    /// First component of the vector.
+    pub x: N
+}
+
+double_dispatch_binop_decl_trait!(Pnt1, Pnt1MulRhs)
+double_dispatch_binop_decl_trait!(Pnt1, Pnt1DivRhs)
+double_dispatch_binop_decl_trait!(Pnt1, Pnt1AddRhs)
+double_dispatch_binop_decl_trait!(Pnt1, Pnt1SubRhs)
+double_dispatch_cast_decl_trait!(Pnt1, Pnt1Cast)
+mul_redispatch_impl!(Pnt1, Pnt1MulRhs)
+div_redispatch_impl!(Pnt1, Pnt1DivRhs)
+add_redispatch_impl!(Pnt1, Pnt1AddRhs)
+sub_redispatch_impl!(Pnt1, Pnt1SubRhs)
+cast_redispatch_impl!(Pnt1, Pnt1Cast)
+new_impl!(Pnt1, x)
+orig_impl!(Pnt1, x)
+ord_impl!(Pnt1, x)
+vec_cast_impl!(Pnt1, Pnt1Cast, x)
+as_slice_impl!(Pnt1, 1)
+index_impl!(Pnt1)
+indexable_impl!(Pnt1, 1)
+at_fast_impl!(Pnt1, 1)
+new_repeat_impl!(Pnt1, val, x)
+dim_impl!(Pnt1, 1)
+container_impl!(Pnt1)
+pnt_as_vec_impl!(Pnt1, Vec1)
+pnt_sub_impl!(Pnt1, Vec1, Pnt1SubRhs)
+neg_impl!(Pnt1, x)
+pnt_add_vec_impl!(Pnt1, Vec1, Pnt1AddRhs, x)
+pnt_sub_vec_impl!(Pnt1, Vec1, Pnt1SubRhs, x)
+vec_mul_scalar_impl!(Pnt1, f64, Pnt1MulRhs, x)
+vec_mul_scalar_impl!(Pnt1, f32, Pnt1MulRhs, x)
+vec_mul_scalar_impl!(Pnt1, u64, Pnt1MulRhs, x)
+vec_mul_scalar_impl!(Pnt1, u32, Pnt1MulRhs, x)
+vec_mul_scalar_impl!(Pnt1, u16, Pnt1MulRhs, x)
+vec_mul_scalar_impl!(Pnt1, u8, Pnt1MulRhs, x)
+vec_mul_scalar_impl!(Pnt1, i64, Pnt1MulRhs, x)
+vec_mul_scalar_impl!(Pnt1, i32, Pnt1MulRhs, x)
+vec_mul_scalar_impl!(Pnt1, i16, Pnt1MulRhs, x)
+vec_mul_scalar_impl!(Pnt1, i8, Pnt1MulRhs, x)
+vec_mul_scalar_impl!(Pnt1, uint, Pnt1MulRhs, x)
+vec_mul_scalar_impl!(Pnt1, int, Pnt1MulRhs, x)
+vec_div_scalar_impl!(Pnt1, f64, Pnt1DivRhs, x)
+vec_div_scalar_impl!(Pnt1, f32, Pnt1DivRhs, x)
+vec_div_scalar_impl!(Pnt1, u64, Pnt1DivRhs, x)
+vec_div_scalar_impl!(Pnt1, u32, Pnt1DivRhs, x)
+vec_div_scalar_impl!(Pnt1, u16, Pnt1DivRhs, x)
+vec_div_scalar_impl!(Pnt1, u8, Pnt1DivRhs, x)
+vec_div_scalar_impl!(Pnt1, i64, Pnt1DivRhs, x)
+vec_div_scalar_impl!(Pnt1, i32, Pnt1DivRhs, x)
+vec_div_scalar_impl!(Pnt1, i16, Pnt1DivRhs, x)
+vec_div_scalar_impl!(Pnt1, i8, Pnt1DivRhs, x)
+vec_div_scalar_impl!(Pnt1, uint, Pnt1DivRhs, x)
+vec_div_scalar_impl!(Pnt1, int, Pnt1DivRhs, x)
+vec_add_scalar_impl!(Pnt1, f64, Pnt1AddRhs, x)
+vec_add_scalar_impl!(Pnt1, f32, Pnt1AddRhs, x)
+vec_add_scalar_impl!(Pnt1, u64, Pnt1AddRhs, x)
+vec_add_scalar_impl!(Pnt1, u32, Pnt1AddRhs, x)
+vec_add_scalar_impl!(Pnt1, u16, Pnt1AddRhs, x)
+vec_add_scalar_impl!(Pnt1, u8, Pnt1AddRhs, x)
+vec_add_scalar_impl!(Pnt1, i64, Pnt1AddRhs, x)
+vec_add_scalar_impl!(Pnt1, i32, Pnt1AddRhs, x)
+vec_add_scalar_impl!(Pnt1, i16, Pnt1AddRhs, x)
+vec_add_scalar_impl!(Pnt1, i8, Pnt1AddRhs, x)
+vec_add_scalar_impl!(Pnt1, uint, Pnt1AddRhs, x)
+vec_add_scalar_impl!(Pnt1, int, Pnt1AddRhs, x)
+vec_sub_scalar_impl!(Pnt1, f64, Pnt1SubRhs, x)
+vec_sub_scalar_impl!(Pnt1, f32, Pnt1SubRhs, x)
+vec_sub_scalar_impl!(Pnt1, u64, Pnt1SubRhs, x)
+vec_sub_scalar_impl!(Pnt1, u32, Pnt1SubRhs, x)
+vec_sub_scalar_impl!(Pnt1, u16, Pnt1SubRhs, x)
+vec_sub_scalar_impl!(Pnt1, u8, Pnt1SubRhs, x)
+vec_sub_scalar_impl!(Pnt1, i64, Pnt1SubRhs, x)
+vec_sub_scalar_impl!(Pnt1, i32, Pnt1SubRhs, x)
+vec_sub_scalar_impl!(Pnt1, i16, Pnt1SubRhs, x)
+vec_sub_scalar_impl!(Pnt1, i8, Pnt1SubRhs, x)
+vec_sub_scalar_impl!(Pnt1, uint, Pnt1SubRhs, x)
+vec_sub_scalar_impl!(Pnt1, int, Pnt1SubRhs, x)
+approx_eq_impl!(Pnt1, x)
+from_iterator_impl!(Pnt1, iterator)
+bounded_impl!(Pnt1, x)
+iterable_impl!(Pnt1, 1)
+iterable_mut_impl!(Pnt1, 1)
+pnt_to_homogeneous_impl!(Pnt1, Pnt2, y, x)
+pnt_from_homogeneous_impl!(Pnt1, Pnt2, y, x)
+
+/// Point of dimension 2.
+#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
+pub struct Pnt2<N> {
+    /// First component of the vector.
+    pub x: N,
+    /// Second component of the vector.
+    pub y: N
+}
+
+double_dispatch_binop_decl_trait!(Pnt2, Pnt2MulRhs)
+double_dispatch_binop_decl_trait!(Pnt2, Pnt2DivRhs)
+double_dispatch_binop_decl_trait!(Pnt2, Pnt2AddRhs)
+double_dispatch_binop_decl_trait!(Pnt2, Pnt2SubRhs)
+double_dispatch_cast_decl_trait!(Pnt2, Pnt2Cast)
+mul_redispatch_impl!(Pnt2, Pnt2MulRhs)
+div_redispatch_impl!(Pnt2, Pnt2DivRhs)
+add_redispatch_impl!(Pnt2, Pnt2AddRhs)
+sub_redispatch_impl!(Pnt2, Pnt2SubRhs)
+cast_redispatch_impl!(Pnt2, Pnt2Cast)
+new_impl!(Pnt2, x, y)
+orig_impl!(Pnt2, x, y)
+ord_impl!(Pnt2, x, y)
+vec_cast_impl!(Pnt2, Pnt2Cast, x, y)
+as_slice_impl!(Pnt2, 2)
+index_impl!(Pnt2)
+indexable_impl!(Pnt2, 2)
+at_fast_impl!(Pnt2, 2)
+new_repeat_impl!(Pnt2, val, x, y)
+dim_impl!(Pnt2, 2)
+container_impl!(Pnt2)
+pnt_as_vec_impl!(Pnt2, Vec2)
+pnt_sub_impl!(Pnt2, Vec2, Pnt2SubRhs)
+neg_impl!(Pnt2, x, y)
+pnt_add_vec_impl!(Pnt2, Vec2, Pnt2AddRhs, x, y)
+pnt_sub_vec_impl!(Pnt2, Vec2, Pnt2SubRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, f64, Pnt2MulRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, f32, Pnt2MulRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, u64, Pnt2MulRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, u32, Pnt2MulRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, u16, Pnt2MulRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, u8, Pnt2MulRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, i64, Pnt2MulRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, i32, Pnt2MulRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, i16, Pnt2MulRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, i8, Pnt2MulRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, uint, Pnt2MulRhs, x, y)
+vec_mul_scalar_impl!(Pnt2, int, Pnt2MulRhs, x, y)
+vec_div_scalar_impl!(Pnt2, f64, Pnt2DivRhs, x, y)
+vec_div_scalar_impl!(Pnt2, f32, Pnt2DivRhs, x, y)
+vec_div_scalar_impl!(Pnt2, u64, Pnt2DivRhs, x, y)
+vec_div_scalar_impl!(Pnt2, u32, Pnt2DivRhs, x, y)
+vec_div_scalar_impl!(Pnt2, u16, Pnt2DivRhs, x, y)
+vec_div_scalar_impl!(Pnt2, u8, Pnt2DivRhs, x, y)
+vec_div_scalar_impl!(Pnt2, i64, Pnt2DivRhs, x, y)
+vec_div_scalar_impl!(Pnt2, i32, Pnt2DivRhs, x, y)
+vec_div_scalar_impl!(Pnt2, i16, Pnt2DivRhs, x, y)
+vec_div_scalar_impl!(Pnt2, i8, Pnt2DivRhs, x, y)
+vec_div_scalar_impl!(Pnt2, uint, Pnt2DivRhs, x, y)
+vec_div_scalar_impl!(Pnt2, int, Pnt2DivRhs, x, y)
+vec_add_scalar_impl!(Pnt2, f64, Pnt2AddRhs, x, y)
+vec_add_scalar_impl!(Pnt2, f32, Pnt2AddRhs, x, y)
+vec_add_scalar_impl!(Pnt2, u64, Pnt2AddRhs, x, y)
+vec_add_scalar_impl!(Pnt2, u32, Pnt2AddRhs, x, y)
+vec_add_scalar_impl!(Pnt2, u16, Pnt2AddRhs, x, y)
+vec_add_scalar_impl!(Pnt2, u8, Pnt2AddRhs, x, y)
+vec_add_scalar_impl!(Pnt2, i64, Pnt2AddRhs, x, y)
+vec_add_scalar_impl!(Pnt2, i32, Pnt2AddRhs, x, y)
+vec_add_scalar_impl!(Pnt2, i16, Pnt2AddRhs, x, y)
+vec_add_scalar_impl!(Pnt2, i8, Pnt2AddRhs, x, y)
+vec_add_scalar_impl!(Pnt2, uint, Pnt2AddRhs, x, y)
+vec_add_scalar_impl!(Pnt2, int, Pnt2AddRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, f64, Pnt2SubRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, f32, Pnt2SubRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, u64, Pnt2SubRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, u32, Pnt2SubRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, u16, Pnt2SubRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, u8, Pnt2SubRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, i64, Pnt2SubRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, i32, Pnt2SubRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, i16, Pnt2SubRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, i8, Pnt2SubRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, uint, Pnt2SubRhs, x, y)
+vec_sub_scalar_impl!(Pnt2, int, Pnt2SubRhs, x, y)
+approx_eq_impl!(Pnt2, x, y)
+from_iterator_impl!(Pnt2, iterator, iterator)
+bounded_impl!(Pnt2, x, y)
+iterable_impl!(Pnt2, 2)
+iterable_mut_impl!(Pnt2, 2)
+pnt_to_homogeneous_impl!(Pnt2, Pnt3, z, x, y)
+pnt_from_homogeneous_impl!(Pnt2, Pnt3, z, x, y)
+
+/// Point of dimension 3.
+#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
+pub struct Pnt3<N> {
+    /// First component of the vector.
+    pub x: N,
+    /// Second component of the vector.
+    pub y: N,
+    /// Third component of the vector.
+    pub z: N
+}
+
+double_dispatch_binop_decl_trait!(Pnt3, Pnt3MulRhs)
+double_dispatch_binop_decl_trait!(Pnt3, Pnt3DivRhs)
+double_dispatch_binop_decl_trait!(Pnt3, Pnt3AddRhs)
+double_dispatch_binop_decl_trait!(Pnt3, Pnt3SubRhs)
+double_dispatch_cast_decl_trait!(Pnt3, Pnt3Cast)
+mul_redispatch_impl!(Pnt3, Pnt3MulRhs)
+div_redispatch_impl!(Pnt3, Pnt3DivRhs)
+add_redispatch_impl!(Pnt3, Pnt3AddRhs)
+sub_redispatch_impl!(Pnt3, Pnt3SubRhs)
+cast_redispatch_impl!(Pnt3, Pnt3Cast)
+new_impl!(Pnt3, x, y, z)
+orig_impl!(Pnt3, x, y, z)
+ord_impl!(Pnt3, x, y, z)
+vec_cast_impl!(Pnt3, Pnt3Cast, x, y, z)
+as_slice_impl!(Pnt3, 3)
+index_impl!(Pnt3)
+indexable_impl!(Pnt3, 3)
+at_fast_impl!(Pnt3, 3)
+new_repeat_impl!(Pnt3, val, x, y, z)
+dim_impl!(Pnt3, 3)
+container_impl!(Pnt3)
+pnt_as_vec_impl!(Pnt3, Vec3)
+pnt_sub_impl!(Pnt3, Vec3, Pnt3SubRhs)
+neg_impl!(Pnt3, x, y, z)
+pnt_add_vec_impl!(Pnt3, Vec3, Pnt3AddRhs, x, y, z)
+pnt_sub_vec_impl!(Pnt3, Vec3, Pnt3SubRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, f64, Pnt3MulRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, f32, Pnt3MulRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, u64, Pnt3MulRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, u32, Pnt3MulRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, u16, Pnt3MulRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, u8, Pnt3MulRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, i64, Pnt3MulRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, i32, Pnt3MulRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, i16, Pnt3MulRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, i8, Pnt3MulRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, uint, Pnt3MulRhs, x, y, z)
+vec_mul_scalar_impl!(Pnt3, int, Pnt3MulRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, f64, Pnt3DivRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, f32, Pnt3DivRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, u64, Pnt3DivRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, u32, Pnt3DivRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, u16, Pnt3DivRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, u8, Pnt3DivRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, i64, Pnt3DivRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, i32, Pnt3DivRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, i16, Pnt3DivRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, i8, Pnt3DivRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, uint, Pnt3DivRhs, x, y, z)
+vec_div_scalar_impl!(Pnt3, int, Pnt3DivRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, f64, Pnt3AddRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, f32, Pnt3AddRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, u64, Pnt3AddRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, u32, Pnt3AddRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, u16, Pnt3AddRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, u8, Pnt3AddRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, i64, Pnt3AddRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, i32, Pnt3AddRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, i16, Pnt3AddRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, i8, Pnt3AddRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, uint, Pnt3AddRhs, x, y, z)
+vec_add_scalar_impl!(Pnt3, int, Pnt3AddRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, f64, Pnt3SubRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, f32, Pnt3SubRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, u64, Pnt3SubRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, u32, Pnt3SubRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, u16, Pnt3SubRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, u8, Pnt3SubRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, i64, Pnt3SubRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, i32, Pnt3SubRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, i16, Pnt3SubRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, i8, Pnt3SubRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, uint, Pnt3SubRhs, x, y, z)
+vec_sub_scalar_impl!(Pnt3, int, Pnt3SubRhs, x, y, z)
+approx_eq_impl!(Pnt3, x, y, z)
+from_iterator_impl!(Pnt3, iterator, iterator, iterator)
+bounded_impl!(Pnt3, x, y, z)
+iterable_impl!(Pnt3, 3)
+iterable_mut_impl!(Pnt3, 3)
+pnt_to_homogeneous_impl!(Pnt3, Pnt4, w, x, y, z)
+pnt_from_homogeneous_impl!(Pnt3, Pnt4, w, x, y, z)
+
+/// Point of dimension 4.
+#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
+pub struct Pnt4<N> {
+    /// First component of the vector.
+    pub x: N,
+    /// Second component of the vector.
+    pub y: N,
+    /// Third component of the vector.
+    pub z: N,
+    /// Fourth component of the vector.
+    pub w: N
+}
+
+double_dispatch_binop_decl_trait!(Pnt4, Pnt4MulRhs)
+double_dispatch_binop_decl_trait!(Pnt4, Pnt4DivRhs)
+double_dispatch_binop_decl_trait!(Pnt4, Pnt4AddRhs)
+double_dispatch_binop_decl_trait!(Pnt4, Pnt4SubRhs)
+double_dispatch_cast_decl_trait!(Pnt4, Pnt4Cast)
+mul_redispatch_impl!(Pnt4, Pnt4MulRhs)
+div_redispatch_impl!(Pnt4, Pnt4DivRhs)
+add_redispatch_impl!(Pnt4, Pnt4AddRhs)
+sub_redispatch_impl!(Pnt4, Pnt4SubRhs)
+cast_redispatch_impl!(Pnt4, Pnt4Cast)
+new_impl!(Pnt4, x, y, z, w)
+orig_impl!(Pnt4, x, y, z, w)
+ord_impl!(Pnt4, x, y, z, w)
+vec_cast_impl!(Pnt4, Pnt4Cast, x, y, z, w)
+as_slice_impl!(Pnt4, 4)
+index_impl!(Pnt4)
+indexable_impl!(Pnt4, 4)
+at_fast_impl!(Pnt4, 4)
+new_repeat_impl!(Pnt4, val, x, y, z, w)
+dim_impl!(Pnt4, 4)
+container_impl!(Pnt4)
+pnt_as_vec_impl!(Pnt4, Vec4)
+pnt_sub_impl!(Pnt4, Vec4, Pnt4SubRhs)
+neg_impl!(Pnt4, x, y, z, w)
+pnt_add_vec_impl!(Pnt4, Vec4, Pnt4AddRhs, x, y, z, w)
+pnt_sub_vec_impl!(Pnt4, Vec4, Pnt4SubRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, f64, Pnt4MulRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, f32, Pnt4MulRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, u64, Pnt4MulRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, u32, Pnt4MulRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, u16, Pnt4MulRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, u8, Pnt4MulRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, i64, Pnt4MulRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, i32, Pnt4MulRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, i16, Pnt4MulRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, i8, Pnt4MulRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, uint, Pnt4MulRhs, x, y, z, w)
+vec_mul_scalar_impl!(Pnt4, int, Pnt4MulRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, f64, Pnt4DivRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, f32, Pnt4DivRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, u64, Pnt4DivRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, u32, Pnt4DivRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, u16, Pnt4DivRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, u8, Pnt4DivRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, i64, Pnt4DivRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, i32, Pnt4DivRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, i16, Pnt4DivRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, i8, Pnt4DivRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, uint, Pnt4DivRhs, x, y, z, w)
+vec_div_scalar_impl!(Pnt4, int, Pnt4DivRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, f64, Pnt4AddRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, f32, Pnt4AddRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, u64, Pnt4AddRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, u32, Pnt4AddRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, u16, Pnt4AddRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, u8, Pnt4AddRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, i64, Pnt4AddRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, i32, Pnt4AddRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, i16, Pnt4AddRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, i8, Pnt4AddRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, uint, Pnt4AddRhs, x, y, z, w)
+vec_add_scalar_impl!(Pnt4, int, Pnt4AddRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, f64, Pnt4SubRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, f32, Pnt4SubRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, u64, Pnt4SubRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, u32, Pnt4SubRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, u16, Pnt4SubRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, u8, Pnt4SubRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, i64, Pnt4SubRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, i32, Pnt4SubRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, i16, Pnt4SubRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, i8, Pnt4SubRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, uint, Pnt4SubRhs, x, y, z, w)
+vec_sub_scalar_impl!(Pnt4, int, Pnt4SubRhs, x, y, z, w)
+approx_eq_impl!(Pnt4, x, y, z, w)
+from_iterator_impl!(Pnt4, iterator, iterator, iterator, iterator)
+bounded_impl!(Pnt4, x, y, z, w)
+iterable_impl!(Pnt4, 4)
+iterable_mut_impl!(Pnt4, 4)
+pnt_to_homogeneous_impl!(Pnt4, Pnt5, a, x, y, z, w)
+pnt_from_homogeneous_impl!(Pnt4, Pnt5, a, x, y, z, w)
+
+/// Point of dimension 5.
+#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
+pub struct Pnt5<N> {
+    /// First component of the vector.
+    pub x: N,
+    /// Second component of the vector.
+    pub y: N,
+    /// Third component of the vector.
+    pub z: N,
+    /// Fourth component of the vector.
+    pub w: N,
+    /// Fifth of the vector.
+    pub a: N
+}
+
+double_dispatch_binop_decl_trait!(Pnt5, Pnt5MulRhs)
+double_dispatch_binop_decl_trait!(Pnt5, Pnt5DivRhs)
+double_dispatch_binop_decl_trait!(Pnt5, Pnt5AddRhs)
+double_dispatch_binop_decl_trait!(Pnt5, Pnt5SubRhs)
+double_dispatch_cast_decl_trait!(Pnt5, Pnt5Cast)
+mul_redispatch_impl!(Pnt5, Pnt5MulRhs)
+div_redispatch_impl!(Pnt5, Pnt5DivRhs)
+add_redispatch_impl!(Pnt5, Pnt5AddRhs)
+sub_redispatch_impl!(Pnt5, Pnt5SubRhs)
+cast_redispatch_impl!(Pnt5, Pnt5Cast)
+new_impl!(Pnt5, x, y, z, w, a)
+orig_impl!(Pnt5, x, y, z, w, a)
+ord_impl!(Pnt5, x, y, z, w, a)
+vec_cast_impl!(Pnt5, Pnt5Cast, x, y, z, w, a)
+as_slice_impl!(Pnt5, 5)
+index_impl!(Pnt5)
+indexable_impl!(Pnt5, 5)
+at_fast_impl!(Pnt5, 5)
+new_repeat_impl!(Pnt5, val, x, y, z, w, a)
+dim_impl!(Pnt5, 5)
+container_impl!(Pnt5)
+pnt_as_vec_impl!(Pnt5, Vec5)
+pnt_sub_impl!(Pnt5, Vec5, Pnt5SubRhs)
+neg_impl!(Pnt5, x, y, z, w, a)
+pnt_add_vec_impl!(Pnt5, Vec5, Pnt5AddRhs, x, y, z, w, a)
+pnt_sub_vec_impl!(Pnt5, Vec5, Pnt5SubRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, f64, Pnt5MulRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, f32, Pnt5MulRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, u64, Pnt5MulRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, u32, Pnt5MulRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, u16, Pnt5MulRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, u8, Pnt5MulRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, i64, Pnt5MulRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, i32, Pnt5MulRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, i16, Pnt5MulRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, i8, Pnt5MulRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, uint, Pnt5MulRhs, x, y, z, w, a)
+vec_mul_scalar_impl!(Pnt5, int, Pnt5MulRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, f64, Pnt5DivRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, f32, Pnt5DivRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, u64, Pnt5DivRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, u32, Pnt5DivRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, u16, Pnt5DivRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, u8, Pnt5DivRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, i64, Pnt5DivRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, i32, Pnt5DivRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, i16, Pnt5DivRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, i8, Pnt5DivRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, uint, Pnt5DivRhs, x, y, z, w, a)
+vec_div_scalar_impl!(Pnt5, int, Pnt5DivRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, f64, Pnt5AddRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, f32, Pnt5AddRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, u64, Pnt5AddRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, u32, Pnt5AddRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, u16, Pnt5AddRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, u8, Pnt5AddRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, i64, Pnt5AddRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, i32, Pnt5AddRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, i16, Pnt5AddRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, i8, Pnt5AddRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, uint, Pnt5AddRhs, x, y, z, w, a)
+vec_add_scalar_impl!(Pnt5, int, Pnt5AddRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, f64, Pnt5SubRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, f32, Pnt5SubRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, u64, Pnt5SubRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, u32, Pnt5SubRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, u16, Pnt5SubRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, u8, Pnt5SubRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, i64, Pnt5SubRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, i32, Pnt5SubRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, i16, Pnt5SubRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, i8, Pnt5SubRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, uint, Pnt5SubRhs, x, y, z, w, a)
+vec_sub_scalar_impl!(Pnt5, int, Pnt5SubRhs, x, y, z, w, a)
+approx_eq_impl!(Pnt5, x, y, z, w, a)
+from_iterator_impl!(Pnt5, iterator, iterator, iterator, iterator, iterator)
+bounded_impl!(Pnt5, x, y, z, w, a)
+iterable_impl!(Pnt5, 5)
+iterable_mut_impl!(Pnt5, 5)
+pnt_to_homogeneous_impl!(Pnt5, Pnt6, b, x, y, z, w, a)
+pnt_from_homogeneous_impl!(Pnt5, Pnt6, b, x, y, z, w, a)
+
+/// Point of dimension 6.
+#[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Show)]
+pub struct Pnt6<N> {
+    /// First component of the vector.
+    pub x: N,
+    /// Second component of the vector.
+    pub y: N,
+    /// Third component of the vector.
+    pub z: N,
+    /// Fourth component of the vector.
+    pub w: N,
+    /// Fifth of the vector.
+    pub a: N,
+    /// Sixth component of the vector.
+    pub b: N
+}
+
+double_dispatch_binop_decl_trait!(Pnt6, Pnt6MulRhs)
+double_dispatch_binop_decl_trait!(Pnt6, Pnt6DivRhs)
+double_dispatch_binop_decl_trait!(Pnt6, Pnt6AddRhs)
+double_dispatch_binop_decl_trait!(Pnt6, Pnt6SubRhs)
+double_dispatch_cast_decl_trait!(Pnt6, Pnt6Cast)
+mul_redispatch_impl!(Pnt6, Pnt6MulRhs)
+div_redispatch_impl!(Pnt6, Pnt6DivRhs)
+add_redispatch_impl!(Pnt6, Pnt6AddRhs)
+sub_redispatch_impl!(Pnt6, Pnt6SubRhs)
+cast_redispatch_impl!(Pnt6, Pnt6Cast)
+new_impl!(Pnt6, x, y, z, w, a, b)
+orig_impl!(Pnt6, x, y, z, w, a, b)
+ord_impl!(Pnt6, x, y, z, w, a, b)
+vec_cast_impl!(Pnt6, Pnt6Cast, x, y, z, w, a, b)
+as_slice_impl!(Pnt6, 6)
+index_impl!(Pnt6)
+indexable_impl!(Pnt6, 6)
+at_fast_impl!(Pnt6, 6)
+new_repeat_impl!(Pnt6, val, x, y, z, w, a, b)
+dim_impl!(Pnt6, 6)
+container_impl!(Pnt6)
+pnt_as_vec_impl!(Pnt6, Vec6)
+pnt_sub_impl!(Pnt6, Vec6, Pnt6SubRhs)
+neg_impl!(Pnt6, x, y, z, w, a, b)
+pnt_add_vec_impl!(Pnt6, Vec6, Pnt6AddRhs, x, y, z, w, a, b)
+pnt_sub_vec_impl!(Pnt6, Vec6, Pnt6SubRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, f64, Pnt6MulRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, f32, Pnt6MulRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, u64, Pnt6MulRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, u32, Pnt6MulRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, u16, Pnt6MulRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, u8, Pnt6MulRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, i64, Pnt6MulRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, i32, Pnt6MulRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, i16, Pnt6MulRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, i8, Pnt6MulRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, uint, Pnt6MulRhs, x, y, z, w, a, b)
+vec_mul_scalar_impl!(Pnt6, int, Pnt6MulRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, f64, Pnt6DivRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, f32, Pnt6DivRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, u64, Pnt6DivRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, u32, Pnt6DivRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, u16, Pnt6DivRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, u8, Pnt6DivRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, i64, Pnt6DivRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, i32, Pnt6DivRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, i16, Pnt6DivRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, i8, Pnt6DivRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, uint, Pnt6DivRhs, x, y, z, w, a, b)
+vec_div_scalar_impl!(Pnt6, int, Pnt6DivRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, f64, Pnt6AddRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, f32, Pnt6AddRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, u64, Pnt6AddRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, u32, Pnt6AddRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, u16, Pnt6AddRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, u8, Pnt6AddRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, i64, Pnt6AddRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, i32, Pnt6AddRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, i16, Pnt6AddRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, i8, Pnt6AddRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, uint, Pnt6AddRhs, x, y, z, w, a, b)
+vec_add_scalar_impl!(Pnt6, int, Pnt6AddRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, f64, Pnt6SubRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, f32, Pnt6SubRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, u64, Pnt6SubRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, u32, Pnt6SubRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, u16, Pnt6SubRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, u8, Pnt6SubRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, i64, Pnt6SubRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, i32, Pnt6SubRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, i16, Pnt6SubRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, i8, Pnt6SubRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, uint, Pnt6SubRhs, x, y, z, w, a, b)
+vec_sub_scalar_impl!(Pnt6, int, Pnt6SubRhs, x, y, z, w, a, b)
+approx_eq_impl!(Pnt6, x, y, z, w, a, b)
+from_iterator_impl!(Pnt6, iterator, iterator, iterator, iterator, iterator, iterator)
+iterable_impl!(Pnt6, 6)
+iterable_mut_impl!(Pnt6, 6)

src/structs/pnt_macros.rs

@@ -0,0 +1,104 @@
+#![macro_escape]
+
+macro_rules! orig_impl(
+    ($t: ident, $comp0: ident $(,$compN: ident)*) => (
+        impl<N: Zero> Orig for $t<N> {
+            #[inline]
+            fn orig() -> $t<N> {
+                $t {
+                    $comp0: Zero::zero()
+                    $(, $compN: Zero::zero() )*
+                }
+            }
+
+            #[inline]
+            fn is_orig(&self) -> bool {
+                self.$comp0.is_zero() $(&& self.$compN.is_zero() )*
+            }
+        }
+    )
+)
+
+macro_rules! pnt_sub_impl(
+    ($t: ident, $tv: ident, $trhs: ident) => (
+        impl<N: Sub<N, N>> $trhs<N, $tv<N>> for $t<N> {
+            #[inline]
+            fn binop(left: &$t<N>, right: &$t<N>) -> $tv<N> {
+                *left.as_vec() - *right.as_vec()
+            }
+        }
+    )
+)
+
+macro_rules! pnt_add_vec_impl(
+    ($t: ident, $tv: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => (
+        impl<N: Add<N, N>> $trhs<N, $t<N>> for $tv<N> {
+            #[inline]
+            fn binop(left: &$t<N>, right: &$tv<N>) -> $t<N> {
+                $t::new(left.$comp0 + right.$comp0 $(, left.$compN + right.$compN)*)
+            }
+        }
+    )
+)
+
+macro_rules! pnt_sub_vec_impl(
+    ($t: ident, $tv: ident, $trhs: ident, $comp0: ident $(,$compN: ident)*) => (
+        impl<N: Sub<N, N>> $trhs<N, $t<N>> for $tv<N> {
+            #[inline]
+            fn binop(left: &$t<N>, right: &$tv<N>) -> $t<N> {
+                $t::new(left.$comp0 - right.$comp0 $(, left.$compN - right.$compN)*)
+            }
+        }
+    )
+)
+
+macro_rules! pnt_as_vec_impl(
+    ($t: ident, $tv: ident) => (
+        impl<N> $t<N> {
+            #[inline]
+            pub fn as_vec<'a>(&'a self) -> &'a $tv<N> {
+                unsafe {
+                    mem::transmute(self)
+                }
+            }
+        }
+
+        impl<N> PntAsVec<$tv<N>> for $t<N> {
+            #[inline]
+            fn as_vec<'a>(&'a self) -> &'a $tv<N> {
+                self.as_vec()
+            }
+        }
+    )
+)
+
+macro_rules! pnt_to_homogeneous_impl(
+    ($t: ident, $t2: ident, $extra: ident, $comp0: ident $(,$compN: ident)*) => (
+        impl<N: Clone + One + Zero> ToHomogeneous<$t2<N>> for $t<N> {
+            fn to_homogeneous(v: &$t<N>) -> $t2<N> {
+                let mut res: $t2<N> = Orig::orig();
+
+                res.$comp0    = v.$comp0.clone();
+                $( res.$compN = v.$compN.clone(); )*
+                res.$extra    = One::one();
+
+                res
+            }
+        }
+    )
+)
+
+macro_rules! pnt_from_homogeneous_impl(
+    ($t: ident, $t2: ident, $extra: ident, $comp0: ident $(,$compN: ident)*) => (
+        impl<N: Clone + Div<N, N> + One + Zero> FromHomogeneous<$t2<N>> for $t<N> {
+            fn from(v: &$t2<N>) -> $t<N> {
+                let mut res: $t<N> = Orig::orig();
+
+                res.$comp0    = v.$comp0.clone() / v.$extra;
+                $( res.$compN = v.$compN.clone() / v.$extra; )*
+
+                res
+            }
+        }
+    )
+)

src/structs/rot.rs

@@ -9,6 +9,7 @@ use traits::geometry::{Rotate, Rotation, AbsoluteRotate, RotationMatrix, Transfo
 use traits::structure::{Cast, Dim, Row, Col};
 use traits::operations::{Absolute, Inv, Transpose, ApproxEq};
 use structs::vec::{Vec1, Vec2, Vec3, Vec4, Vec2MulRhs, Vec3MulRhs, Vec4MulRhs};
+use structs::pnt::{Pnt2, Pnt3, Pnt4, Pnt2MulRhs, Pnt3MulRhs, Pnt4MulRhs};
 use structs::mat::{Mat2, Mat3, Mat4, Mat5};
 
 
@@ -29,8 +30,7 @@ impl<N: Clone + FloatMath + Neg<N>> Rot2<N> {
     }
 }
 
-impl<N: FloatMath + Clone>
+impl<N: FloatMath + Clone> Rotation<Vec1<N>> for Rot2<N> {
-Rotation<Vec1<N>> for Rot2<N> {
     #[inline]
     fn rotation(&self) -> Vec1<N> {
         Vec1::new((-self.submat.m12).atan2(self.submat.m11.clone()))
@@ -353,12 +353,14 @@ Rotation<Vec4<N>> for Rot4<N> {
 double_dispatch_binop_decl_trait!(Rot2, Rot2MulRhs)
 mul_redispatch_impl!(Rot2, Rot2MulRhs)
 submat_impl!(Rot2, Mat2)
-rotate_impl!(Rot2, Vec2)
+rotate_impl!(Rot2RotateRhs, Rot2, Vec2, Pnt2)
-transform_impl!(Rot2, Vec2)
+transform_impl!(Rot2TransformRhs, Rot2, Vec2, Pnt2)
 dim_impl!(Rot2, 2)
 rot_mul_rot_impl!(Rot2, Rot2MulRhs)
 rot_mul_vec_impl!(Rot2, Vec2, Rot2MulRhs)
 vec_mul_rot_impl!(Rot2, Vec2, Vec2MulRhs)
+rot_mul_pnt_impl!(Rot2, Pnt2, Rot2MulRhs)
+pnt_mul_rot_impl!(Rot2, Pnt2, Pnt2MulRhs)
 one_impl!(Rot2)
 rotation_matrix_impl!(Rot2, Vec2, Vec1)
 col_impl!(Rot2, Vec2)
@@ -373,12 +375,14 @@ approx_eq_impl!(Rot2)
 double_dispatch_binop_decl_trait!(Rot3, Rot3MulRhs)
 mul_redispatch_impl!(Rot3, Rot3MulRhs)
 submat_impl!(Rot3, Mat3)
-rotate_impl!(Rot3, Vec3)
+rotate_impl!(Rot3RotateRhs, Rot3, Vec3, Pnt3)
-transform_impl!(Rot3, Vec3)
+transform_impl!(Rot3TransformRhs, Rot3, Vec3, Pnt3)
 dim_impl!(Rot3, 3)
 rot_mul_rot_impl!(Rot3, Rot3MulRhs)
 rot_mul_vec_impl!(Rot3, Vec3, Rot3MulRhs)
 vec_mul_rot_impl!(Rot3, Vec3, Vec3MulRhs)
+rot_mul_pnt_impl!(Rot3, Pnt3, Rot3MulRhs)
+pnt_mul_rot_impl!(Rot3, Pnt3, Pnt3MulRhs)
 one_impl!(Rot3)
 rotation_matrix_impl!(Rot3, Vec3, Vec3)
 col_impl!(Rot3, Vec3)
@@ -393,12 +397,14 @@ approx_eq_impl!(Rot3)
 double_dispatch_binop_decl_trait!(Rot4, Rot4MulRhs)
 mul_redispatch_impl!(Rot4, Rot4MulRhs)
 submat_impl!(Rot4, Mat4)
-rotate_impl!(Rot4, Vec4)
+rotate_impl!(Rot4RotateRhs, Rot4, Vec4, Pnt4)
-transform_impl!(Rot4, Vec4)
+transform_impl!(Rot4TransformRhs, Rot4, Vec4, Pnt4)
 dim_impl!(Rot4, 4)
 rot_mul_rot_impl!(Rot4, Rot4MulRhs)
 rot_mul_vec_impl!(Rot4, Vec4, Rot4MulRhs)
 vec_mul_rot_impl!(Rot4, Vec4, Vec4MulRhs)
+rot_mul_pnt_impl!(Rot4, Pnt4, Rot4MulRhs)
+pnt_mul_rot_impl!(Rot4, Pnt4, Pnt4MulRhs)
 one_impl!(Rot4)
 rotation_matrix_impl!(Rot4, Vec4, Vec4)
 col_impl!(Rot4, Vec4)

src/structs/rot_macros.rs

@@ -12,32 +12,98 @@ macro_rules! submat_impl(
 )
 
 macro_rules! rotate_impl(
-    ($t: ident, $tv: ident) => (
+    ($trhs: ident, $t: ident, $tv: ident, $tp: ident) => (
-        impl<N: Num + Clone> Rotate<$tv<N>> for $t<N> {
+        /*
+         * FIXME: we use the double dispatch trick here so that we can rotate vectors _and_
+         * points. Remove this as soon as rust supports multidispatch.
+         */
+        pub trait $trhs<N> {
+            fn rotate(left: &$t<N>, right: &Self) -> Self;
+            fn inv_rotate(left: &$t<N>, right: &Self) -> Self;
+        }
+
+        impl<N, V: $trhs<N>> Rotate<V> for $t<N> {
+            #[inline(always)]
+            fn rotate(&self, other: &V) -> V {
+                $trhs::rotate(self, other)
+            }
+
+            #[inline(always)]
+            fn inv_rotate(&self, other: &V) -> V {
+                $trhs::inv_rotate(self, other)
+            }
+        }
+
+        impl<N: Num + Clone> $trhs<N> for $tv<N> {
             #[inline]
-            fn rotate(&self, v: &$tv<N>) -> $tv<N> {
+            fn rotate(t: &$t<N>, v: &$tv<N>) -> $tv<N> {
-                self * *v
+                t * *v
             }
 
             #[inline]
-            fn inv_rotate(&self, v: &$tv<N>) -> $tv<N> {
+            fn inv_rotate(t: &$t<N>, v: &$tv<N>) -> $tv<N> {
-                v * *self
+                v * *t
+            }
+        }
+
+        impl<N: Num + Clone> $trhs<N> for $tp<N> {
+            #[inline]
+            fn rotate(t: &$t<N>, p: &$tp<N>) -> $tp<N> {
+                t * *p
+            }
+
+            #[inline]
+            fn inv_rotate(t: &$t<N>, p: &$tp<N>) -> $tp<N> {
+                p * *t
             }
         }
     )
 )
 
 macro_rules! transform_impl(
-    ($t: ident, $tv: ident) => (
+    ($trhs: ident, $t: ident, $tv: ident, $tp: ident) => (
-        impl<N: Num + Clone> Transform<$tv<N>> for $t<N> {
+        /*
+         * FIXME: we use the double dispatch trick here so that we can transform vectors _and_
+         * points. Remove this as soon as rust supports multidispatch.
+         */
+        pub trait $trhs<N> {
+            fn transform(left: &$t<N>, right: &Self) -> Self;
+            fn inv_transform(left: &$t<N>, right: &Self) -> Self;
+        }
+
+        impl<N, V: $trhs<N>> Transform<V> for $t<N> {
+            #[inline(always)]
+            fn transform(&self, other: &V) -> V {
+                $trhs::transform(self, other)
+            }
+
+            #[inline(always)]
+            fn inv_transform(&self, other: &V) -> V {
+                $trhs::inv_transform(self, other)
+            }
+        }
+
+        impl<N: Num + Clone> $trhs<N> for $tv<N> {
             #[inline]
-            fn transform(&self, v: &$tv<N>) -> $tv<N> {
+            fn transform(t: &$t<N>, v: &$tv<N>) -> $tv<N> {
-                self.rotate(v)
+                t.rotate(v)
             }
 
             #[inline]
-            fn inv_transform(&self, v: &$tv<N>) -> $tv<N> {
+            fn inv_transform(t: &$t<N>, v: &$tv<N>) -> $tv<N> {
-                self.inv_rotate(v)
+                t.inv_rotate(v)
+            }
+        }
+
+        impl<N: Num + Clone> $trhs<N> for $tp<N> {
+            #[inline]
+            fn transform(t: &$t<N>, p: &$tp<N>) -> $tp<N> {
+                t.rotate(p)
+            }
+
+            #[inline]
+            fn inv_transform(t: &$t<N>, p: &$tp<N>) -> $tp<N> {
+                t.inv_rotate(p)
             }
         }
     )
@@ -99,6 +165,12 @@ macro_rules! rot_mul_vec_impl(
     )
 )
 
+macro_rules! rot_mul_pnt_impl(
+    ($t: ident, $tv: ident, $mulrhs: ident) => (
+        rot_mul_vec_impl!($t, $tv, $mulrhs)
+    )
+)
+
 macro_rules! vec_mul_rot_impl(
     ($t: ident, $tv: ident, $mulrhs: ident) => (
         impl<N: Num + Clone> $mulrhs<N, $tv<N>> for $t<N> {
@@ -110,6 +182,12 @@ macro_rules! vec_mul_rot_impl(
     )
 )
 
+macro_rules! pnt_mul_rot_impl(
+    ($t: ident, $tv: ident, $mulrhs: ident) => (
+        vec_mul_rot_impl!($t, $tv, $mulrhs)
+    )
+)
+
 macro_rules! inv_impl(
     ($t: ident) => (
         impl<N: Clone> Inv for $t<N> {

src/structs/spec/mat.rs

@@ -1,5 +1,6 @@
 use std::num::{Zero, One};
 use structs::vec::{Vec2, Vec3, Vec2MulRhs, Vec3MulRhs};
+use structs::pnt::{Pnt2, Pnt3, Pnt2MulRhs, Pnt3MulRhs};
 use structs::mat::{Mat1, Mat2, Mat3, Mat3MulRhs, Mat2MulRhs};
 use traits::operations::{Inv, Det, ApproxEq};
 use traits::structure::{Row, Col};
@@ -284,3 +285,45 @@ impl<N: Mul<N, N> + Add<N, N>> Mat2MulRhs<N, Vec2<N>> for Vec2<N> {
         )
     }
 }
+
+impl<N: Mul<N, N> + Add<N, N>> Mat3MulRhs<N, Pnt3<N>> for Pnt3<N> {
+    #[inline(always)]
+    fn binop(left: &Mat3<N>, right: &Pnt3<N>) -> Pnt3<N> {
+        Pnt3::new(
+            left.m11 * right.x + left.m12 * right.y + left.m13 * right.z,
+            left.m21 * right.x + left.m22 * right.y + left.m23 * right.z,
+            left.m31 * right.x + left.m32 * right.y + left.m33 * right.z
+        )
+    }
+}
+
+impl<N: Mul<N, N> + Add<N, N>> Pnt3MulRhs<N, Pnt3<N>> for Mat3<N> {
+    #[inline(always)]
+    fn binop(left: &Pnt3<N>, right: &Mat3<N>) -> Pnt3<N> {
+        Pnt3::new(
+            left.x * right.m11 + left.y * right.m21 + left.z * right.m31,
+            left.x * right.m12 + left.y * right.m22 + left.z * right.m32,
+            left.x * right.m13 + left.y * right.m23 + left.z * right.m33
+        )
+    }
+}
+
+impl<N: Mul<N, N> + Add<N, N>> Pnt2MulRhs<N, Pnt2<N>> for Mat2<N> {
+    #[inline(always)]
+    fn binop(left: &Pnt2<N>, right: &Mat2<N>) -> Pnt2<N> {
+        Pnt2::new(
+            left.x * right.m11 + left.y * right.m21,
+            left.x * right.m12 + left.y * right.m22
+        )
+    }
+}
+
+impl<N: Mul<N, N> + Add<N, N>> Mat2MulRhs<N, Pnt2<N>> for Pnt2<N> {
+    #[inline(always)]
+    fn binop(left: &Mat2<N>, right: &Pnt2<N>) -> Pnt2<N> {
+        Pnt2::new(
+            left.m11 * right.x + left.m12 * right.y,
+            left.m21 * right.x + left.m22 * right.y
+        )
+    }
+}

src/structs/spec/vec0.rs

@@ -91,11 +91,6 @@ impl<N: Num> Dot<N> for vec::Vec0<N> {
     fn dot(_: &vec::Vec0<N>, _: &vec::Vec0<N>) -> N {
         Zero::zero()
     }
-
-    #[inline]
-    fn sub_dot(_: &vec::Vec0<N>, _: &vec::Vec0<N>, _: &vec::Vec0<N>) -> N {
-        Zero::zero()
-    }
 }
 
 impl<N, T> Mul<T, vec::Vec0<N>> for vec::Vec0<N> {

src/structs/vec.rs

@@ -10,7 +10,8 @@ use traits::operations::{ApproxEq, PartialOrd, PartialOrdering, PartialLess, Par
                          PartialGreater, NotComparable};
 use traits::geometry::{Transform, Rotate, FromHomogeneous, ToHomogeneous, Dot, Norm,
                        Translation, Translate};
-use traits::structure::{Basis, Cast, Dim, Indexable, Iterable, IterableMut};
+use traits::structure::{Basis, Cast, Dim, Indexable, Iterable, IterableMut, VecAsPnt};
+use structs::pnt::{Pnt1, Pnt2, Pnt3, Pnt4, Pnt5, Pnt6};
 
 
 /// Vector of dimension 0.
@@ -124,9 +125,11 @@ iterable_impl!(Vec1, 1)
 iterable_mut_impl!(Vec1, 1)
 to_homogeneous_impl!(Vec1, Vec2, y, x)
 from_homogeneous_impl!(Vec1, Vec2, y, x)
-translate_impl!(Vec1)
+translate_impl!(Vec1, Pnt1)
 rotate_impl!(Vec1)
-transform_impl!(Vec1)
+rotate_impl!(Pnt1)
+transform_impl!(Vec1, Pnt1)
+vec_as_pnt_impl!(Vec1, Pnt1)
 
 /// Vector of dimension 2.
 #[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Zero, Show)]
@@ -223,9 +226,11 @@ iterable_impl!(Vec2, 2)
 iterable_mut_impl!(Vec2, 2)
 to_homogeneous_impl!(Vec2, Vec3, z, x, y)
 from_homogeneous_impl!(Vec2, Vec3, z, x, y)
-translate_impl!(Vec2)
+translate_impl!(Vec2, Pnt2)
 rotate_impl!(Vec2)
-transform_impl!(Vec2)
+rotate_impl!(Pnt2)
+transform_impl!(Vec2, Pnt2)
+vec_as_pnt_impl!(Vec2, Pnt2)
 
 /// Vector of dimension 3.
 #[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Zero, Show)]
@@ -327,9 +332,11 @@ iterable_impl!(Vec3, 3)
 iterable_mut_impl!(Vec3, 3)
 to_homogeneous_impl!(Vec3, Vec4, w, x, y, z)
 from_homogeneous_impl!(Vec3, Vec4, w, x, y, z)
-translate_impl!(Vec3)
+translate_impl!(Vec3, Pnt3)
 rotate_impl!(Vec3)
-transform_impl!(Vec3)
+rotate_impl!(Pnt3)
+transform_impl!(Vec3, Pnt3)
+vec_as_pnt_impl!(Vec3, Pnt3)
 
 
 /// Vector of dimension 4.
@@ -431,9 +438,11 @@ iterable_impl!(Vec4, 4)
 iterable_mut_impl!(Vec4, 4)
 to_homogeneous_impl!(Vec4, Vec5, a, x, y, z, w)
 from_homogeneous_impl!(Vec4, Vec5, a, x, y, z, w)
-translate_impl!(Vec4)
+translate_impl!(Vec4, Pnt4)
 rotate_impl!(Vec4)
-transform_impl!(Vec4)
+rotate_impl!(Pnt4)
+transform_impl!(Vec4, Pnt4)
+vec_as_pnt_impl!(Vec4, Pnt4)
 
 /// Vector of dimension 5.
 #[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Zero, Show)]
@@ -536,9 +545,11 @@ iterable_impl!(Vec5, 5)
 iterable_mut_impl!(Vec5, 5)
 to_homogeneous_impl!(Vec5, Vec6, b, x, y, z, w, a)
 from_homogeneous_impl!(Vec5, Vec6, b, x, y, z, w, a)
-translate_impl!(Vec5)
+translate_impl!(Vec5, Pnt5)
 rotate_impl!(Vec5)
-transform_impl!(Vec5)
+rotate_impl!(Pnt5)
+transform_impl!(Vec5, Pnt5)
+vec_as_pnt_impl!(Vec5, Pnt5)
 
 /// Vector of dimension 6.
 #[deriving(Eq, PartialEq, Encodable, Decodable, Clone, Hash, Rand, Zero, Show)]
@@ -641,6 +652,8 @@ from_iterator_impl!(Vec6, iterator, iterator, iterator, iterator, iterator, iter
 bounded_impl!(Vec6, x, y, z, w, a, b)
 iterable_impl!(Vec6, 6)
 iterable_mut_impl!(Vec6, 6)
-translate_impl!(Vec6)
+translate_impl!(Vec6, Pnt6)
 rotate_impl!(Vec6)
-transform_impl!(Vec6)
+rotate_impl!(Pnt6)
+transform_impl!(Vec6, Pnt6)
+vec_as_pnt_impl!(Vec6, Pnt6)

src/structs/vec_macros.rs

@@ -405,11 +405,6 @@ macro_rules! dot_impl(
             fn dot(a: &$t<N>, b: &$t<N>) -> N {
                 a.$comp0 * b.$comp0 $(+ a.$compN * b.$compN )*
             }
-
-            #[inline]
-            fn sub_dot(a: &$t<N>, b: &$t<N>, c: &$t<N>) -> N {
-                (a.$comp0 - b.$comp0) * c.$comp0 $(+ (a.$compN - b.$compN) * c.$compN )*
-            }
         }
     )
 )
@@ -608,7 +603,7 @@ macro_rules! to_homogeneous_impl(
     ($t: ident, $t2: ident, $extra: ident, $comp0: ident $(,$compN: ident)*) => (
         impl<N: Clone + One + Zero> ToHomogeneous<$t2<N>> for $t<N> {
             fn to_homogeneous(v: &$t<N>) -> $t2<N> {
-                let mut res: $t2<N> = One::one();
+                let mut res: $t2<N> = Zero::zero();
 
                 res.$comp0    = v.$comp0.clone();
                 $( res.$compN = v.$compN.clone(); )*
@@ -625,8 +620,8 @@ macro_rules! from_homogeneous_impl(
             fn from(v: &$t2<N>) -> $t<N> {
                 let mut res: $t<N> = Zero::zero();
 
-                res.$comp0    = v.$comp0.clone() / v.$extra;
+                res.$comp0    = v.$comp0.clone();
-                $( res.$compN = v.$compN.clone() / v.$extra; )*
+                $( res.$compN = v.$compN.clone(); )*
 
                 res
             }
@@ -635,8 +630,8 @@ macro_rules! from_homogeneous_impl(
 )
 
 macro_rules! translate_impl(
-    ($t: ident) => (
+    ($tv: ident, $t: ident) => (
-        impl<N: Add<N, N> + Sub<N, N>> Translate<$t<N>> for $t<N> {
+        impl<N: Add<N, N> + Sub<N, N>> Translate<$t<N>> for $tv<N> {
             fn translate(&self, other: &$t<N>) -> $t<N> {
                 *other + *self
             }
@@ -663,8 +658,8 @@ macro_rules! rotate_impl(
 )
 
 macro_rules! transform_impl(
-    ($t: ident) => (
+    ($tv: ident, $t: ident) => (
-        impl<N: Clone + Add<N, N> + Sub<N, N>> Transform<$t<N>> for $t<N> {
+        impl<N: Clone + Add<N, N> + Sub<N, N>> Transform<$t<N>> for $tv<N> {
             fn transform(&self, other: &$t<N>) -> $t<N> {
                 self.translate(other)
             }
@@ -673,5 +668,35 @@ macro_rules! transform_impl(
                 self.inv_translate(other)
             }
         }
+
+        impl<N: Clone> Transform<$tv<N>> for $tv<N> {
+            fn transform(&self, other: &$tv<N>) -> $tv<N> {
+                other.clone()
+            }
+
+            fn inv_transform(&self, other: &$tv<N>) -> $tv<N> {
+                other.clone()
+            }
+        }
+    )
+)
+
+macro_rules! vec_as_pnt_impl(
+    ($tv: ident, $t: ident) => (
+        impl<N> $tv<N> {
+            #[inline]
+            pub fn as_pnt<'a>(&'a self) -> &'a $t<N> {
+                unsafe {
+                    mem::transmute(self)
+                }
+            }
+        }
+
+        impl<N> VecAsPnt<$t<N>> for $tv<N> {
+            #[inline]
+            fn as_pnt<'a>(&'a self) -> &'a $t<N> {
+                self.as_pnt()
+            }
+        }
     )
 )

src/traits/geometry.rs

@@ -202,19 +202,6 @@ pub trait Dot<N> {
     /// Computes the dot (inner) product of two vectors.
     #[inline]
     fn dot(&Self, &Self) -> N;
-
-    /**
-     * Short-cut to compute the projection of a point on a vector, but without
-     * computing intermediate vectors.
-     * The following equation must be verified:
-     *
-     * ```.ignore
-     *   a.sub_dot(b, c) == (a - b).dot(c)
-     * ```
-     *
-     */
-    #[inline]
-    fn sub_dot(a: &Self, b: &Self, c: &Self) -> N;
 }
 
 /// Traits of objects having an euclidian norm.
@@ -280,3 +267,21 @@ pub trait UniformSphereSample {
     /// Iterate through the samples.
     fn sample(|Self| -> ());
 }
+
+/// The zero element of a vector space, seen as an element of its embeding affine space.
+// XXX: once associated types are suported, move this to the `AnyPnt` trait.
+pub trait Orig {
+    /// The trivial origin.
+    fn orig() -> Self;
+    /// Returns true if this points is exactly the trivial origin.
+    fn is_orig(&self) -> bool;
+}
+
+/// Trait implemented by projectors.
+// XXX: Vout should be an associated type instead of a type parameter.
+pub trait Projector<Vin, Vout> {
+    /// Projects an element of a vector or affine space to a subspace.
+    ///
+    /// This must be an indempotent operaton.
+    fn project(&self, &Vin) -> Vout;
+}

src/traits/mod.rs

@@ -1,12 +1,13 @@
 //! Mathematical traits.
 
-pub use self::geometry::{AbsoluteRotate, Cross, CrossMatrix, Dot, FromHomogeneous, Norm, Rotate,
+pub use self::geometry::{AbsoluteRotate, Cross, CrossMatrix, Dot, FromHomogeneous, Norm, Orig,
-                         Rotation, RotationMatrix, RotationWithTranslation, ToHomogeneous,
+                         Projector, Rotate, Rotation, RotationMatrix, RotationWithTranslation,
-                         Transform, Transformation, Translate, Translation, UniformSphereSample};
+                         ToHomogeneous, Transform, Transformation, Translate, Translation,
+                         UniformSphereSample};
 
-pub use self::structure::{FloatVec, FloatVecExt, Basis, Cast, Col, Dim, Indexable,
+pub use self::structure::{FloatVec, FloatVecExt, FloatPnt, FloatPntExt, Basis, Cast, Col, Dim,
-                          Iterable, IterableMut, Mat, Row, AnyVec, VecExt,
+                          Indexable, Iterable, IterableMut, Mat, Row, AnyVec, VecExt, AnyPnt,
-                          ColSlice, RowSlice, Diag, Eye};
+                          PntExt, PntAsVec, VecAsPnt, ColSlice, RowSlice, Diag, Eye};
 
 pub use self::operations::{Absolute, ApproxEq, Cov, Det, Inv, LMul, Mean, Outer, PartialOrd, RMul,
                            ScalarAdd, ScalarSub, ScalarMul, ScalarDiv, Transpose};

src/traits/structure.rs

@@ -3,7 +3,7 @@
 use std::num::{Zero, Bounded};
 use std::slice::{Items, MutItems};
 use traits::operations::{RMul, LMul, ScalarAdd, ScalarSub};
-use traits::geometry::{Dot, Norm, UniformSphereSample};
+use traits::geometry::{Dot, Norm, UniformSphereSample, Orig};
 
 /// Traits of objects which can be created from an object of type `T`.
 pub trait Cast<T> {
@@ -28,37 +28,6 @@ pub trait Eye {
 // XXX: we keep ScalarAdd and ScalarSub here to avoid trait impl conflict (overriding) between the
 // different Add/Sub traits. This is _so_ unfortunate…
 
-/// Trait grouping most common operations on vectors.
-pub trait AnyVec<N>: Dim + Sub<Self, Self> + Add<Self, Self> + Neg<Self> + Zero + PartialEq + Mul<N, Self>
-                     + Div<N, Self> + Dot<N> {
-}
-
-/// Trait of vector with components implementing the `Float` trait.
-pub trait FloatVec<N: Float>: AnyVec<N> + Norm<N> {
-}
-
-/// Trait grouping uncommon, low-level and borderline (from the mathematical point of view)
-/// operations on vectors.
-pub trait VecExt<N>: AnyVec<N> + Indexable<uint, N> + Iterable<N> +
-                     UniformSphereSample + ScalarAdd<N> + ScalarSub<N> + Bounded
-{ }
-
-/// Trait grouping uncommon, low-level and borderline (from the mathematical point of view)
-/// operations on vectors.
-pub trait FloatVecExt<N: Float>: FloatVec<N> + VecExt<N> + Basis { }
-
-impl<N, V: Dim + Sub<V, V> + Add<V, V> + Neg<V> + Zero + PartialEq + Mul<N, V> + Div<N, V> + Dot<N>>
-AnyVec<N> for V { }
-
-impl<N: Float, V: AnyVec<N> + Norm<N>> FloatVec<N> for V { }
-
-impl<N,
-     V: AnyVec<N> + Indexable<uint, N> + Iterable<N> +
-        UniformSphereSample + ScalarAdd<N> + ScalarSub<N> + Bounded>
-VecExt<N> for V { }
-
-impl<N: Float, V: FloatVec<N> + VecExt<N> + Basis> FloatVecExt<N> for V { }
-
 // FIXME: return an iterator instead
 /// Traits of objects which can form a basis (typically vectors).
 pub trait Basis {
@@ -172,3 +141,92 @@ pub trait IterableMut<N> {
     /// Gets a vector-like read-write iterator.
     fn mut_iter<'l>(&'l mut self) -> MutItems<'l, N>;
 }
+
+/*
+ * Vec related traits.
+ */
+/// Trait that relates a point of an affine space to a vector of the associated vector space.
+pub trait VecAsPnt<P> {
+    /// Converts a reference to this point to a reference to its associated vector.
+    fn as_pnt<'a>(&'a self) -> &'a P;
+}
+
+/// Trait grouping most common operations on vectors.
+pub trait AnyVec<N>: Dim + Sub<Self, Self> + Add<Self, Self> + Neg<Self> + Zero + PartialEq + Mul<N, Self>
+                     + Div<N, Self> + Dot<N> {
+}
+
+/// Trait of vector with components implementing the `Float` trait.
+pub trait FloatVec<N: Float>: AnyVec<N> + Norm<N> {
+}
+
+/// Trait grouping uncommon, low-level and borderline (from the mathematical point of view)
+/// operations on vectors.
+pub trait VecExt<N>: AnyVec<N> + Indexable<uint, N> + Iterable<N> +
+                     UniformSphereSample + ScalarAdd<N> + ScalarSub<N> + Bounded
+{ }
+
+/// Trait grouping uncommon, low-level and borderline (from the mathematical point of view)
+/// operations on vectors.
+pub trait FloatVecExt<N: Float>: FloatVec<N> + VecExt<N> + Basis { }
+
+impl<N, V: Dim + Sub<V, V> + Add<V, V> + Neg<V> + Zero + PartialEq + Mul<N, V> + Div<N, V> + Dot<N>>
+AnyVec<N> for V { }
+
+impl<N: Float, V: AnyVec<N> + Norm<N>> FloatVec<N> for V { }
+
+impl<N,
+     V: AnyVec<N> + Indexable<uint, N> + Iterable<N> +
+        UniformSphereSample + ScalarAdd<N> + ScalarSub<N> + Bounded>
+VecExt<N> for V { }
+
+impl<N: Float, V: FloatVec<N> + VecExt<N> + Basis> FloatVecExt<N> for V { }
+
+/*
+ * Pnt related traits.
+ */
+/// Trait that relates a point of an affine space to a vector of the associated vector space.
+pub trait PntAsVec<V> {
+    /// Converts a reference to this point to a reference to its associated vector.
+    fn as_vec<'a>(&'a self) -> &'a V;
+}
+
+/// Trait grouping most common operations on points.
+// XXX: the vector space element `V` should be an associated type. Though this would prevent V from
+// having bounds (they are not supported yet). So, for now, we will just use a type parameter.
+pub trait AnyPnt<N, V>:
+          PntAsVec<V> + Dim + Sub<Self, V> + Orig + Neg<Self> + PartialEq + Mul<N, Self> + Div<N, Self> {
+}
+
+/// Trait of points with components implementing the `Float` trait.
+pub trait FloatPnt<N: Float, V: Norm<N>>: AnyPnt<N, V> {
+    /// Computes the square distance between two points.
+    #[inline]
+    fn sqdist(a: &Self, b: &Self) -> N {
+        Norm::sqnorm(&(*a - *b))
+    }
+
+    /// Computes the distance between two points.
+    #[inline]
+    fn dist(a: &Self, b: &Self) -> N {
+        Norm::norm(&(*a - *b))
+    }
+}
+
+/// Trait grouping uncommon, low-level and borderline (from the mathematical point of view)
+/// operations on points.
+pub trait PntExt<N, V>: AnyPnt<N, V> + Indexable<uint, N> + Iterable<N> +
+                        ScalarAdd<N> + ScalarSub<N> + Bounded
+{ }
+
+/// Trait grouping uncommon, low-level and borderline (from the mathematical point of view)
+/// operations on points.
+pub trait FloatPntExt<N: Float, V: Norm<N>> : FloatPnt<N, V> + PntExt<N, V> { }
+
+
+impl<N, V, P: PntAsVec<V> + Dim + Sub<P, V> + Orig + Neg<P> + PartialEq + Mul<N, P> + Div<N, P>>
+AnyPnt<N, V> for P { }
+impl<N: Float, V: Norm<N>, P: AnyPnt<N, V>> FloatPnt<N, V> for P { }
+impl<N, V, P: AnyPnt<N, V> + Indexable<uint, N> + Iterable<N> + ScalarAdd<N> + ScalarSub<N> + Bounded>
+PntExt<N, V> for P { }
+impl<N: Float, V: Norm<N>, P: FloatPnt<N, V> + PntExt<N, V>> FloatPntExt<N, V> for P { }