diff --git a/Makefile b/Makefile
index 3b5ede3e..698ee0b8 100644
--- a/Makefile
+++ b/Makefile
@@ -4,13 +4,13 @@ nalgebra_doc_path=doc
 all:
 	mkdir -p $(nalgebra_lib_path)
 	rustc src/lib.rs --out-dir $(nalgebra_lib_path) --opt-level 3
+	rustc src/lib.rs --out-dir $(nalgebra_lib_path) --crate-type dylib --opt-level 3
 
 test:
 	mkdir -p $(nalgebra_lib_path)
 	rustc --test src/lib.rs --opt-level 3 -o test~ && ./test~
 	rm test~
-	# FIXME:
-	# rustdoc --test -L lib src/lib.rs
+	rustdoc --test -L lib src/lib.rs
 
 bench:
 	rustc --test src/lib.rs --opt-level 3 -o bench~ && ./bench~ --bench
diff --git a/src/lib.rs b/src/lib.rs
index 04a8c2fe..4a102114 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -18,7 +18,7 @@ out-of-place modifications.
 
 * You can import the whole prelude using:
 
-```
+```.ignore
 use nalgebra::na::*;
 ```
 
@@ -26,7 +26,7 @@ The preferred way to use **nalgebra** is to import types and traits explicitly,
 free-functions using the `na::` prefix:
 
 ```.rust
-extern mod nalgebra;
+extern crate nalgebra;
 use nalgebra::na::{Vec3, Rot3, Rotation};
 use nalgebra::na;
 
@@ -57,7 +57,7 @@ and keeps an optimized set of tools for computational graphics and physics. Thos
   For example, the following works:
 
 ```rust
-extern mod nalgebra;
+extern crate nalgebra;
 use nalgebra::na::{Vec3, Mat3};
 use nalgebra::na;
 
@@ -76,13 +76,15 @@ fn main() {
 You will need the last rust compiler from the master branch.
 If you encounter problems, make sure you have the last version before creating an issue.
 
-    git clone git://github.com/sebcrozet/nalgebra.git
-    cd nalgebra
-    make
+```.ignore
+git clone git://github.com/sebcrozet/nalgebra.git
+cd nalgebra
+make
+```
 
 You can build the documentation on the `doc` folder using:
 
-```
+```.ignore
 make doc
 ```
 
@@ -107,9 +109,9 @@ Feel free to add your project to this list if you happen to use **nalgebra**!
 #[feature(macro_rules)];
 #[doc(html_root_url = "http://www.rust-ci.org/sebcrozet/nalgebra/doc")];
 
-extern mod std;
-extern mod extra;
-extern mod serialize;
+extern crate std;
+extern crate extra;
+extern crate serialize;
 
 pub mod na;
 mod structs;
diff --git a/src/na.rs b/src/na.rs
index e4fd655d..b81c3283 100644
--- a/src/na.rs
+++ b/src/na.rs
@@ -1,12 +1,14 @@
 //! **nalgebra** prelude.
 
 use std::num::{Zero, One};
+use std::cmp;
+pub use traits::{Less, Equal, Greater, NotComparable};
 pub use traits::{
     Absolute,
     AbsoluteRotate,
     ApproxEq,
-    RealVec,
-    RealVecExt,
+    FloatVec,
+    FloatVecExt,
     Basis,
     Cast,
     Col,
@@ -25,6 +27,8 @@ pub use traits::{
     Mean,
     Norm,
     Outer,
+    PartialOrd,
+    PartialOrdering,
     RMul,
     Rotate, Rotation, RotationMatrix, RotationWithTranslation,
     Row,
@@ -48,6 +52,71 @@ pub use structs::{
     Vec0, Vec1, Vec2, Vec3, Vec4, Vec5, Vec6
 };
 
+/// Change the input value to ensure it is on the range `[min, max]`.
+#[inline(always)]
+pub fn clamp<T: Ord>(val: T, min: T, max: T) -> T {
+    if val > min {
+        if val < max {
+            val
+        }
+        else {
+            max
+        }
+    }
+    else {
+        min
+    }
+}
+
+/// Same as `cmp::max`.
+#[inline(always)]
+pub fn max<T: Ord>(a: T, b: T) -> T {
+    cmp::max(a, b)
+}
+
+/// Same as `cmp::min`.
+#[inline(always)]
+pub fn min<T: Ord>(a: T, b: T) -> T {
+    cmp::min(a, b)
+}
+
+/// Returns the infimum of `a` and `b`.
+#[inline(always)]
+pub fn inf<T: PartialOrd>(a: &T, b: &T) -> T {
+    PartialOrd::inf(a, b)
+}
+
+/// Returns the supremum of `a` and `b`.
+#[inline(always)]
+pub fn sup<T: PartialOrd>(a: &T, b: &T) -> T {
+    PartialOrd::sup(a, b)
+}
+
+/// Compare `a` and `b` using a partial ordering relation.
+#[inline(always)]
+pub fn partial_cmp<T: PartialOrd>(a: &T, b: &T) -> PartialOrdering {
+    PartialOrd::partial_cmp(a, b)
+}
+
+/// Return the minimum of `a` and `b` if they are comparable.
+#[inline(always)]
+pub fn partial_min<'a, T: PartialOrd>(a: &'a T, b: &'a T) -> Option<&'a T> {
+    PartialOrd::partial_min(a, b)
+}
+
+/// Return the maximum of `a` and `b` if they are comparable.
+#[inline(always)]
+pub fn partial_max<'a, T: PartialOrd>(a: &'a T, b: &'a T) -> Option<&'a T> {
+    PartialOrd::partial_max(a, b)
+}
+
+/// Clamp `value` between `min` and `max`. Returns `None` if `value` is not comparable to
+/// `min` or `max`.
+#[inline(always)]
+pub fn partial_clamp<'a, T: PartialOrd>(value: &'a T, min: &'a T, max: &'a T) -> Option<&'a T> {
+    PartialOrd::partial_clamp(value, min, max)
+}
+
 //
 //
 // Constructors
@@ -89,7 +158,7 @@ pub fn one<T: One>() -> T {
  */
 /// Computes a projection matrix given the frustrum near plane width, height, the field of
 /// view, and the distance to the clipping planes (`znear` and `zfar`).
-pub fn perspective3d<N: Real + Cast<f32> + Zero + One>(width: N, height: N, fov: N, znear: N, zfar: N) -> Mat4<N> {
+pub fn perspective3d<N: Float + Cast<f32> + Zero + One>(width: N, height: N, fov: N, znear: N, zfar: N) -> Mat4<N> {
     let aspect = width / height;
 
     let _1: N = one();
@@ -112,7 +181,7 @@ pub fn perspective3d<N: Real + Cast<f32> + Zero + One>(width: N, height: N, fov:
 /// Gets the translation applicable by `m`.
 ///
 /// ```rust
-/// extern mod nalgebra;
+/// extern crate nalgebra;
 /// use nalgebra::na::{Vec3, Iso3};
 /// use nalgebra::na;
 ///
@@ -131,7 +200,7 @@ pub fn translation<V, M: Translation<V>>(m: &M) -> V {
 /// Gets the inverse translation applicable by `m`.
 ///
 /// ```rust
-/// extern mod nalgebra;
+/// extern crate nalgebra;
 /// use nalgebra::na::{Vec3, Iso3};
 /// use nalgebra::na;
 ///
@@ -160,7 +229,7 @@ pub fn append_translation<V, M: Translation<V>>(m: &M, v: &V) -> M {
 /// Applies a translation to a vector.
 ///
 /// ```rust
-/// extern mod nalgebra;
+/// extern crate nalgebra;
 /// use nalgebra::na::{Vec3, Iso3};
 /// use nalgebra::na;
 ///
@@ -181,7 +250,7 @@ pub fn translate<V, M: Translate<V>>(m: &M, v: &V) -> V {
 /// Applies an inverse translation to a vector.
 ///
 /// ```rust
-/// extern mod nalgebra;
+/// extern crate nalgebra;
 /// use nalgebra::na::{Vec3, Iso3};
 /// use nalgebra::na;
 ///
@@ -205,7 +274,7 @@ pub fn inv_translate<V, M: Translate<V>>(m: &M, v: &V) -> V {
 /// Gets the rotation applicable by `m`.
 ///
 /// ```rust
-/// extern mod nalgebra;
+/// extern crate nalgebra;
 /// use nalgebra::na::{Vec3, Rot3};
 /// use nalgebra::na;
 ///
@@ -224,7 +293,7 @@ pub fn rotation<V, M: Rotation<V>>(m: &M) -> V {
 /// Gets the inverse rotation applicable by `m`.
 ///
 /// ```rust
-/// extern mod nalgebra;
+/// extern crate nalgebra;
 /// use nalgebra::na::{Vec3, Rot3};
 /// use nalgebra::na;
 ///
@@ -243,7 +312,7 @@ pub fn inv_rotation<V, M: Rotation<V>>(m: &M) -> V {
 /// Applies the rotation `v` to a copy of `m`.
 ///
 /// ```rust
-/// extern mod nalgebra;
+/// extern crate nalgebra;
 /// use nalgebra::na::{Vec3, Rot3};
 /// use nalgebra::na;
 ///
@@ -264,7 +333,7 @@ pub fn append_rotation<V, M: Rotation<V>>(m: &M, v: &V) -> M {
 /// Pre-applies the rotation `v` to a copy of `m`.
 ///
 /// ```rust
-/// extern mod nalgebra;
+/// extern crate nalgebra;
 /// use nalgebra::na::{Vec3, Rot3};
 /// use nalgebra::na;
 ///
@@ -288,13 +357,13 @@ pub fn prepend_rotation<V, M: Rotation<V>>(m: &M, v: &V) -> M {
 /// Applies a rotation to a vector.
 ///
 /// ```rust
-/// extern mod nalgebra;
-/// use std::num::Real;
+/// extern crate nalgebra;
+/// use std::num::Float;
 /// use nalgebra::na::{Rot3, Vec3};
 /// use nalgebra::na;
 ///
 /// fn main() {
-///     let t  = Rot3::new(Vec3::new(0.0, 0.0, 0.5 * Real::pi()));
+///     let t  = Rot3::new(Vec3::new(0.0, 0.0, 0.5 * Float::pi()));
 ///     let v  = Vec3::new(1.0, 0.0, 0.0);
 ///
 ///     let tv = na::rotate(&t, &v);
@@ -311,13 +380,13 @@ pub fn rotate<V, M: Rotate<V>>(m: &M, v: &V) -> V {
 /// Applies an inverse rotation to a vector.
 ///
 /// ```rust
-/// extern mod nalgebra;
-/// use std::num::Real;
+/// extern crate nalgebra;
+/// use std::num::Float;
 /// use nalgebra::na::{Rot3, Vec3};
 /// use nalgebra::na;
 ///
 /// fn main() {
-///     let t  = Rot3::new(Vec3::new(0.0, 0.0, 0.5 * Real::pi()));
+///     let t  = Rot3::new(Vec3::new(0.0, 0.0, 0.5 * Float::pi()));
 ///     let v  = Vec3::new(1.0, 0.0, 0.0);
 ///
 ///     let tv = na::inv_rotate(&t, &v);
@@ -435,19 +504,19 @@ pub fn sub_dot<V: Dot<N>, N>(a: &V, b: &V, c: &V) -> N {
 
 /// Computes the L2 norm of a vector.
 #[inline(always)]
-pub fn norm<V: Norm<N>, N: Real>(v: &V) -> N {
+pub fn norm<V: Norm<N>, N: Float>(v: &V) -> N {
     Norm::norm(v)
 }
 
 /// Computes the squared L2 norm of a vector.
 #[inline(always)]
-pub fn sqnorm<V: Norm<N>, N: Real>(v: &V) -> N {
+pub fn sqnorm<V: Norm<N>, N: Float>(v: &V) -> N {
     Norm::sqnorm(v)
 }
 
 /// Gets the normalized version of a vector.
 #[inline(always)]
-pub fn normalize<V: Norm<N>, N: Real>(v: &V) -> V {
+pub fn normalize<V: Norm<N>, N: Float>(v: &V) -> V {
     Norm::normalize_cpy(v)
 }
 
diff --git a/src/structs/dvec.rs b/src/structs/dvec.rs
index 802cfa9d..d4e78b17 100644
--- a/src/structs/dvec.rs
+++ b/src/structs/dvec.rs
@@ -2,7 +2,7 @@
 
 #[allow(missing_doc)]; // we hide doc to not have to document the $trhs double dispatch trait.
 
-use std::num::{Zero, One, Real};
+use std::num::{Zero, One, Float};
 use std::rand::Rand;
 use std::rand;
 use std::vec;
@@ -177,7 +177,7 @@ impl<N> FromIterator<N> for DVec<N> {
     }
 }
 
-impl<N: Clone + Num + Real + ApproxEq<N> + DVecMulRhs<N, DVec<N>>> DVec<N> {
+impl<N: Clone + Num + Float + ApproxEq<N> + DVecMulRhs<N, DVec<N>>> DVec<N> {
     /// Computes the canonical basis for the given dimension. A canonical basis is a set of
     /// vectors, mutually orthogonal, with all its component equal to 0.0 except one which is equal
     /// to 1.0.
@@ -284,7 +284,7 @@ impl<N: Num + Clone> Dot<N> for DVec<N> {
     } 
 }
 
-impl<N: Num + Real + Clone> Norm<N> for DVec<N> {
+impl<N: Num + Float + Clone> Norm<N> for DVec<N> {
     #[inline]
     fn sqnorm(v: &DVec<N>) -> N {
         Dot::dot(v, v)
diff --git a/src/structs/iso.rs b/src/structs/iso.rs
index c69d93b2..8fecfb34 100644
--- a/src/structs/iso.rs
+++ b/src/structs/iso.rs
@@ -51,7 +51,7 @@ pub struct Iso4<N> {
     translation: Vec4<N>
 }
 
-impl<N: Clone + Num + Real> Iso3<N> {
+impl<N: Clone + Num + Float> Iso3<N> {
     /// Reorient and translate this transformation such that its local `x` axis points to a given
     /// direction.  Note that the usually known `look_at` function does the same thing but with the
     /// `z` axis. See `look_at_z` for that.
diff --git a/src/structs/iso_macros.rs b/src/structs/iso_macros.rs
index 0762b685..98e6cd99 100644
--- a/src/structs/iso_macros.rs
+++ b/src/structs/iso_macros.rs
@@ -2,7 +2,7 @@
 
 macro_rules! iso_impl(
     ($t: ident, $submat: ident, $subvec: ident, $subrotvec: ident) => (
-        impl<N: Clone + Real + Real + Num> $t<N> {
+        impl<N: Clone + Float + Float + Num> $t<N> {
             /// Creates a new isometry from a rotation matrix and a vector.
             #[inline]
             pub fn new(translation: $subvec<N>, rotation: $subrotvec<N>) -> $t<N> {
@@ -26,7 +26,7 @@ macro_rules! iso_impl(
 
 macro_rules! rotation_matrix_impl(
     ($t: ident, $trot: ident, $tlv: ident, $tav: ident) => (
-        impl<N: Cast<f32> + Real + Real + Num + Clone>
+        impl<N: Cast<f32> + Float + Float + Num + Clone>
         RotationMatrix<$tlv<N>, $tav<N>, $trot<N>> for $t<N> {
             #[inline]
             fn to_rot_mat(&self) -> $trot<N> {
@@ -50,7 +50,7 @@ macro_rules! dim_impl(
 
 macro_rules! one_impl(
     ($t: ident) => (
-        impl<N: Real + Real + Num + Clone> One for $t<N> {
+        impl<N: Float + Float + Num + Clone> One for $t<N> {
             #[inline]
             fn one() -> $t<N> {
                 $t::new_with_rotmat(Zero::zero(), One::one())
@@ -61,7 +61,7 @@ macro_rules! one_impl(
 
 macro_rules! iso_mul_iso_impl(
     ($t: ident, $tmul: ident) => (
-        impl<N: Num + Real + Real + Clone> $tmul<N, $t<N>> for $t<N> {
+        impl<N: Num + Float + Float + Clone> $tmul<N, $t<N>> for $t<N> {
             #[inline]
             fn binop(left: &$t<N>, right: &$t<N>) -> $t<N> {
                 $t::new_with_rotmat(
@@ -96,7 +96,7 @@ macro_rules! vec_mul_iso_impl(
 
 macro_rules! translation_impl(
     ($t: ident, $tv: ident) => (
-        impl<N: Real + Num + Real + Clone> Translation<$tv<N>> for $t<N> {
+        impl<N: Float + Num + Float + Clone> Translation<$tv<N>> for $t<N> {
             #[inline]
             fn translation(&self) -> $tv<N> {
                 self.translation.clone()
@@ -153,7 +153,7 @@ macro_rules! translate_impl(
 
 macro_rules! rotation_impl(
     ($t: ident, $trot: ident, $tav: ident) => (
-        impl<N: Cast<f32> + Num + Real + Real + Clone> Rotation<$tav<N>> for $t<N> {
+        impl<N: Cast<f32> + Num + Float + Float + Clone> Rotation<$tav<N>> for $t<N> {
             #[inline]
             fn rotation(&self) -> $tav<N> {
                 self.rotation.rotation()
@@ -220,7 +220,7 @@ macro_rules! rotate_impl(
 
 macro_rules! transformation_impl(
     ($t: ident) => (
-        impl<N: Num + Real + Real + Clone> Transformation<$t<N>> for $t<N> {
+        impl<N: Num + Float + Float + Clone> Transformation<$t<N>> for $t<N> {
             fn transformation(&self) -> $t<N> {
                 self.clone()
             }
@@ -336,7 +336,7 @@ macro_rules! approx_eq_impl(
 
 macro_rules! rand_impl(
     ($t: ident) => (
-        impl<N: Rand + Clone + Real + Real + Num> Rand for $t<N> {
+        impl<N: Rand + Clone + Float + Float + Num> Rand for $t<N> {
             #[inline]
             fn rand<R: Rng>(rng: &mut R) -> $t<N> {
                 $t::new(rng.gen(), rng.gen())
diff --git a/src/structs/rot.rs b/src/structs/rot.rs
index e7daa12f..bed3fd95 100644
--- a/src/structs/rot.rs
+++ b/src/structs/rot.rs
@@ -20,7 +20,7 @@ pub struct Rot2<N> {
     priv submat: Mat2<N>
 }
 
-impl<N: Clone + Real + Neg<N>> Rot2<N> {
+impl<N: Clone + Float + Neg<N>> Rot2<N> {
     /// Builds a 2 dimensional rotation matrix from an angle in radian.
     pub fn new(angle: Vec1<N>) -> Rot2<N> {
         let (sia, coa) = angle.x.sin_cos();
@@ -31,7 +31,7 @@ impl<N: Clone + Real + Neg<N>> Rot2<N> {
     }
 }
 
-impl<N: Real + Num + Clone>
+impl<N: Float + Num + Clone>
 Rotation<Vec1<N>> for Rot2<N> {
     #[inline]
     fn rotation(&self) -> Vec1<N> {
@@ -69,7 +69,7 @@ Rotation<Vec1<N>> for Rot2<N> {
     }
 }
 
-impl<N: Clone + Rand + Real + Neg<N>> Rand for Rot2<N> {
+impl<N: Clone + Rand + Float + Neg<N>> Rand for Rot2<N> {
     #[inline]
     fn rand<R: Rng>(rng: &mut R) -> Rot2<N> {
         Rot2::new(rng.gen())
@@ -99,7 +99,7 @@ pub struct Rot3<N> {
 }
 
 
-impl<N: Clone + Real + Num + Real> Rot3<N> {
+impl<N: Clone + Float + Num + Float> Rot3<N> {
     /// Builds a 3 dimensional rotation matrix from an axis and an angle.
     ///
     /// # Arguments
@@ -140,7 +140,7 @@ impl<N: Clone + Real + Num + Real> Rot3<N> {
     }
 }
 
-impl<N: Clone + Num + Real> Rot3<N> {
+impl<N: Clone + Num + Float> Rot3<N> {
     /// Reorient this matrix such that its local `x` axis points to a given point. Note that the
     /// usually known `look_at` function does the same thing but with the `z` axis. See `look_at_z`
     /// for that.
@@ -180,7 +180,7 @@ impl<N: Clone + Num + Real> Rot3<N> {
     }
 }
 
-impl<N: Clone + Real + Num + Real + Cast<f32>>
+impl<N: Clone + Float + Num + Float + Cast<f32>>
 Rotation<Vec3<N>> for Rot3<N> {
     #[inline]
     fn rotation(&self) -> Vec3<N> {
@@ -245,7 +245,7 @@ Rotation<Vec3<N>> for Rot3<N> {
     }
 }
 
-impl<N: Clone + Rand + Real + Num + Real>
+impl<N: Clone + Rand + Float + Num + Float>
 Rand for Rot3<N> {
     #[inline]
     fn rand<R: Rng>(rng: &mut R) -> Rot3<N> {
@@ -309,7 +309,7 @@ impl<N: Signed> AbsoluteRotate<Vec4<N>> for Rot4<N> {
     }
 }
 
-impl<N: Real + Num + Clone>
+impl<N: Float + Num + Clone>
 Rotation<Vec4<N>> for Rot4<N> {
     #[inline]
     fn rotation(&self) -> Vec4<N> {
diff --git a/src/structs/rot_macros.rs b/src/structs/rot_macros.rs
index 7b130aa2..40808458 100644
--- a/src/structs/rot_macros.rs
+++ b/src/structs/rot_macros.rs
@@ -56,7 +56,7 @@ macro_rules! dim_impl(
 
 macro_rules! rotation_matrix_impl(
     ($t: ident, $tlv: ident, $tav: ident) => (
-        impl<N: Cast<f32> + Real + Real + Num + Clone>
+        impl<N: Cast<f32> + Float + Float + Num + Clone>
         RotationMatrix<$tlv<N>, $tav<N>, $t<N>> for $t<N> {
             #[inline]
             fn to_rot_mat(&self) -> $t<N> {
diff --git a/src/structs/spec/vec.rs b/src/structs/spec/vec.rs
index 38a16d08..5b747808 100644
--- a/src/structs/spec/vec.rs
+++ b/src/structs/spec/vec.rs
@@ -91,7 +91,7 @@ impl<N: Clone + One + Zero + Neg<N>> Basis for Vec2<N> {
     }
 }
 
-impl<N: Clone + Ord + Real + Signed> Basis for Vec3<N> {
+impl<N: Clone + Ord + Float + Signed> Basis for Vec3<N> {
     #[inline(always)]
     fn canonical_basis(f: |Vec3<N>| -> bool) {
         if !f(Vec3::new(One::one(), Zero::zero(), Zero::zero())) { return };
diff --git a/src/structs/spec/vec0.rs b/src/structs/spec/vec0.rs
index 4530084c..a1572c48 100644
--- a/src/structs/spec/vec0.rs
+++ b/src/structs/spec/vec0.rs
@@ -1,5 +1,5 @@
 use std::cast;
-use std::num::{Zero, One, Real, Bounded};
+use std::num::{Zero, One, Float, Bounded};
 use std::vec::{Items, MutItems};
 use std::iter::{Iterator, FromIterator};
 use traits::operations::ApproxEq;
@@ -159,7 +159,7 @@ impl<N: Clone + Add<N, N> + Neg<N>> Translation<vec::Vec0<N>> for vec::Vec0<N> {
     }
 }
 
-impl<N: Num + Real> Norm<N> for vec::Vec0<N> {
+impl<N: Num + Float> Norm<N> for vec::Vec0<N> {
     #[inline]
     fn sqnorm(_: &vec::Vec0<N>) -> N {
         Zero::zero()
diff --git a/src/structs/vec.rs b/src/structs/vec.rs
index c7884475..88cd1bb9 100644
--- a/src/structs/vec.rs
+++ b/src/structs/vec.rs
@@ -3,10 +3,11 @@
 #[allow(missing_doc)]; // we allow missing to avoid having to document the vector components.
 
 use std::cast;
-use std::num::{Zero, One, Real, Bounded};
+use std::cmp;
+use std::num::{Zero, One, Float, Bounded};
 use std::vec::{Items, MutItems};
 use std::iter::{Iterator, FromIterator};
-use traits::operations::ApproxEq;
+use traits::operations::{ApproxEq, PartialOrd, PartialOrdering, Less, Equal, Greater, NotComparable};
 
 use traits::geometry::{Transform, Rotate, FromHomogeneous, ToHomogeneous, Dot, Norm,
                        Translation, Translate};
@@ -38,7 +39,6 @@ sub_redispatch_impl!(Vec1, Vec1SubRhs)
 cast_redispatch_impl!(Vec1, Vec1Cast)
 new_impl!(Vec1, x)
 ord_impl!(Vec1, x)
-orderable_impl!(Vec1, x)
 vec_axis_impl!(Vec1, x)
 vec_cast_impl!(Vec1, Vec1Cast, x)
 indexable_impl!(Vec1, 1)
@@ -137,7 +137,6 @@ sub_redispatch_impl!(Vec2, Vec2SubRhs)
 cast_redispatch_impl!(Vec2, Vec2Cast)
 new_impl!(Vec2, x, y)
 ord_impl!(Vec2, x, y)
-orderable_impl!(Vec2, x, y)
 vec_axis_impl!(Vec2, x, y)
 vec_cast_impl!(Vec2, Vec2Cast, x, y)
 indexable_impl!(Vec2, 2)
@@ -238,7 +237,6 @@ sub_redispatch_impl!(Vec3, Vec3SubRhs)
 cast_redispatch_impl!(Vec3, Vec3Cast)
 new_impl!(Vec3, x, y, z)
 ord_impl!(Vec3, x, y, z)
-orderable_impl!(Vec3, x, y, z)
 vec_axis_impl!(Vec3, x, y, z)
 vec_cast_impl!(Vec3, Vec3Cast, x, y, z)
 indexable_impl!(Vec3, 3)
@@ -345,7 +343,6 @@ sub_redispatch_impl!(Vec4, Vec4SubRhs)
 cast_redispatch_impl!(Vec4, Vec4Cast)
 new_impl!(Vec4, x, y, z, w)
 ord_impl!(Vec4, x, y, z, w)
-orderable_impl!(Vec4, x, y, z, w)
 vec_axis_impl!(Vec4, x, y, z, w)
 vec_cast_impl!(Vec4, Vec4Cast, x, y, z, w)
 indexable_impl!(Vec4, 4)
@@ -450,7 +447,6 @@ sub_redispatch_impl!(Vec5, Vec5SubRhs)
 cast_redispatch_impl!(Vec5, Vec5Cast)
 new_impl!(Vec5, x, y, z, w, a)
 ord_impl!(Vec5, x, y, z, w, a)
-orderable_impl!(Vec5, x, y, z, w, a)
 vec_axis_impl!(Vec5, x, y, z, w, a)
 vec_cast_impl!(Vec5, Vec5Cast, x, y, z, w, a)
 indexable_impl!(Vec5, 5)
@@ -557,7 +553,6 @@ sub_redispatch_impl!(Vec6, Vec6SubRhs)
 cast_redispatch_impl!(Vec6, Vec6Cast)
 new_impl!(Vec6, x, y, z, w, a, b)
 ord_impl!(Vec6, x, y, z, w, a, b)
-orderable_impl!(Vec6, x, y, z, w, a, b)
 vec_axis_impl!(Vec6, x, y, z, w, a, b)
 vec_cast_impl!(Vec6, Vec6Cast, x, y, z, w, a, b)
 indexable_impl!(Vec6, 6)
diff --git a/src/structs/vec_macros.rs b/src/structs/vec_macros.rs
index 9c105265..11eac72b 100644
--- a/src/structs/vec_macros.rs
+++ b/src/structs/vec_macros.rs
@@ -36,47 +36,52 @@ macro_rules! at_fast_impl(
 
 macro_rules! ord_impl(
     ($t: ident, $comp0: ident $(,$compN: ident)*) => (
-        impl<N: Ord> Ord for $t<N> {
+        impl<N: Ord + Eq + Clone> PartialOrd for $t<N> {
             #[inline]
-            fn lt(&self, other: &$t<N>) -> bool {
-                self.$comp0 < other.$comp0 $(&& self.$compN < other.$compN)*
+            fn inf(a: &$t<N>, b: &$t<N>) -> $t<N> {
+                $t::new(cmp::min(a.$comp0.clone(), b.$comp0.clone())
+                        $(, cmp::min(a.$compN.clone(), b.$compN.clone()))*)
             }
 
             #[inline]
-            fn le(&self, other: &$t<N>) -> bool {
-                self.$comp0 <= other.$comp0 $(&& self.$compN <= other.$compN)*
+            fn sup(a: &$t<N>, b: &$t<N>) -> $t<N> {
+                $t::new(cmp::max(a.$comp0.clone(), b.$comp0.clone())
+                        $(, cmp::max(a.$compN.clone(), b.$compN.clone()))*)
             }
 
             #[inline]
-            fn gt(&self, other: &$t<N>) -> bool {
-                self.$comp0 > other.$comp0 $(&& self.$compN > other.$compN)*
-            }
+            #[allow(unused_mut)] // otherwise there will be a warning for is_eq or Vec1.
+            fn partial_cmp(a: &$t<N>, b: &$t<N>) -> PartialOrdering {
+                let is_lt     = a.$comp0 <  b.$comp0;
+                let mut is_eq = a.$comp0 == b.$comp0;
 
-            #[inline]
-            fn ge(&self, other: &$t<N>) -> bool {
-                self.$comp0 >= other.$comp0 $(&& self.$compN >= other.$compN)*
-            }
-        }
-    )
-)
+                if is_lt { // <
+                    $(
+                        if a.$compN > b.$compN {
+                            return NotComparable
+                        }
+                     )*
 
-macro_rules! orderable_impl(
-    ($t: ident, $comp0: ident $(,$compN: ident)*) => (
-        impl<N: Clone + Orderable> Orderable for $t<N> {
-            #[inline]
-            fn max(&self, other: &$t<N>) -> $t<N> {
-                $t::new(self.$comp0.max(&other.$comp0) $(, self.$compN.max(&other.$compN))*)
-            }
+                    Less
+                }
+                else { // >=
+                    $(
+                        if a.$compN < b.$compN {
+                            return NotComparable
+                        }
+                        else if a.$compN > b.$compN {
+                            is_eq = false;
+                        }
 
-            #[inline]
-            fn min(&self, other: &$t<N>) -> $t<N> {
-                $t::new(self.$comp0.min(&other.$comp0) $(, self.$compN.min(&other.$compN))*)
-            }
+                     )*
 
-            #[inline]
-            fn clamp(&self, min: &$t<N>, max: &$t<N>) -> $t<N> {
-                $t::new(self.$comp0.clamp(&min.$comp0, &max.$comp0)
-                        $(, self.$compN.clamp(&min.$comp0, &max.$comp0))*)
+                    if is_eq {
+                        Equal
+                    }
+                    else {
+                        Greater
+                    }
+                }
             }
         }
     )
@@ -223,7 +228,7 @@ macro_rules! container_impl(
 
 macro_rules! basis_impl(
     ($t: ident, $trhs: ident, $dim: expr) => (
-        impl<N: Clone + Num + Real + ApproxEq<N> + $trhs<N, $t<N>>> Basis for $t<N> {
+        impl<N: Clone + Num + Float + ApproxEq<N> + $trhs<N, $t<N>>> Basis for $t<N> {
             #[inline]
             fn canonical_basis(f: |$t<N>| -> bool) {
                 for i in range(0u, $dim) {
@@ -433,7 +438,7 @@ macro_rules! translation_impl(
 
 macro_rules! norm_impl(
     ($t: ident, $comp0: ident $(,$compN: ident)*) => (
-        impl<N: Clone + Num + Real> Norm<N> for $t<N> {
+        impl<N: Clone + Num + Float> Norm<N> for $t<N> {
             #[inline]
             fn sqnorm(v: &$t<N>) -> N {
                 Dot::dot(v, v)
diff --git a/src/tests/mat.rs b/src/tests/mat.rs
index c654696b..f34a004c 100644
--- a/src/tests/mat.rs
+++ b/src/tests/mat.rs
@@ -1,4 +1,4 @@
-use std::num::{Real, abs};
+use std::num::{Float, abs};
 use std::rand::random;
 use na::{Vec1, Vec3, Mat1, Mat2, Mat3, Mat4, Mat5, Mat6, Rot3, DMat, DVec, Indexable};
 use na;
@@ -87,7 +87,7 @@ fn test_inv_mat6() {
 fn test_rotation2() {
     for _ in range(0, 10000) {
         let randmat: na::Rot2<f64> = na::one();
-        let ang    = Vec1::new(abs::<f64>(random()) % Real::pi());
+        let ang    = Vec1::new(abs::<f64>(random()) % Float::pi());
 
         assert!(na::approx_eq(&na::rotation(&na::append_rotation(&randmat, &ang)), &ang));
     }
@@ -105,7 +105,7 @@ fn test_inv_rotation3() {
     for _ in range(0, 10000) {
         let randmat: Rot3<f64> = na::one();
         let dir:     Vec3<f64> = random();
-        let ang            = na::normalize(&dir) * (abs::<f64>(random()) % Real::pi());
+        let ang            = na::normalize(&dir) * (abs::<f64>(random()) % Float::pi());
         let rot            = na::append_rotation(&randmat, &ang);
 
         assert!(na::approx_eq(&(na::transpose(&rot) * rot), &na::one()));
diff --git a/src/tests/vec.rs b/src/tests/vec.rs
index fca0cbe4..ea78040b 100644
--- a/src/tests/vec.rs
+++ b/src/tests/vec.rs
@@ -292,23 +292,19 @@ fn test_ord_vec3() {
     assert!(Vec3::new(1.5, 0.5, 0.5) != Vec3::new(0.5, 0.5, 0.5));
 
     // comparable
-    assert!(Vec3::new(0.5, 0.3, 0.3) < Vec3::new(1.0, 2.0, 1.0));
-    assert!(Vec3::new(0.5, 0.3, 0.3) <= Vec3::new(1.0, 2.0, 1.0));
-    assert!(Vec3::new(2.0, 4.0, 2.0) > Vec3::new(1.0, 2.0, 1.0));
-    assert!(Vec3::new(2.0, 4.0, 2.0) >= Vec3::new(1.0, 2.0, 1.0));
+    assert!(na::partial_cmp(&Vec3::new(0.5, 0.3, 0.3), &Vec3::new(1.0, 2.0, 1.0)).is_le());
+    assert!(na::partial_cmp(&Vec3::new(0.5, 0.3, 0.3), &Vec3::new(1.0, 2.0, 1.0)).is_lt());
+    assert!(na::partial_cmp(&Vec3::new(2.0, 4.0, 2.0), &Vec3::new(1.0, 2.0, 1.0)).is_ge());
+    assert!(na::partial_cmp(&Vec3::new(2.0, 4.0, 2.0), &Vec3::new(1.0, 2.0, 1.0)).is_gt());
 
     // not comparable
-    assert!(!(Vec3::new(0.0, 3.0, 0.0) < Vec3::new(1.0, 2.0, 1.0)));
-    assert!(!(Vec3::new(0.0, 3.0, 0.0) > Vec3::new(1.0, 2.0, 1.0)));
-    assert!(!(Vec3::new(0.0, 3.0, 0.0) <= Vec3::new(1.0, 2.0, 1.0)));
-    assert!(!(Vec3::new(0.0, 3.0, 0.0) >= Vec3::new(1.0, 2.0, 1.0)));
+    assert!(na::partial_cmp(&Vec3::new(0.0, 3.0, 0.0), &Vec3::new(1.0, 2.0, 1.0)).is_not_comparable());
 }
 
 #[test]
 fn test_min_max_vec3() {
-    assert_eq!(Vec3::new(1, 2, 3).max(&Vec3::new(3, 2, 1)), Vec3::new(3, 2, 3));
-    assert_eq!(Vec3::new(1, 2, 3).min(&Vec3::new(3, 2, 1)), Vec3::new(1, 2, 1));
-    assert_eq!(Vec3::new(0, 2, 4).clamp(&Vec3::new(1, 1, 1), &Vec3::new(3, 3, 3)), Vec3::new(1, 2, 3));
+    assert_eq!(na::sup(&Vec3::new(1, 2, 3), &Vec3::new(3, 2, 1)), Vec3::new(3, 2, 3));
+    assert_eq!(na::inf(&Vec3::new(1, 2, 3), &Vec3::new(3, 2, 1)), Vec3::new(1, 2, 1));
 }
 
 #[test]
diff --git a/src/traits/geometry.rs b/src/traits/geometry.rs
index 91fdf4b3..14b4df58 100644
--- a/src/traits/geometry.rs
+++ b/src/traits/geometry.rs
@@ -153,9 +153,9 @@ pub trait RotationMatrix<LV, AV, M: Mat<LV, LV> + Rotation<AV>> : Rotation<AV> {
 pub trait AbsoluteRotate<V> {
     /// This is the same as:
     ///
-    /// ~~~
+    /// ```.ignore
     ///     self.rotation_matrix().absolute().rmul(v)
-    /// ~~~
+    /// ```
     fn absolute_rotate(&self, v: &V) -> V;
 }
 
@@ -208,9 +208,9 @@ pub trait Dot<N> {
      * computing intermediate vectors.
      * The following equation must be verified:
      *
-     * ~~~
+     * ```.ignore
      *   a.sub_dot(b, c) == (a - b).dot(c)
-     * ~~~
+     * ```
      *
      */
     #[inline]
@@ -218,7 +218,7 @@ pub trait Dot<N> {
 }
 
 /// Traits of objects having an euclidian norm.
-pub trait Norm<N: Real> {
+pub trait Norm<N: Float> {
     /// Computes the norm of `self`.
     #[inline]
     fn norm(v: &Self) -> N {
diff --git a/src/traits/mod.rs b/src/traits/mod.rs
index 6f25caed..f192a654 100644
--- a/src/traits/mod.rs
+++ b/src/traits/mod.rs
@@ -4,11 +4,12 @@ pub use self::geometry::{AbsoluteRotate, Cross, CrossMatrix, Dot, FromHomogeneou
                          Rotation, RotationMatrix, RotationWithTranslation, ToHomogeneous,
                          Transform, Transformation, Translate, Translation, UniformSphereSample};
 
-pub use self::structure::{RealVec, RealVecExt, Basis, Cast, Col, Dim, Indexable,
+pub use self::structure::{FloatVec, FloatVecExt, Basis, Cast, Col, Dim, Indexable,
                           Iterable, IterableMut, Mat, Row, Vec, VecExt};
 
-pub use self::operations::{Absolute, ApproxEq, Cov, Inv, LMul, Mean, Outer, RMul, ScalarAdd,
-                           ScalarSub, Transpose};
+pub use self::operations::{Absolute, ApproxEq, Cov, Inv, LMul, Mean, Outer, PartialOrd, RMul,
+                           ScalarAdd, ScalarSub, Transpose};
+pub use self::operations::{PartialOrdering, Less, Equal, Greater, NotComparable};
 
 pub mod geometry;
 pub mod structure;
diff --git a/src/traits/operations.rs b/src/traits/operations.rs
index 015ff4be..7f090281 100644
--- a/src/traits/operations.rs
+++ b/src/traits/operations.rs
@@ -1,5 +1,129 @@
 //! Low level operations on vectors and matrices.
 
+use std::cmp;
+
+
+/// Result of a partial ordering.
+#[deriving(Eq, Encodable, Decodable, Clone, DeepClone, ToStr, Show)]
+pub enum PartialOrdering {
+    /// Result of a strict comparison.
+    Less,
+    /// Equality relationship.
+    Equal,
+    /// Result of a strict comparison.
+    Greater,
+    /// Result of a comparison between two objects that are not comparable.
+    NotComparable
+}
+
+impl PartialOrdering {
+    /// Returns `true` if `self` is equal to `Equal`.
+    pub fn is_eq(&self) -> bool {
+        *self == Equal
+    }
+
+    /// Returns `true` if `self` is equal to `Less`.
+    pub fn is_lt(&self) -> bool {
+        *self == Less
+    }
+
+    /// Returns `true` if `self` is equal to `Less` or `Equal`.
+    pub fn is_le(&self) -> bool {
+        *self == Less || *self == Equal
+    }
+
+    /// Returns `true` if `self` is equal to `Greater`.
+    pub fn is_gt(&self) -> bool {
+        *self == Greater
+    }
+
+    /// Returns `true` if `self` is equal to `Greater` or `Equal`.
+    pub fn is_ge(&self) -> bool {
+        *self == Greater || *self == Equal
+    }
+
+    /// Returns `true` if `self` is equal to `NotComparable`.
+    pub fn is_not_comparable(&self) -> bool {
+        *self == NotComparable
+    }
+
+    /// Creates a `PartialOrdering` from an `Ordering`.
+    pub fn from_ordering(ord: Ordering) -> PartialOrdering {
+        match ord {
+            cmp::Less    => Less,
+            cmp::Equal   => Equal,
+            cmp::Greater => Greater
+        }
+    }
+
+    /// Converts this `PartialOrdering` to an `Ordering`.
+    ///
+    /// Returns `None` if `self` is `NotComparable`.
+    pub fn to_ordering(self) -> Option<Ordering> {
+        match self {
+            Less          => Some(cmp::Less),
+            Equal         => Some(cmp::Equal),
+            Greater       => Some(cmp::Greater),
+            NotComparable => None
+        }
+    }
+}
+
+/// Pointwise ordering operations.
+pub trait PartialOrd {
+    /// Returns the infimum of `a` and `b`.
+    fn inf(a: &Self, b: &Self) -> Self;
+
+    /// Returns the supremum of `a` and `b`.
+    fn sup(a: &Self, b: &Self) -> Self;
+
+    /// Compare `a` and `b` using a partial ordering relation.
+    fn partial_cmp(a: &Self, b: &Self) -> PartialOrdering;
+
+    /// Return the minimum of `a` and `b` if they are comparable.
+    #[inline]
+    fn partial_min<'a>(a: &'a Self, b: &'a Self) -> Option<&'a Self> {
+        match PartialOrd::partial_cmp(a, b) {
+            Less | Equal  => Some(a),
+            Greater       => Some(b),
+            NotComparable => None
+        }
+    }
+
+    /// Return the maximum of `a` and `b` if they are comparable.
+    #[inline]
+    fn partial_max<'a>(a: &'a Self, b: &'a Self) -> Option<&'a Self> {
+        match PartialOrd::partial_cmp(a, b) {
+            Greater | Equal => Some(a),
+            Less            => Some(b),
+            NotComparable   => None
+        }
+    }
+
+    /// Clamp `value` between `min` and `max`. Returns `None` if `value` is not comparable to
+    /// `min` or `max`.
+    #[inline]
+    fn partial_clamp<'a>(value: &'a Self, min: &'a Self, max: &'a Self) -> Option<&'a Self> {
+        let v_min = PartialOrd::partial_cmp(value, min);
+        let v_max = PartialOrd::partial_cmp(value, max);
+
+        if v_min.is_not_comparable() || v_max.is_not_comparable() {
+            None
+        }
+        else {
+            if v_min.is_lt() {
+                Some(min)
+            }
+            else if v_max.is_gt() {
+                Some(max)
+            }
+            else {
+                Some(value)
+            }
+        }
+    }
+}
+
 /// Trait for testing approximate equality
 pub trait ApproxEq<Eps> {
     /// Default epsilon for approximation.
diff --git a/src/traits/structure.rs b/src/traits/structure.rs
index 7f14c1eb..360e9748 100644
--- a/src/traits/structure.rs
+++ b/src/traits/structure.rs
@@ -27,31 +27,31 @@ pub trait Vec<N>: Dim + Sub<Self, Self> + Add<Self, Self> + Neg<Self> + Zero + E
                   + Div<N, Self> + Dot<N> {
 }
 
-/// Trait of vector with components implementing the `Real` trait.
-pub trait RealVec<N: Real>: Vec<N> + Norm<N> {
+/// Trait of vector with components implementing the `Float` trait.
+pub trait FloatVec<N: Float>: Vec<N> + Norm<N> {
 }
 
 /// Trait grouping uncommon, low-level and borderline (from the mathematical point of view)
 /// operations on vectors.
 pub trait VecExt<N>: Vec<N> + Indexable<uint, N> + Iterable<N> +
-                     UniformSphereSample + ScalarAdd<N> + ScalarSub<N> + Bounded + Orderable
+                     UniformSphereSample + ScalarAdd<N> + ScalarSub<N> + Bounded
 { }
 
 /// Trait grouping uncommon, low-level and borderline (from the mathematical point of view)
 /// operations on vectors.
-pub trait RealVecExt<N: Real>: RealVec<N> + VecExt<N> + Basis + Round { }
+pub trait FloatVecExt<N: Float>: FloatVec<N> + VecExt<N> + Basis + Round { }
 
 impl<N, V: Dim + Sub<V, V> + Add<V, V> + Neg<V> + Zero + Eq + Mul<N, V> + Div<N, V> + Dot<N>>
 Vec<N> for V { }
 
-impl<N: Real, V: Vec<N> + Norm<N>> RealVec<N> for V { }
+impl<N: Float, V: Vec<N> + Norm<N>> FloatVec<N> for V { }
 
 impl<N,
      V: Vec<N> + Indexable<uint, N> + Iterable<N> +
-        UniformSphereSample + ScalarAdd<N> + ScalarSub<N> + Bounded + Orderable>
+        UniformSphereSample + ScalarAdd<N> + ScalarSub<N> + Bounded>
 VecExt<N> for V { }
 
-impl<N: Real, V: RealVec<N> + VecExt<N> + Basis + Round> RealVecExt<N> for V { }
+impl<N: Float, V: FloatVec<N> + VecExt<N> + Basis + Round> FloatVecExt<N> for V { }
 
 // FIXME: return an iterator instead
 /// Traits of objects which can form a basis (typically vectors).