diff --git a/Cargo.toml b/Cargo.toml
index 0c53df562..79d761f3f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name    = "nalgebra"
-version = "0.17.2"
+version = "0.17.3"
 authors = [ "Sébastien Crozet <developer@crozet.re>" ]
 
 description = "Linear algebra library with transformations and statically-sized or dynamically-sized matrices."
@@ -11,6 +11,7 @@ readme = "README.md"
 categories = [ "science" ]
 keywords = [ "linear", "algebra", "matrix", "vector", "math" ]
 license = "BSD-3-Clause"
+edition = "2018"
 
 exclude = ["/ci/*", "/.travis.yml", "/Makefile"]
 
@@ -26,7 +27,7 @@ arbitrary       = [ "quickcheck" ]
 serde-serialize = [ "serde", "serde_derive", "num-complex/serde" ]
 abomonation-serialize = [ "abomonation" ]
 sparse = [ ]
-debug = [ ]
+debug = [ "approx/num-complex", "rand/std" ]
 alloc = [ ]
 io = [ "pest", "pest_derive" ]
 
@@ -53,6 +54,19 @@ alga = { git = "https://github.com/rustsim/alga", branch = "dev" }
 [dev-dependencies]
 serde_json = "1.0"
 rand_xorshift = "0.1"
+### Uncomment this line before running benchmarks.
+### We can't just let this uncommented because that would breack
+### compilation for #[no-std] because of the terrible Cargo bug
+### https://github.com/rust-lang/cargo/issues/4866
+#criterion = "0.2.10"
 
 [workspace]
 members = [ "nalgebra-lapack", "nalgebra-glm" ]
+
+[[bench]]
+name = "nalgebra_bench"
+harness = false
+path = "benches/lib.rs"
+
+[profile.bench]
+lto = true
diff --git a/benches/common/macros.rs b/benches/common/macros.rs
index 758336a82..43bcf59d7 100644
--- a/benches/common/macros.rs
+++ b/benches/common/macros.rs
@@ -2,56 +2,52 @@
 
 macro_rules! bench_binop(
     ($name: ident, $t1: ty, $t2: ty, $binop: ident) => {
-        #[bench]
-        fn $name(bh: &mut Bencher) {
+        fn $name(bh: &mut criterion::Criterion) {
             use rand::SeedableRng;
             let mut rng = IsaacRng::seed_from_u64(0);
             let a = rng.gen::<$t1>();
             let b = rng.gen::<$t2>();
 
-            bh.iter(|| {
+            bh.bench_function(stringify!($name), move |bh| bh.iter(|| {
                 a.$binop(b)
-            })
+            }));
         }
     }
 );
 
 macro_rules! bench_binop_ref(
     ($name: ident, $t1: ty, $t2: ty, $binop: ident) => {
-        #[bench]
-        fn $name(bh: &mut Bencher) {
+        fn $name(bh: &mut criterion::Criterion) {
             use rand::SeedableRng;
             let mut rng = IsaacRng::seed_from_u64(0);
             let a = rng.gen::<$t1>();
             let b = rng.gen::<$t2>();
 
-            bh.iter(|| {
+            bh.bench_function(stringify!($name), move |bh| bh.iter(|| {
                 a.$binop(&b)
-            })
+            }));
         }
     }
 );
 
 macro_rules! bench_binop_fn(
     ($name: ident, $t1: ty, $t2: ty, $binop: path) => {
-        #[bench]
-        fn $name(bh: &mut Bencher) {
+        fn $name(bh: &mut criterion::Criterion) {
             use rand::SeedableRng;
             let mut rng = IsaacRng::seed_from_u64(0);
             let a = rng.gen::<$t1>();
             let b = rng.gen::<$t2>();
 
-            bh.iter(|| {
+            bh.bench_function(stringify!($name), move |bh| bh.iter(|| {
                 $binop(&a, &b)
-            })
+            }));
         }
     }
 );
 
 macro_rules! bench_unop_na(
     ($name: ident, $t: ty, $unop: ident) => {
-        #[bench]
-        fn $name(bh: &mut Bencher) {
+        fn $name(bh: &mut criterion::Criterion) {
             const LEN: usize = 1 << 13;
 
             use rand::SeedableRng;
@@ -60,21 +56,20 @@ macro_rules! bench_unop_na(
             let elems: Vec<$t> =  (0usize .. LEN).map(|_| rng.gen::<$t>()).collect();
             let mut i = 0;
 
-            bh.iter(|| {
+            bh.bench_function(stringify!($name), move |bh| bh.iter(|| {
                 i = (i + 1) & (LEN - 1);
 
                 unsafe {
                     test::black_box(na::$unop(elems.get_unchecked(i)))
                 }
-            })
+            }));
         }
     }
 );
 
 macro_rules! bench_unop(
     ($name: ident, $t: ty, $unop: ident) => {
-        #[bench]
-        fn $name(bh: &mut Bencher) {
+        fn $name(bh: &mut criterion::Criterion) {
             const LEN: usize = 1 << 13;
 
             use rand::SeedableRng;
@@ -83,21 +78,20 @@ macro_rules! bench_unop(
             let mut elems: Vec<$t> =  (0usize .. LEN).map(|_| rng.gen::<$t>()).collect();
             let mut i = 0;
 
-            bh.iter(|| {
+            bh.bench_function(stringify!($name), move |bh| bh.iter(|| {
                 i = (i + 1) & (LEN - 1);
 
                 unsafe {
                     test::black_box(elems.get_unchecked_mut(i).$unop())
                 }
-            })
+            }));
         }
     }
 );
 
 macro_rules! bench_construction(
     ($name: ident, $constructor: path, $( $args: ident: $types: ty),*) => {
-        #[bench]
-        fn $name(bh: &mut Bencher) {
+        fn $name(bh: &mut criterion::Criterion) {
             const LEN: usize = 1 << 13;
 
             use rand::SeedableRng;
@@ -106,14 +100,14 @@ macro_rules! bench_construction(
             $(let $args: Vec<$types> = (0usize .. LEN).map(|_| rng.gen::<$types>()).collect();)*
             let mut i = 0;
 
-            bh.iter(|| {
+            bh.bench_function(stringify!($name), move |bh| bh.iter(|| {
                 i = (i + 1) & (LEN - 1);
 
                 unsafe {
                     let res = $constructor($(*$args.get_unchecked(i),)*);
                     test::black_box(res)
                 }
-            })
+            }));
         }
     }
 );
diff --git a/benches/core/matrix.rs b/benches/core/matrix.rs
index c323cd6ec..12fb836d3 100644
--- a/benches/core/matrix.rs
+++ b/benches/core/matrix.rs
@@ -1,7 +1,6 @@
 use na::{DMatrix, DVector, Matrix2, Matrix3, Matrix4, MatrixN, Vector2, Vector3, Vector4, U10};
 use rand::{IsaacRng, Rng};
 use std::ops::{Add, Div, Mul, Sub};
-use test::{self, Bencher};
 
 #[path = "../common/macros.rs"]
 mod macros;
@@ -46,153 +45,196 @@ bench_unop!(mat2_transpose, Matrix2<f32>, transpose);
 bench_unop!(mat3_transpose, Matrix3<f32>, transpose);
 bench_unop!(mat4_transpose, Matrix4<f32>, transpose);
 
-#[bench]
-fn mat_div_scalar(b: &mut Bencher) {
+fn mat_div_scalar(b: &mut criterion::Criterion) {
     let a = DMatrix::from_row_slice(1000, 1000, &vec![2.0; 1000000]);
     let n = 42.0;
 
-    b.iter(|| {
+    b.bench_function("mat_div_scalar", move |bh| bh.iter(|| {
         let mut aa = a.clone();
         let mut b = aa.slice_mut((0, 0), (1000, 1000));
         b /= n
-    })
+    }));
 }
 
-#[bench]
-fn mat100_add_mat100(bench: &mut Bencher) {
+fn mat100_add_mat100(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(100, 100);
     let b = DMatrix::<f64>::new_random(100, 100);
 
-    bench.iter(|| &a + &b)
+    bench.bench_function("mat100_add_mat100", move |bh| bh.iter(|| &a + &b));
 }
 
-#[bench]
-fn mat4_mul_mat4(bench: &mut Bencher) {
+fn mat4_mul_mat4(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(4, 4);
     let b = DMatrix::<f64>::new_random(4, 4);
 
-    bench.iter(|| &a * &b)
+    bench.bench_function("mat4_mul_mat4", move |bh| bh.iter(|| &a * &b));
 }
 
-#[bench]
-fn mat5_mul_mat5(bench: &mut Bencher) {
+fn mat5_mul_mat5(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(5, 5);
     let b = DMatrix::<f64>::new_random(5, 5);
 
-    bench.iter(|| &a * &b)
+    bench.bench_function("mat5_mul_mat5", move |bh| bh.iter(|| &a * &b));
 }
 
-#[bench]
-fn mat6_mul_mat6(bench: &mut Bencher) {
+fn mat6_mul_mat6(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(6, 6);
     let b = DMatrix::<f64>::new_random(6, 6);
 
-    bench.iter(|| &a * &b)
+    bench.bench_function("mat6_mul_mat6", move |bh| bh.iter(|| &a * &b));
 }
 
-#[bench]
-fn mat7_mul_mat7(bench: &mut Bencher) {
+fn mat7_mul_mat7(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(7, 7);
     let b = DMatrix::<f64>::new_random(7, 7);
 
-    bench.iter(|| &a * &b)
+    bench.bench_function("mat7_mul_mat7", move |bh| bh.iter(|| &a * &b));
 }
 
-#[bench]
-fn mat8_mul_mat8(bench: &mut Bencher) {
+fn mat8_mul_mat8(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(8, 8);
     let b = DMatrix::<f64>::new_random(8, 8);
 
-    bench.iter(|| &a * &b)
+    bench.bench_function("mat8_mul_mat8", move |bh| bh.iter(|| &a * &b));
 }
 
-#[bench]
-fn mat9_mul_mat9(bench: &mut Bencher) {
+fn mat9_mul_mat9(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(9, 9);
     let b = DMatrix::<f64>::new_random(9, 9);
 
-    bench.iter(|| &a * &b)
+    bench.bench_function("mat9_mul_mat9", move |bh| bh.iter(|| &a * &b));
 }
 
-#[bench]
-fn mat10_mul_mat10(bench: &mut Bencher) {
+fn mat10_mul_mat10(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(10, 10);
     let b = DMatrix::<f64>::new_random(10, 10);
 
-    bench.iter(|| &a * &b)
+    bench.bench_function("mat10_mul_mat10", move |bh| bh.iter(|| &a * &b));
 }
 
-#[bench]
-fn mat10_mul_mat10_static(bench: &mut Bencher) {
+fn mat10_mul_mat10_static(bench: &mut criterion::Criterion) {
     let a = MatrixN::<f64, U10>::new_random();
     let b = MatrixN::<f64, U10>::new_random();
 
-    bench.iter(|| &a * &b)
+    bench.bench_function("mat10_mul_mat10_static", move |bh| bh.iter(|| &a * &b));
 }
 
-#[bench]
-fn mat100_mul_mat100(bench: &mut Bencher) {
+fn mat100_mul_mat100(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(100, 100);
     let b = DMatrix::<f64>::new_random(100, 100);
 
-    bench.iter(|| &a * &b)
+    bench.bench_function("mat100_mul_mat100", move |bh| bh.iter(|| &a * &b));
 }
 
-#[bench]
-fn mat500_mul_mat500(bench: &mut Bencher) {
+fn mat500_mul_mat500(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::from_element(500, 500, 5f64);
     let b = DMatrix::<f64>::from_element(500, 500, 6f64);
 
-    bench.iter(|| &a * &b)
+    bench.bench_function("mat500_mul_mat500", move |bh| bh.iter(|| &a * &b));
 }
 
-#[bench]
-fn copy_from(bench: &mut Bencher) {
+fn copy_from(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(1000, 1000);
     let mut b = DMatrix::<f64>::new_random(1000, 1000);
 
-    bench.iter(|| {
-        b.copy_from(&a);
-    })
+    bench.bench_function("copy_from", move |bh| bh.iter(|| {
+          b.copy_from(&a);
+    }));
 }
 
-#[bench]
-fn axpy(bench: &mut Bencher) {
+fn axpy(bench: &mut criterion::Criterion) {
     let x = DVector::<f64>::from_element(100000, 2.0);
     let mut y = DVector::<f64>::from_element(100000, 3.0);
     let a = 42.0;
 
-    bench.iter(|| {
-        y.axpy(a, &x, 1.0);
-    })
+    bench.bench_function("axpy", move |bh| bh.iter(|| {
+          y.axpy(a, &x, 1.0);
+    }));
 }
 
-#[bench]
-fn tr_mul_to(bench: &mut Bencher) {
+fn tr_mul_to(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(1000, 1000);
     let b = DVector::<f64>::new_random(1000);
     let mut c = DVector::from_element(1000, 0.0);
 
-    bench.iter(|| a.tr_mul_to(&b, &mut c))
+    bench.bench_function("", move |bh| bh.iter(|| a.tr_mul_to(&b, &mut c)));
 }
 
-#[bench]
-fn mat_mul_mat(bench: &mut Bencher) {
+fn mat_mul_mat(bench: &mut criterion::Criterion) {
     let a = DMatrix::<f64>::new_random(100, 100);
     let b = DMatrix::<f64>::new_random(100, 100);
     let mut ab = DMatrix::<f64>::from_element(100, 100, 0.0);
 
-    bench.iter(|| {
-        test::black_box(a.mul_to(&b, &mut ab));
-    })
-}
-
-#[bench]
-fn mat100_from_fn(bench: &mut Bencher) {
-    bench.iter(|| DMatrix::from_fn(100, 100, |a, b| a + b))
-}
-
-#[bench]
-fn mat500_from_fn(bench: &mut Bencher) {
-    bench.iter(|| DMatrix::from_fn(500, 500, |a, b| a + b))
-}
+    bench.bench_function("mat_mul_mat", move |bh| bh.iter(|| {
+          test::black_box(a.mul_to(&b, &mut ab));
+    }));
+}
+
+fn mat100_from_fn(bench: &mut criterion::Criterion) {
+    bench.bench_function("mat100_from_fn", move |bh| bh.iter(|| DMatrix::from_fn(100, 100, |a, b| a + b)));
+}
+
+fn mat500_from_fn(bench: &mut criterion::Criterion) {
+    bench.bench_function("mat500_from_fn", move |bh| bh.iter(|| DMatrix::from_fn(500, 500, |a, b| a + b)));
+}
+
+criterion_group!(matrix,
+    mat2_mul_m,
+    mat3_mul_m,
+    mat4_mul_m,
+
+    mat2_tr_mul_m,
+    mat3_tr_mul_m,
+    mat4_tr_mul_m,
+
+    mat2_add_m,
+    mat3_add_m,
+    mat4_add_m,
+
+    mat2_sub_m,
+    mat3_sub_m,
+    mat4_sub_m,
+
+    mat2_mul_v,
+    mat3_mul_v,
+    mat4_mul_v,
+
+    mat2_tr_mul_v,
+    mat3_tr_mul_v,
+    mat4_tr_mul_v,
+
+    mat2_mul_s,
+    mat3_mul_s,
+    mat4_mul_s,
+
+    mat2_div_s,
+    mat3_div_s,
+    mat4_div_s,
+
+    mat2_inv,
+    mat3_inv,
+    mat4_inv,
+
+    mat2_transpose,
+    mat3_transpose,
+    mat4_transpose,
+
+    mat_div_scalar,
+    mat100_add_mat100,
+    mat4_mul_mat4,
+    mat5_mul_mat5,
+    mat6_mul_mat6,
+    mat7_mul_mat7,
+    mat8_mul_mat8,
+    mat9_mul_mat9,
+    mat10_mul_mat10,
+    mat10_mul_mat10_static,
+    mat100_mul_mat100,
+    mat500_mul_mat500,
+    copy_from,
+    axpy,
+    tr_mul_to,
+    mat_mul_mat,
+    mat100_from_fn,
+    mat500_from_fn,
+);
\ No newline at end of file
diff --git a/benches/core/mod.rs b/benches/core/mod.rs
index 9699a728b..eda9ddaac 100644
--- a/benches/core/mod.rs
+++ b/benches/core/mod.rs
@@ -1,2 +1,5 @@
+pub use self::matrix::matrix;
+pub use self::vector::vector;
+
 mod matrix;
 mod vector;
diff --git a/benches/core/vector.rs b/benches/core/vector.rs
index 837eb7ca4..7d3237e8a 100644
--- a/benches/core/vector.rs
+++ b/benches/core/vector.rs
@@ -1,7 +1,6 @@
 use na::{DVector, Vector2, Vector3, Vector4, VectorN};
 use rand::{IsaacRng, Rng};
 use std::ops::{Add, Div, Mul, Sub};
-use test::{self, Bencher};
 use typenum::U10000;
 
 #[path = "../common/macros.rs"]
@@ -48,19 +47,17 @@ bench_unop!(vec4_normalize, Vector4<f32>, normalize);
 bench_binop_ref!(vec10000_dot_f64, VectorN<f64, U10000>, VectorN<f64, U10000>, dot);
 bench_binop_ref!(vec10000_dot_f32, VectorN<f32, U10000>, VectorN<f32, U10000>, dot);
 
-#[bench]
-fn vec10000_axpy_f64(bh: &mut Bencher) {
+fn vec10000_axpy_f64(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
     let mut rng = IsaacRng::seed_from_u64(0);
     let mut a = DVector::new_random(10000);
     let b = DVector::new_random(10000);
     let n = rng.gen::<f64>();
 
-    bh.iter(|| a.axpy(n, &b, 1.0))
+    bh.bench_function("vec10000_axpy_f64", move |bh| bh.iter(|| a.axpy(n, &b, 1.0)));
 }
 
-#[bench]
-fn vec10000_axpy_beta_f64(bh: &mut Bencher) {
+fn vec10000_axpy_beta_f64(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
     let mut rng = IsaacRng::seed_from_u64(0);
     let mut a = DVector::new_random(10000);
@@ -68,27 +65,25 @@ fn vec10000_axpy_beta_f64(bh: &mut Bencher) {
     let n = rng.gen::<f64>();
     let beta = rng.gen::<f64>();
 
-    bh.iter(|| a.axpy(n, &b, beta))
+    bh.bench_function("vec10000_axpy_beta_f64", move |bh| bh.iter(|| a.axpy(n, &b, beta)));
 }
 
-#[bench]
-fn vec10000_axpy_f64_slice(bh: &mut Bencher) {
+fn vec10000_axpy_f64_slice(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
     let mut rng = IsaacRng::seed_from_u64(0);
     let mut a = DVector::new_random(10000);
     let b = DVector::new_random(10000);
     let n = rng.gen::<f64>();
 
-    bh.iter(|| {
+    bh.bench_function("vec10000_axpy_f64_slice", move |bh| bh.iter(|| {
         let mut a = a.fixed_rows_mut::<U10000>(0);
         let b = b.fixed_rows::<U10000>(0);
 
         a.axpy(n, &b, 1.0)
-    })
+    }));
 }
 
-#[bench]
-fn vec10000_axpy_f64_static(bh: &mut Bencher) {
+fn vec10000_axpy_f64_static(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
     let mut rng = IsaacRng::seed_from_u64(0);
     let mut a = VectorN::<f64, U10000>::new_random();
@@ -96,22 +91,20 @@ fn vec10000_axpy_f64_static(bh: &mut Bencher) {
     let n = rng.gen::<f64>();
 
     // NOTE: for some reasons, it is much faster if the arument are boxed (Box::new(VectorN...)).
-    bh.iter(|| a.axpy(n, &b, 1.0))
+    bh.bench_function("vec10000_axpy_f64_static", move |bh| bh.iter(|| a.axpy(n, &b, 1.0)));
 }
 
-#[bench]
-fn vec10000_axpy_f32(bh: &mut Bencher) {
+fn vec10000_axpy_f32(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
     let mut rng = IsaacRng::seed_from_u64(0);
     let mut a = DVector::new_random(10000);
     let b = DVector::new_random(10000);
     let n = rng.gen::<f32>();
 
-    bh.iter(|| a.axpy(n, &b, 1.0))
+    bh.bench_function("vec10000_axpy_f32", move |bh| bh.iter(|| a.axpy(n, &b, 1.0)));
 }
 
-#[bench]
-fn vec10000_axpy_beta_f32(bh: &mut Bencher) {
+fn vec10000_axpy_beta_f32(bh: &mut criterion::Criterion) {
     use rand::SeedableRng;
     let mut rng = IsaacRng::seed_from_u64(0);
     let mut a = DVector::new_random(10000);
@@ -119,5 +112,55 @@ fn vec10000_axpy_beta_f32(bh: &mut Bencher) {
     let n = rng.gen::<f32>();
     let beta = rng.gen::<f32>();
 
-    bh.iter(|| a.axpy(n, &b, beta))
+    bh.bench_function("vec10000_axpy_beta_f32", move |bh| bh.iter(|| a.axpy(n, &b, beta)));
 }
+
+criterion_group!(vector,
+    vec2_add_v_f32,
+    vec3_add_v_f32,
+    vec4_add_v_f32,
+
+    vec2_add_v_f64,
+    vec3_add_v_f64,
+    vec4_add_v_f64,
+
+    vec2_sub_v,
+    vec3_sub_v,
+    vec4_sub_v,
+
+    vec2_mul_s,
+    vec3_mul_s,
+    vec4_mul_s,
+
+    vec2_div_s,
+    vec3_div_s,
+    vec4_div_s,
+
+    vec2_dot_f32,
+    vec3_dot_f32,
+    vec4_dot_f32,
+
+    vec2_dot_f64,
+    vec3_dot_f64,
+    vec4_dot_f64,
+
+    vec3_cross,
+
+    vec2_norm,
+    vec3_norm,
+    vec4_norm,
+
+    vec2_normalize,
+    vec3_normalize,
+    vec4_normalize,
+
+    vec10000_dot_f64,
+    vec10000_dot_f32,
+
+    vec10000_axpy_f64,
+    vec10000_axpy_beta_f64,
+    vec10000_axpy_f64_slice,
+    vec10000_axpy_f64_static,
+    vec10000_axpy_f32,
+    vec10000_axpy_beta_f32
+);
diff --git a/benches/geometry/mod.rs b/benches/geometry/mod.rs
index 0f9eb3711..cb23cbf9d 100644
--- a/benches/geometry/mod.rs
+++ b/benches/geometry/mod.rs
@@ -1 +1,3 @@
+pub use self::quaternion::quaternion;
+
 mod quaternion;
diff --git a/benches/geometry/quaternion.rs b/benches/geometry/quaternion.rs
index bc94c054e..dd079aacd 100644
--- a/benches/geometry/quaternion.rs
+++ b/benches/geometry/quaternion.rs
@@ -1,7 +1,6 @@
 use na::{Quaternion, UnitQuaternion, Vector3};
 use rand::{IsaacRng, Rng};
 use std::ops::{Add, Div, Mul, Sub};
-use test::{self, Bencher};
 
 #[path = "../common/macros.rs"]
 mod macros;
@@ -25,3 +24,14 @@ bench_unop!(unit_quaternion_inv, UnitQuaternion<f32>, inverse);
 
 // bench_unop_self!(quaternion_conjugate, Quaternion<f32>, conjugate);
 // bench_unop!(quaternion_normalize, Quaternion<f32>, normalize);
+
+criterion_group!(quaternion,
+    quaternion_add_q,
+    quaternion_sub_q,
+    quaternion_mul_q,
+    unit_quaternion_mul_v,
+    quaternion_mul_s,
+    quaternion_div_s,
+    quaternion_inv,
+    unit_quaternion_inv
+);
\ No newline at end of file
diff --git a/benches/lib.rs b/benches/lib.rs
index f788c9988..d5333542d 100644
--- a/benches/lib.rs
+++ b/benches/lib.rs
@@ -6,15 +6,34 @@ extern crate rand;
 extern crate test;
 extern crate typenum;
 
+#[macro_use]
+extern crate criterion;
+
 use na::DMatrix;
 use rand::{IsaacRng, Rng};
 
-mod core;
-mod geometry;
-mod linalg;
+pub mod core;
+pub mod geometry;
+pub mod linalg;
 
 fn reproductible_dmatrix(nrows: usize, ncols: usize) -> DMatrix<f64> {
     use rand::SeedableRng;
     let mut rng = IsaacRng::seed_from_u64(0);
     DMatrix::<f64>::from_fn(nrows, ncols, |_, _| rng.gen())
 }
+
+criterion_main!(
+    core::matrix,
+    core::vector,
+    geometry::quaternion,
+    linalg::bidiagonal,
+    linalg::cholesky,
+    linalg::full_piv_lu,
+    linalg::hessenberg,
+    linalg::lu,
+    linalg::qr,
+    linalg::schur,
+    linalg::solve,
+    linalg::svd,
+    linalg::symmetric_eigen,
+);
\ No newline at end of file
diff --git a/benches/linalg/bidiagonal.rs b/benches/linalg/bidiagonal.rs
index 9e5a723ef..ed126205c 100644
--- a/benches/linalg/bidiagonal.rs
+++ b/benches/linalg/bidiagonal.rs
@@ -1,73 +1,75 @@
 use na::{Bidiagonal, DMatrix, Matrix4};
-use test::{self, Bencher};
 
 #[path = "../common/macros.rs"]
 mod macros;
 
 // Without unpack.
-#[bench]
-fn bidiagonalize_100x100(bh: &mut Bencher) {
+fn bidiagonalize_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
-    bh.iter(|| test::black_box(Bidiagonal::new(m.clone())))
+    bh.bench_function("bidiagonalize_100x100", move |bh| bh.iter(|| test::black_box(Bidiagonal::new(m.clone()))));
 }
 
-#[bench]
-fn bidiagonalize_100x500(bh: &mut Bencher) {
+fn bidiagonalize_100x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 500);
-    bh.iter(|| test::black_box(Bidiagonal::new(m.clone())))
+    bh.bench_function("bidiagonalize_100x500", move |bh| bh.iter(|| test::black_box(Bidiagonal::new(m.clone()))));
 }
 
-#[bench]
-fn bidiagonalize_4x4(bh: &mut Bencher) {
+fn bidiagonalize_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(Bidiagonal::new(m.clone())))
+    bh.bench_function("bidiagonalize_4x4", move |bh| bh.iter(|| test::black_box(Bidiagonal::new(m.clone()))));
 }
 
-#[bench]
-fn bidiagonalize_500x100(bh: &mut Bencher) {
+fn bidiagonalize_500x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 100);
-    bh.iter(|| test::black_box(Bidiagonal::new(m.clone())))
+    bh.bench_function("bidiagonalize_500x100", move |bh| bh.iter(|| test::black_box(Bidiagonal::new(m.clone()))));
 }
 
-#[bench]
-fn bidiagonalize_500x500(bh: &mut Bencher) {
+fn bidiagonalize_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
-    bh.iter(|| test::black_box(Bidiagonal::new(m.clone())))
+    bh.bench_function("bidiagonalize_500x500", move |bh| bh.iter(|| test::black_box(Bidiagonal::new(m.clone()))));
 }
 
 // With unpack.
-#[bench]
-fn bidiagonalize_unpack_100x100(bh: &mut Bencher) {
+fn bidiagonalize_unpack_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
-    bh.iter(|| {
+    bh.bench_function("bidiagonalize_unpack_100x100", move |bh| bh.iter(|| {
         let bidiag = Bidiagonal::new(m.clone());
         let _ = bidiag.unpack();
-    })
+    }));
 }
 
-#[bench]
-fn bidiagonalize_unpack_100x500(bh: &mut Bencher) {
+fn bidiagonalize_unpack_100x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 500);
-    bh.iter(|| {
+    bh.bench_function("bidiagonalize_unpack_100x500", move |bh| bh.iter(|| {
         let bidiag = Bidiagonal::new(m.clone());
         let _ = bidiag.unpack();
-    })
+    }));
 }
 
-#[bench]
-fn bidiagonalize_unpack_500x100(bh: &mut Bencher) {
+fn bidiagonalize_unpack_500x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 100);
-    bh.iter(|| {
+    bh.bench_function("bidiagonalize_unpack_500x100", move |bh| bh.iter(|| {
         let bidiag = Bidiagonal::new(m.clone());
         let _ = bidiag.unpack();
-    })
+    }));
 }
 
-#[bench]
-fn bidiagonalize_unpack_500x500(bh: &mut Bencher) {
+fn bidiagonalize_unpack_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
-    bh.iter(|| {
+    bh.bench_function("bidiagonalize_unpack_500x500", move |bh| bh.iter(|| {
         let bidiag = Bidiagonal::new(m.clone());
         let _ = bidiag.unpack();
-    })
+    }));
 }
+
+criterion_group!(bidiagonal,
+    bidiagonalize_100x100,
+    bidiagonalize_100x500,
+    bidiagonalize_4x4,
+    bidiagonalize_500x100,
+//    bidiagonalize_500x500, // too long
+    bidiagonalize_unpack_100x100,
+    bidiagonalize_unpack_100x500,
+    bidiagonalize_unpack_500x100,
+//    bidiagonalize_unpack_500x500 // too long
+);
\ No newline at end of file
diff --git a/benches/linalg/cholesky.rs b/benches/linalg/cholesky.rs
index 73c028cb5..40ca98211 100644
--- a/benches/linalg/cholesky.rs
+++ b/benches/linalg/cholesky.rs
@@ -1,109 +1,112 @@
 use na::{Cholesky, DMatrix, DVector};
-use test::{self, Bencher};
 
-#[bench]
-fn cholesky_100x100(bh: &mut Bencher) {
+fn cholesky_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let m = &m * m.transpose();
 
-    bh.iter(|| test::black_box(Cholesky::new(m.clone())))
+    bh.bench_function("cholesky_100x100", move |bh| bh.iter(|| test::black_box(Cholesky::new(m.clone()))));
 }
 
-#[bench]
-fn cholesky_500x500(bh: &mut Bencher) {
+fn cholesky_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let m = &m * m.transpose();
 
-    bh.iter(|| test::black_box(Cholesky::new(m.clone())))
+    bh.bench_function("cholesky_500x500", move |bh| bh.iter(|| test::black_box(Cholesky::new(m.clone()))));
 }
 
 // With unpack.
-#[bench]
-fn cholesky_decompose_unpack_100x100(bh: &mut Bencher) {
+fn cholesky_decompose_unpack_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let m = &m * m.transpose();
 
-    bh.iter(|| {
+    bh.bench_function("cholesky_decompose_unpack_100x100", move |bh| bh.iter(|| {
         let chol = Cholesky::new(m.clone()).unwrap();
         let _ = chol.unpack();
-    })
+    }));
 }
-#[bench]
-fn cholesky_decompose_unpack_500x500(bh: &mut Bencher) {
+fn cholesky_decompose_unpack_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let m = &m * m.transpose();
 
-    bh.iter(|| {
+    bh.bench_function("cholesky_decompose_unpack_500x500", move |bh| bh.iter(|| {
         let chol = Cholesky::new(m.clone()).unwrap();
         let _ = chol.unpack();
-    })
+    }));
 }
 
-#[bench]
-fn cholesky_solve_10x10(bh: &mut Bencher) {
+fn cholesky_solve_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     let m = &m * m.transpose();
     let v = DVector::<f64>::new_random(10);
     let chol = Cholesky::new(m.clone()).unwrap();
 
-    bh.iter(|| {
+    bh.bench_function("cholesky_solve_10x10", move |bh| bh.iter(|| {
         let _ = chol.solve(&v);
-    })
+    }));
 }
 
-#[bench]
-fn cholesky_solve_100x100(bh: &mut Bencher) {
+fn cholesky_solve_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let m = &m * m.transpose();
     let v = DVector::<f64>::new_random(100);
     let chol = Cholesky::new(m.clone()).unwrap();
 
-    bh.iter(|| {
+    bh.bench_function("cholesky_solve_100x100", move |bh| bh.iter(|| {
         let _ = chol.solve(&v);
-    })
+    }));
 }
 
-#[bench]
-fn cholesky_solve_500x500(bh: &mut Bencher) {
+fn cholesky_solve_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let m = &m * m.transpose();
     let v = DVector::<f64>::new_random(500);
     let chol = Cholesky::new(m.clone()).unwrap();
 
-    bh.iter(|| {
+    bh.bench_function("cholesky_solve_500x500", move |bh| bh.iter(|| {
         let _ = chol.solve(&v);
-    })
+    }));
 }
 
-#[bench]
-fn cholesky_inverse_10x10(bh: &mut Bencher) {
+
+fn cholesky_inverse_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     let m = &m * m.transpose();
     let chol = Cholesky::new(m.clone()).unwrap();
 
-    bh.iter(|| {
+    bh.bench_function("cholesky_inverse_10x10", move |bh| bh.iter(|| {
         let _ = chol.inverse();
-    })
+    }));
 }
 
-#[bench]
-fn cholesky_inverse_100x100(bh: &mut Bencher) {
+fn cholesky_inverse_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let m = &m * m.transpose();
     let chol = Cholesky::new(m.clone()).unwrap();
 
-    bh.iter(|| {
+    bh.bench_function("cholesky_inverse_100x100", move |bh| bh.iter(|| {
         let _ = chol.inverse();
-    })
+    }));
 }
 
-#[bench]
-fn cholesky_inverse_500x500(bh: &mut Bencher) {
+fn cholesky_inverse_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let m = &m * m.transpose();
     let chol = Cholesky::new(m.clone()).unwrap();
 
-    bh.iter(|| {
+    bh.bench_function("cholesky_inverse_500x500", move |bh| bh.iter(|| {
         let _ = chol.inverse();
-    })
+    }));
 }
+
+criterion_group!(cholesky,
+    cholesky_100x100,
+    cholesky_500x500,
+    cholesky_decompose_unpack_100x100,
+    cholesky_decompose_unpack_500x500,
+    cholesky_solve_10x10,
+    cholesky_solve_100x100,
+    cholesky_solve_500x500,
+    cholesky_inverse_10x10,
+    cholesky_inverse_100x100,
+    cholesky_inverse_500x500
+);
\ No newline at end of file
diff --git a/benches/linalg/eigen.rs b/benches/linalg/eigen.rs
index 54aa77a50..0b1e6b266 100644
--- a/benches/linalg/eigen.rs
+++ b/benches/linalg/eigen.rs
@@ -1,30 +1,33 @@
 use test::Bencher;
 use na::{DMatrix, Eigen};
 
-#[bench]
-fn eigen_100x100(bh: &mut Bencher) {
+fn eigen_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
 
-    bh.iter(|| Eigen::new(m.clone(), 1.0e-7, 0))
+    bh.bench_function("eigen_100x100", move |bh| bh.iter(|| Eigen::new(m.clone(), 1.0e-7, 0)));
 }
 
-#[bench]
-fn eigen_500x500(bh: &mut Bencher) {
+fn eigen_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
 
-    bh.iter(|| Eigen::new(m.clone(), 1.0e-7, 0))
+    bh.bench_function("eigen_500x500", move |bh| bh.iter(|| Eigen::new(m.clone(), 1.0e-7, 0)));
 }
 
-#[bench]
-fn eigenvalues_100x100(bh: &mut Bencher) {
+fn eigenvalues_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
 
-    bh.iter(|| m.clone().eigenvalues(1.0e-7, 0))
+    bh.bench_function("eigenvalues_100x100", move |bh| bh.iter(|| m.clone().eigenvalues(1.0e-7, 0)));
 }
 
-#[bench]
-fn eigenvalues_500x500(bh: &mut Bencher) {
+fn eigenvalues_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
 
-    bh.iter(|| m.clone().eigenvalues(1.0e-7, 0))
+    bh.bench_function("eigenvalues_500x500", move |bh| bh.iter(|| m.clone().eigenvalues(1.0e-7, 0)));
 }
+
+criterion_group!(eigen,
+    eigen_100x100,
+//    eigen_500x500,
+    eigenvalues_100x100,
+//    eigenvalues_500x500
+);
diff --git a/benches/linalg/full_piv_lu.rs b/benches/linalg/full_piv_lu.rs
index ad82b069e..6c7b1fa6f 100644
--- a/benches/linalg/full_piv_lu.rs
+++ b/benches/linalg/full_piv_lu.rs
@@ -1,102 +1,105 @@
 use na::{DMatrix, DVector, FullPivLU};
-use test::{self, Bencher};
 
 // Without unpack.
-#[bench]
-fn full_piv_lu_decompose_10x10(bh: &mut Bencher) {
+fn full_piv_lu_decompose_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
-    bh.iter(|| test::black_box(FullPivLU::new(m.clone())))
+    bh.bench_function("full_piv_lu_decompose_10x10", move |bh| bh.iter(|| test::black_box(FullPivLU::new(m.clone()))));
 }
 
-#[bench]
-fn full_piv_lu_decompose_100x100(bh: &mut Bencher) {
+fn full_piv_lu_decompose_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
-    bh.iter(|| test::black_box(FullPivLU::new(m.clone())))
+    bh.bench_function("full_piv_lu_decompose_100x100", move |bh| bh.iter(|| test::black_box(FullPivLU::new(m.clone()))));
 }
 
-#[bench]
-fn full_piv_lu_decompose_500x500(bh: &mut Bencher) {
+fn full_piv_lu_decompose_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
-    bh.iter(|| test::black_box(FullPivLU::new(m.clone())))
+    bh.bench_function("full_piv_lu_decompose_500x500", move |bh| bh.iter(|| test::black_box(FullPivLU::new(m.clone()))));
 }
 
-#[bench]
-fn full_piv_lu_solve_10x10(bh: &mut Bencher) {
+fn full_piv_lu_solve_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     let lu = FullPivLU::new(m.clone());
 
-    bh.iter(|| {
+    bh.bench_function("full_piv_lu_solve_10x10", move |bh| bh.iter(|| {
         let mut b = DVector::<f64>::from_element(10, 1.0);
         lu.solve(&mut b);
-    })
+    }));
 }
 
-#[bench]
-fn full_piv_lu_solve_100x100(bh: &mut Bencher) {
+fn full_piv_lu_solve_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let lu = FullPivLU::new(m.clone());
 
-    bh.iter(|| {
+    bh.bench_function("full_piv_lu_solve_100x100", move |bh| bh.iter(|| {
         let mut b = DVector::<f64>::from_element(100, 1.0);
         lu.solve(&mut b);
-    })
+    }));
 }
 
-#[bench]
-fn full_piv_lu_solve_500x500(bh: &mut Bencher) {
+fn full_piv_lu_solve_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let lu = FullPivLU::new(m.clone());
 
-    bh.iter(|| {
+    bh.bench_function("full_piv_lu_solve_500x500", move |bh| bh.iter(|| {
         let mut b = DVector::<f64>::from_element(500, 1.0);
         lu.solve(&mut b);
-    })
+    }));
 }
 
-#[bench]
-fn full_piv_lu_inverse_10x10(bh: &mut Bencher) {
+fn full_piv_lu_inverse_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     let lu = FullPivLU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.try_inverse()))
+    bh.bench_function("full_piv_lu_inverse_10x10", move |bh| bh.iter(|| test::black_box(lu.try_inverse())));
 }
 
-#[bench]
-fn full_piv_lu_inverse_100x100(bh: &mut Bencher) {
+fn full_piv_lu_inverse_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let lu = FullPivLU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.try_inverse()))
+    bh.bench_function("full_piv_lu_inverse_100x100", move |bh| bh.iter(|| test::black_box(lu.try_inverse())));
 }
 
-#[bench]
-fn full_piv_lu_inverse_500x500(bh: &mut Bencher) {
+fn full_piv_lu_inverse_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let lu = FullPivLU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.try_inverse()))
+    bh.bench_function("full_piv_lu_inverse_500x500", move |bh| bh.iter(|| test::black_box(lu.try_inverse())));
 }
 
-#[bench]
-fn full_piv_lu_determinant_10x10(bh: &mut Bencher) {
+fn full_piv_lu_determinant_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     let lu = FullPivLU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.determinant()))
+    bh.bench_function("full_piv_lu_determinant_10x10", move |bh| bh.iter(|| test::black_box(lu.determinant())));
 }
 
-#[bench]
-fn full_piv_lu_determinant_100x100(bh: &mut Bencher) {
+
+fn full_piv_lu_determinant_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let lu = FullPivLU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.determinant()))
+    bh.bench_function("full_piv_lu_determinant_100x100", move |bh| bh.iter(|| test::black_box(lu.determinant())));
 }
 
-#[bench]
-fn full_piv_lu_determinant_500x500(bh: &mut Bencher) {
+fn full_piv_lu_determinant_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let lu = FullPivLU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.determinant()))
+    bh.bench_function("full_piv_lu_determinant_500x500", move |bh| bh.iter(|| test::black_box(lu.determinant())));
 }
+
+criterion_group!(full_piv_lu,
+    full_piv_lu_decompose_10x10,
+    full_piv_lu_decompose_100x100,
+//    full_piv_lu_decompose_500x500,
+    full_piv_lu_solve_10x10,
+    full_piv_lu_solve_100x100,
+//    full_piv_lu_solve_500x500,
+    full_piv_lu_inverse_10x10,
+    full_piv_lu_inverse_100x100,
+//    full_piv_lu_inverse_500x500,
+    full_piv_lu_determinant_10x10,
+    full_piv_lu_determinant_100x100,
+//    full_piv_lu_determinant_500x500
+);
\ No newline at end of file
diff --git a/benches/linalg/hessenberg.rs b/benches/linalg/hessenberg.rs
index 427aa1fe2..3340c3efc 100644
--- a/benches/linalg/hessenberg.rs
+++ b/benches/linalg/hessenberg.rs
@@ -1,58 +1,60 @@
 use na::{DMatrix, Hessenberg, Matrix4};
-use test::{self, Bencher};
 
 #[path = "../common/macros.rs"]
 mod macros;
 
 // Without unpack.
-#[bench]
-fn hessenberg_decompose_4x4(bh: &mut Bencher) {
+fn hessenberg_decompose_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(Hessenberg::new(m.clone())))
+    bh.bench_function("hessenberg_decompose_4x4", move |bh| bh.iter(|| test::black_box(Hessenberg::new(m.clone()))));
 }
 
-#[bench]
-fn hessenberg_decompose_100x100(bh: &mut Bencher) {
+fn hessenberg_decompose_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
-    bh.iter(|| test::black_box(Hessenberg::new(m.clone())))
+    bh.bench_function("hessenberg_decompose_100x100", move |bh| bh.iter(|| test::black_box(Hessenberg::new(m.clone()))));
 }
 
-#[bench]
-fn hessenberg_decompose_200x200(bh: &mut Bencher) {
+fn hessenberg_decompose_200x200(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(200, 200);
-    bh.iter(|| test::black_box(Hessenberg::new(m.clone())))
+    bh.bench_function("hessenberg_decompose_200x200", move |bh| bh.iter(|| test::black_box(Hessenberg::new(m.clone()))));
 }
 
-#[bench]
-fn hessenberg_decompose_500x500(bh: &mut Bencher) {
+fn hessenberg_decompose_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
-    bh.iter(|| test::black_box(Hessenberg::new(m.clone())))
+    bh.bench_function("hessenberg_decompose_500x500", move |bh| bh.iter(|| test::black_box(Hessenberg::new(m.clone()))));
 }
 
 // With unpack.
-#[bench]
-fn hessenberg_decompose_unpack_100x100(bh: &mut Bencher) {
+fn hessenberg_decompose_unpack_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
-    bh.iter(|| {
+    bh.bench_function("hessenberg_decompose_unpack_100x100", move |bh| bh.iter(|| {
         let hess = Hessenberg::new(m.clone());
         let _ = hess.unpack();
-    })
+    }));
 }
 
-#[bench]
-fn hessenberg_decompose_unpack_200x200(bh: &mut Bencher) {
+fn hessenberg_decompose_unpack_200x200(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(200, 200);
-    bh.iter(|| {
+    bh.bench_function("hessenberg_decompose_unpack_200x200", move |bh| bh.iter(|| {
         let hess = Hessenberg::new(m.clone());
         let _ = hess.unpack();
-    })
+    }));
 }
 
-#[bench]
-fn hessenberg_decompose_unpack_500x500(bh: &mut Bencher) {
+fn hessenberg_decompose_unpack_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
-    bh.iter(|| {
+    bh.bench_function("hessenberg_decompose_unpack_500x500", move |bh| bh.iter(|| {
         let hess = Hessenberg::new(m.clone());
         let _ = hess.unpack();
-    })
+    }));
 }
+
+criterion_group!(hessenberg,
+    hessenberg_decompose_4x4,
+    hessenberg_decompose_100x100,
+    hessenberg_decompose_200x200,
+//    hessenberg_decompose_500x500,
+    hessenberg_decompose_unpack_100x100,
+    hessenberg_decompose_unpack_200x200,
+//    hessenberg_decompose_unpack_500x500
+);
\ No newline at end of file
diff --git a/benches/linalg/lu.rs b/benches/linalg/lu.rs
index 2428cf9c4..e37cfe751 100644
--- a/benches/linalg/lu.rs
+++ b/benches/linalg/lu.rs
@@ -1,102 +1,102 @@
 use na::{DMatrix, DVector, LU};
-use test::{self, Bencher};
 
 // Without unpack.
-#[bench]
-fn lu_decompose_10x10(bh: &mut Bencher) {
+fn lu_decompose_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
-    bh.iter(|| test::black_box(LU::new(m.clone())))
+    bh.bench_function("lu_decompose_10x10", move |bh| bh.iter(|| test::black_box(LU::new(m.clone()))));
 }
 
-#[bench]
-fn lu_decompose_100x100(bh: &mut Bencher) {
+fn lu_decompose_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
-    bh.iter(|| test::black_box(LU::new(m.clone())))
+    bh.bench_function("lu_decompose_100x100", move |bh| bh.iter(|| test::black_box(LU::new(m.clone()))));
 }
 
-#[bench]
-fn lu_decompose_500x500(bh: &mut Bencher) {
+fn lu_decompose_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
-    bh.iter(|| test::black_box(LU::new(m.clone())))
+    bh.bench_function("lu_decompose_500x500", move |bh| bh.iter(|| test::black_box(LU::new(m.clone()))));
 }
 
-#[bench]
-fn lu_solve_10x10(bh: &mut Bencher) {
+fn lu_solve_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     let lu = LU::new(m.clone());
 
-    bh.iter(|| {
+    bh.bench_function("lu_solve_10x10", move |bh| bh.iter(|| {
         let mut b = DVector::<f64>::from_element(10, 1.0);
         lu.solve(&mut b);
-    })
+    }));
 }
 
-#[bench]
-fn lu_solve_100x100(bh: &mut Bencher) {
+fn lu_solve_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let lu = LU::new(m.clone());
 
-    bh.iter(|| {
+    bh.bench_function("lu_solve_100x100", move |bh| bh.iter(|| {
         let mut b = DVector::<f64>::from_element(100, 1.0);
         lu.solve(&mut b);
-    })
+    }));
 }
 
-#[bench]
-fn lu_solve_500x500(bh: &mut Bencher) {
+fn lu_solve_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let lu = LU::new(m.clone());
 
-    bh.iter(|| {
+    bh.bench_function("", move |bh| bh.iter(|| {
         let mut b = DVector::<f64>::from_element(500, 1.0);
         lu.solve(&mut b);
-    })
+    }));
 }
 
-#[bench]
-fn lu_inverse_10x10(bh: &mut Bencher) {
+fn lu_inverse_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     let lu = LU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.try_inverse()))
+    bh.bench_function("lu_inverse_10x10", move |bh| bh.iter(|| test::black_box(lu.try_inverse())));
 }
 
-#[bench]
-fn lu_inverse_100x100(bh: &mut Bencher) {
+fn lu_inverse_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let lu = LU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.try_inverse()))
+    bh.bench_function("lu_inverse_100x100", move |bh| bh.iter(|| test::black_box(lu.try_inverse())));
 }
 
-#[bench]
-fn lu_inverse_500x500(bh: &mut Bencher) {
+fn lu_inverse_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let lu = LU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.try_inverse()))
+    bh.bench_function("lu_inverse_500x500", move |bh| bh.iter(|| test::black_box(lu.try_inverse())));
 }
 
-#[bench]
-fn lu_determinant_10x10(bh: &mut Bencher) {
+fn lu_determinant_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     let lu = LU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.determinant()))
+    bh.bench_function("lu_determinant_10x10", move |bh| bh.iter(|| test::black_box(lu.determinant())));
 }
 
-#[bench]
-fn lu_determinant_100x100(bh: &mut Bencher) {
+fn lu_determinant_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let lu = LU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.determinant()))
+    bh.bench_function("lu_determinant_100x100", move |bh| bh.iter(|| test::black_box(lu.determinant())));
 }
 
-#[bench]
-fn lu_determinant_500x500(bh: &mut Bencher) {
+fn lu_determinant_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let lu = LU::new(m.clone());
 
-    bh.iter(|| test::black_box(lu.determinant()))
+    bh.bench_function("", move |bh| bh.iter(|| test::black_box(lu.determinant())));
 }
+
+criterion_group!(lu,
+    lu_decompose_10x10,
+    lu_decompose_100x100,
+//    lu_decompose_500x500,
+    lu_solve_10x10,
+    lu_solve_100x100,
+    lu_inverse_10x10,
+    lu_inverse_100x100,
+//    lu_inverse_500x500,
+    lu_determinant_10x10,
+    lu_determinant_100x100
+);
\ No newline at end of file
diff --git a/benches/linalg/mod.rs b/benches/linalg/mod.rs
index 526b32ea5..a6e7a8ef7 100644
--- a/benches/linalg/mod.rs
+++ b/benches/linalg/mod.rs
@@ -1,3 +1,14 @@
+pub use self::bidiagonal::bidiagonal;
+pub use self::cholesky::cholesky;
+pub use self::full_piv_lu::full_piv_lu;
+pub use self::hessenberg::hessenberg;
+pub use self::lu::lu;
+pub use self::qr::qr;
+pub use self::schur::schur;
+pub use self::solve::solve;
+pub use self::svd::svd;
+pub use self::symmetric_eigen::symmetric_eigen;
+
 mod bidiagonal;
 mod cholesky;
 mod full_piv_lu;
@@ -8,4 +19,4 @@ mod schur;
 mod solve;
 mod svd;
 mod symmetric_eigen;
-// mod eigen;
+// mod eigen;
\ No newline at end of file
diff --git a/benches/linalg/qr.rs b/benches/linalg/qr.rs
index 41a814ff2..8283c5e9c 100644
--- a/benches/linalg/qr.rs
+++ b/benches/linalg/qr.rs
@@ -1,130 +1,133 @@
 use na::{DMatrix, DVector, Matrix4, QR};
-use test::{self, Bencher};
 
 #[path = "../common/macros.rs"]
 mod macros;
 
 // Without unpack.
-#[bench]
-fn qr_decompose_100x100(bh: &mut Bencher) {
+fn qr_decompose_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
-    bh.iter(|| test::black_box(QR::new(m.clone())))
+    bh.bench_function("qr_decompose_100x100", move |bh| bh.iter(|| test::black_box(QR::new(m.clone()))));
 }
 
-#[bench]
-fn qr_decompose_100x500(bh: &mut Bencher) {
+fn qr_decompose_100x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 500);
-    bh.iter(|| test::black_box(QR::new(m.clone())))
+    bh.bench_function("qr_decompose_100x500", move |bh| bh.iter(|| test::black_box(QR::new(m.clone()))));
 }
 
-#[bench]
-fn qr_decompose_4x4(bh: &mut Bencher) {
+fn qr_decompose_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(QR::new(m.clone())))
+    bh.bench_function("qr_decompose_4x4", move |bh| bh.iter(|| test::black_box(QR::new(m.clone()))));
 }
 
-#[bench]
-fn qr_decompose_500x100(bh: &mut Bencher) {
+fn qr_decompose_500x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 100);
-    bh.iter(|| test::black_box(QR::new(m.clone())))
+    bh.bench_function("qr_decompose_500x100", move |bh| bh.iter(|| test::black_box(QR::new(m.clone()))));
 }
 
-#[bench]
-fn qr_decompose_500x500(bh: &mut Bencher) {
+fn qr_decompose_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
-    bh.iter(|| test::black_box(QR::new(m.clone())))
+    bh.bench_function("qr_decompose_500x500", move |bh| bh.iter(|| test::black_box(QR::new(m.clone()))));
 }
 
 // With unpack.
-#[bench]
-fn qr_decompose_unpack_100x100(bh: &mut Bencher) {
+fn qr_decompose_unpack_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
-    bh.iter(|| {
+    bh.bench_function("qr_decompose_unpack_100x100", move |bh| bh.iter(|| {
         let qr = QR::new(m.clone());
         let _ = qr.unpack();
-    })
+    }));
 }
 
-#[bench]
-fn qr_decompose_unpack_100x500(bh: &mut Bencher) {
+fn qr_decompose_unpack_100x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 500);
-    bh.iter(|| {
+    bh.bench_function("qr_decompose_unpack_100x500", move |bh| bh.iter(|| {
         let qr = QR::new(m.clone());
         let _ = qr.unpack();
-    })
+    }));
 }
 
-#[bench]
-fn qr_decompose_unpack_500x100(bh: &mut Bencher) {
+fn qr_decompose_unpack_500x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 100);
-    bh.iter(|| {
+    bh.bench_function("qr_decompose_unpack_500x100", move |bh| bh.iter(|| {
         let qr = QR::new(m.clone());
         let _ = qr.unpack();
-    })
+    }));
 }
 
-#[bench]
-fn qr_decompose_unpack_500x500(bh: &mut Bencher) {
+fn qr_decompose_unpack_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
-    bh.iter(|| {
+    bh.bench_function("qr_decompose_unpack_500x500", move |bh| bh.iter(|| {
         let qr = QR::new(m.clone());
         let _ = qr.unpack();
-    })
+    }));
 }
 
-#[bench]
-fn qr_solve_10x10(bh: &mut Bencher) {
+fn qr_solve_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     let qr = QR::new(m.clone());
 
-    bh.iter(|| {
+    bh.bench_function("qr_solve_10x10", move |bh| bh.iter(|| {
         let mut b = DVector::<f64>::from_element(10, 1.0);
         qr.solve(&mut b);
-    })
+    }));
 }
 
-#[bench]
-fn qr_solve_100x100(bh: &mut Bencher) {
+fn qr_solve_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let qr = QR::new(m.clone());
 
-    bh.iter(|| {
+    bh.bench_function("qr_solve_100x100", move |bh| bh.iter(|| {
         let mut b = DVector::<f64>::from_element(100, 1.0);
         qr.solve(&mut b);
-    })
+    }));
 }
 
-#[bench]
-fn qr_solve_500x500(bh: &mut Bencher) {
+fn qr_solve_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let qr = QR::new(m.clone());
 
-    bh.iter(|| {
+    bh.bench_function("qr_solve_500x500", move |bh| bh.iter(|| {
         let mut b = DVector::<f64>::from_element(500, 1.0);
         qr.solve(&mut b);
-    })
+    }));
 }
 
-#[bench]
-fn qr_inverse_10x10(bh: &mut Bencher) {
+fn qr_inverse_10x10(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(10, 10);
     let qr = QR::new(m.clone());
 
-    bh.iter(|| test::black_box(qr.try_inverse()))
+    bh.bench_function("qr_inverse_10x10", move |bh| bh.iter(|| test::black_box(qr.try_inverse())));
 }
 
-#[bench]
-fn qr_inverse_100x100(bh: &mut Bencher) {
+fn qr_inverse_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let qr = QR::new(m.clone());
 
-    bh.iter(|| test::black_box(qr.try_inverse()))
+    bh.bench_function("qr_inverse_100x100", move |bh| bh.iter(|| test::black_box(qr.try_inverse())));
 }
 
-#[bench]
-fn qr_inverse_500x500(bh: &mut Bencher) {
+fn qr_inverse_500x500(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(500, 500);
     let qr = QR::new(m.clone());
 
-    bh.iter(|| test::black_box(qr.try_inverse()))
+    bh.bench_function("qr_inverse_500x500", move |bh| bh.iter(|| test::black_box(qr.try_inverse())));
 }
+
+
+criterion_group!(qr,
+    qr_decompose_100x100,
+    qr_decompose_100x500,
+    qr_decompose_4x4,
+    qr_decompose_500x100,
+//    qr_decompose_500x500,
+    qr_decompose_unpack_100x100,
+    qr_decompose_unpack_100x500,
+    qr_decompose_unpack_500x100,
+//    qr_decompose_unpack_500x500,
+    qr_solve_10x10,
+    qr_solve_100x100,
+//    qr_solve_500x500,
+    qr_inverse_10x10,
+    qr_inverse_100x100,
+//    qr_inverse_500x500
+);
\ No newline at end of file
diff --git a/benches/linalg/schur.rs b/benches/linalg/schur.rs
index e0e588ac9..ffabc5393 100644
--- a/benches/linalg/schur.rs
+++ b/benches/linalg/schur.rs
@@ -1,50 +1,52 @@
-use na::{Matrix4, RealSchur};
-use test::{self, Bencher};
+use na::{Matrix4, Schur};
 
-#[bench]
-fn schur_decompose_4x4(bh: &mut Bencher) {
+fn schur_decompose_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(RealSchur::new(m.clone())))
+    bh.bench_function("schur_decompose_4x4", move |bh| bh.iter(|| test::black_box(Schur::new(m.clone()))));
 }
 
-#[bench]
-fn schur_decompose_10x10(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(10, 10);
-    bh.iter(|| test::black_box(RealSchur::new(m.clone())))
+fn schur_decompose_10x10(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(10, 10);
+    bh.bench_function("schur_decompose_10x10", move |bh| bh.iter(|| test::black_box(Schur::new(m.clone()))));
 }
 
-#[bench]
-fn schur_decompose_100x100(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(100, 100);
-    bh.iter(|| test::black_box(RealSchur::new(m.clone())))
+fn schur_decompose_100x100(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(100, 100);
+    bh.bench_function("schur_decompose_100x100", move |bh| bh.iter(|| test::black_box(Schur::new(m.clone()))));
 }
 
-#[bench]
-fn schur_decompose_200x200(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(200, 200);
-    bh.iter(|| test::black_box(RealSchur::new(m.clone())))
+fn schur_decompose_200x200(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(200, 200);
+    bh.bench_function("schur_decompose_200x200", move |bh| bh.iter(|| test::black_box(Schur::new(m.clone()))));
 }
 
-#[bench]
-fn eigenvalues_4x4(bh: &mut Bencher) {
+fn eigenvalues_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(m.complex_eigenvalues()))
+    bh.bench_function("eigenvalues_4x4", move |bh| bh.iter(|| test::black_box(m.complex_eigenvalues())));
 }
 
-#[bench]
-fn eigenvalues_10x10(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(10, 10);
-    bh.iter(|| test::black_box(m.complex_eigenvalues()))
+fn eigenvalues_10x10(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(10, 10);
+    bh.bench_function("eigenvalues_10x10", move |bh| bh.iter(|| test::black_box(m.complex_eigenvalues())));
 }
 
-#[bench]
-fn eigenvalues_100x100(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(100, 100);
-    bh.iter(|| test::black_box(m.complex_eigenvalues()))
+fn eigenvalues_100x100(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(100, 100);
+    bh.bench_function("eigenvalues_100x100", move |bh| bh.iter(|| test::black_box(m.complex_eigenvalues())));
 }
 
-#[bench]
-fn eigenvalues_200x200(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(200, 200);
-    bh.iter(|| test::black_box(m.complex_eigenvalues()))
+fn eigenvalues_200x200(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(200, 200);
+    bh.bench_function("eigenvalues_200x200", move |bh| bh.iter(|| test::black_box(m.complex_eigenvalues())));
 }
+
+criterion_group!(schur,
+    schur_decompose_4x4,
+    schur_decompose_10x10,
+    schur_decompose_100x100,
+    schur_decompose_200x200,
+    eigenvalues_4x4,
+    eigenvalues_10x10,
+    eigenvalues_100x100,
+    eigenvalues_200x200
+);
\ No newline at end of file
diff --git a/benches/linalg/solve.rs b/benches/linalg/solve.rs
index 03ec71e56..51c6db596 100644
--- a/benches/linalg/solve.rs
+++ b/benches/linalg/solve.rs
@@ -1,82 +1,85 @@
 use na::{DMatrix, DVector};
-use test::Bencher;
 
-#[bench]
-fn solve_l_triangular_100x100(bh: &mut Bencher) {
+fn solve_l_triangular_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let v = DVector::<f64>::new_random(100);
 
-    bh.iter(|| {
+    bh.bench_function("solve_l_triangular_100x100", move |bh| bh.iter(|| {
         let _ = m.solve_lower_triangular(&v);
-    })
+    }));
 }
 
-#[bench]
-fn solve_l_triangular_1000x1000(bh: &mut Bencher) {
+fn solve_l_triangular_1000x1000(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(1000, 1000);
     let v = DVector::<f64>::new_random(1000);
 
-    bh.iter(|| {
+    bh.bench_function("solve_l_triangular_1000x1000", move |bh| bh.iter(|| {
         let _ = m.solve_lower_triangular(&v);
-    })
+    }));
 }
 
-#[bench]
-fn tr_solve_l_triangular_100x100(bh: &mut Bencher) {
+fn tr_solve_l_triangular_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let v = DVector::<f64>::new_random(100);
 
-    bh.iter(|| {
+    bh.bench_function("tr_solve_l_triangular_100x100", move |bh| bh.iter(|| {
         let _ = m.tr_solve_lower_triangular(&v);
-    })
+    }));
 }
 
-#[bench]
-fn tr_solve_l_triangular_1000x1000(bh: &mut Bencher) {
+fn tr_solve_l_triangular_1000x1000(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(1000, 1000);
     let v = DVector::<f64>::new_random(1000);
 
-    bh.iter(|| {
+    bh.bench_function("tr_solve_l_triangular_1000x1000", move |bh| bh.iter(|| {
         let _ = m.tr_solve_lower_triangular(&v);
-    })
+    }));
 }
 
-#[bench]
-fn solve_u_triangular_100x100(bh: &mut Bencher) {
+fn solve_u_triangular_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let v = DVector::<f64>::new_random(100);
 
-    bh.iter(|| {
+    bh.bench_function("solve_u_triangular_100x100", move |bh| bh.iter(|| {
         let _ = m.solve_upper_triangular(&v);
-    })
+    }));
 }
 
-#[bench]
-fn solve_u_triangular_1000x1000(bh: &mut Bencher) {
+fn solve_u_triangular_1000x1000(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(1000, 1000);
     let v = DVector::<f64>::new_random(1000);
 
-    bh.iter(|| {
+    bh.bench_function("solve_u_triangular_1000x1000", move |bh| bh.iter(|| {
         let _ = m.solve_upper_triangular(&v);
-    })
+    }));
 }
 
-#[bench]
-fn tr_solve_u_triangular_100x100(bh: &mut Bencher) {
+fn tr_solve_u_triangular_100x100(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(100, 100);
     let v = DVector::<f64>::new_random(100);
 
-    bh.iter(|| {
+    bh.bench_function("tr_solve_u_triangular_100x100", move |bh| bh.iter(|| {
         let _ = m.tr_solve_upper_triangular(&v);
-    })
+    }));
 }
 
-#[bench]
-fn tr_solve_u_triangular_1000x1000(bh: &mut Bencher) {
+fn tr_solve_u_triangular_1000x1000(bh: &mut criterion::Criterion) {
     let m = DMatrix::<f64>::new_random(1000, 1000);
     let v = DVector::<f64>::new_random(1000);
 
-    bh.iter(|| {
+    bh.bench_function("tr_solve_u_triangular_1000x1000", move |bh| bh.iter(|| {
         let _ = m.tr_solve_upper_triangular(&v);
-    })
+    }));
 }
+
+
+criterion_group!(solve,
+    solve_l_triangular_100x100,
+    solve_l_triangular_1000x1000,
+    tr_solve_l_triangular_100x100,
+    tr_solve_l_triangular_1000x1000,
+    solve_u_triangular_100x100,
+    solve_u_triangular_1000x1000,
+    tr_solve_u_triangular_100x100,
+    tr_solve_u_triangular_1000x1000
+);
\ No newline at end of file
diff --git a/benches/linalg/svd.rs b/benches/linalg/svd.rs
index 47023804a..6804147c1 100644
--- a/benches/linalg/svd.rs
+++ b/benches/linalg/svd.rs
@@ -1,98 +1,101 @@
 use na::{Matrix4, SVD};
-use test::{self, Bencher};
 
-#[bench]
-fn svd_decompose_4x4(bh: &mut Bencher) {
+fn svd_decompose_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(SVD::new(m.clone(), true, true)))
+    bh.bench_function("svd_decompose_4x4", move |bh| bh.iter(|| test::black_box(SVD::new(m.clone(), true, true))));
 }
 
-#[bench]
-fn svd_decompose_10x10(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(10, 10);
-    bh.iter(|| test::black_box(SVD::new(m.clone(), true, true)))
+fn svd_decompose_10x10(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(10, 10);
+    bh.bench_function("svd_decompose_10x10", move |bh| bh.iter(|| test::black_box(SVD::new(m.clone(), true, true))));
 }
 
-#[bench]
-fn svd_decompose_100x100(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(100, 100);
-    bh.iter(|| test::black_box(SVD::new(m.clone(), true, true)))
+fn svd_decompose_100x100(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(100, 100);
+    bh.bench_function("svd_decompose_100x100", move |bh| bh.iter(|| test::black_box(SVD::new(m.clone(), true, true))));
 }
 
-#[bench]
-fn svd_decompose_200x200(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(200, 200);
-    bh.iter(|| test::black_box(SVD::new(m.clone(), true, true)))
+fn svd_decompose_200x200(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(200, 200);
+    bh.bench_function("svd_decompose_200x200", move |bh| bh.iter(|| test::black_box(SVD::new(m.clone(), true, true))));
 }
 
-#[bench]
-fn rank_4x4(bh: &mut Bencher) {
+fn rank_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(m.rank(1.0e-10)))
+    bh.bench_function("rank_4x4", move |bh| bh.iter(|| test::black_box(m.rank(1.0e-10))));
 }
 
-#[bench]
-fn rank_10x10(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(10, 10);
-    bh.iter(|| test::black_box(m.rank(1.0e-10)))
+fn rank_10x10(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(10, 10);
+    bh.bench_function("rank_10x10", move |bh| bh.iter(|| test::black_box(m.rank(1.0e-10))));
 }
 
-#[bench]
-fn rank_100x100(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(100, 100);
-    bh.iter(|| test::black_box(m.rank(1.0e-10)))
+fn rank_100x100(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(100, 100);
+    bh.bench_function("rank_100x100", move |bh| bh.iter(|| test::black_box(m.rank(1.0e-10))));
 }
 
-#[bench]
-fn rank_200x200(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(200, 200);
-    bh.iter(|| test::black_box(m.rank(1.0e-10)))
+fn rank_200x200(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(200, 200);
+    bh.bench_function("rank_200x200", move |bh| bh.iter(|| test::black_box(m.rank(1.0e-10))));
 }
 
-#[bench]
-fn singular_values_4x4(bh: &mut Bencher) {
+fn singular_values_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(m.singular_values()))
+    bh.bench_function("singular_values_4x4", move |bh| bh.iter(|| test::black_box(m.singular_values())));
 }
 
-#[bench]
-fn singular_values_10x10(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(10, 10);
-    bh.iter(|| test::black_box(m.singular_values()))
+fn singular_values_10x10(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(10, 10);
+    bh.bench_function("singular_values_10x10", move |bh| bh.iter(|| test::black_box(m.singular_values())));
 }
 
-#[bench]
-fn singular_values_100x100(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(100, 100);
-    bh.iter(|| test::black_box(m.singular_values()))
+fn singular_values_100x100(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(100, 100);
+    bh.bench_function("singular_values_100x100", move |bh| bh.iter(|| test::black_box(m.singular_values())));
 }
 
-#[bench]
-fn singular_values_200x200(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(200, 200);
-    bh.iter(|| test::black_box(m.singular_values()))
+fn singular_values_200x200(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(200, 200);
+    bh.bench_function("singular_values_200x200", move |bh| bh.iter(|| test::black_box(m.singular_values())));
 }
 
-#[bench]
-fn pseudo_inverse_4x4(bh: &mut Bencher) {
+fn pseudo_inverse_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10)))
+    bh.bench_function("pseudo_inverse_4x4", move |bh| bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10))));
 }
 
-#[bench]
-fn pseudo_inverse_10x10(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(10, 10);
-    bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10)))
+fn pseudo_inverse_10x10(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(10, 10);
+    bh.bench_function("pseudo_inverse_10x10", move |bh| bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10))));
 }
 
-#[bench]
-fn pseudo_inverse_100x100(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(100, 100);
-    bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10)))
+fn pseudo_inverse_100x100(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(100, 100);
+    bh.bench_function("pseudo_inverse_100x100", move |bh| bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10))));
 }
 
-#[bench]
-fn pseudo_inverse_200x200(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(200, 200);
-    bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10)))
+fn pseudo_inverse_200x200(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(200, 200);
+    bh.bench_function("pseudo_inverse_200x200", move |bh| bh.iter(|| test::black_box(m.clone().pseudo_inverse(1.0e-10))));
 }
+
+
+criterion_group!(svd,
+    svd_decompose_4x4,
+    svd_decompose_10x10,
+    svd_decompose_100x100,
+    svd_decompose_200x200,
+    rank_4x4,
+    rank_10x10,
+    rank_100x100,
+    rank_200x200,
+    singular_values_4x4,
+    singular_values_10x10,
+    singular_values_100x100,
+    singular_values_200x200,
+    pseudo_inverse_4x4,
+    pseudo_inverse_10x10,
+    pseudo_inverse_100x100,
+    pseudo_inverse_200x200
+);
\ No newline at end of file
diff --git a/benches/linalg/symmetric_eigen.rs b/benches/linalg/symmetric_eigen.rs
index 2a9058dae..822ea30ed 100644
--- a/benches/linalg/symmetric_eigen.rs
+++ b/benches/linalg/symmetric_eigen.rs
@@ -1,26 +1,28 @@
 use na::{Matrix4, SymmetricEigen};
-use test::{self, Bencher};
 
-#[bench]
-fn symmetric_eigen_decompose_4x4(bh: &mut Bencher) {
+fn symmetric_eigen_decompose_4x4(bh: &mut criterion::Criterion) {
     let m = Matrix4::<f64>::new_random();
-    bh.iter(|| test::black_box(SymmetricEigen::new(m.clone())))
+    bh.bench_function("symmetric_eigen_decompose_4x4", move |bh| bh.iter(|| test::black_box(SymmetricEigen::new(m.clone()))));
 }
 
-#[bench]
-fn symmetric_eigen_decompose_10x10(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(10, 10);
-    bh.iter(|| test::black_box(SymmetricEigen::new(m.clone())))
+fn symmetric_eigen_decompose_10x10(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(10, 10);
+    bh.bench_function("symmetric_eigen_decompose_10x10", move |bh| bh.iter(|| test::black_box(SymmetricEigen::new(m.clone()))));
 }
 
-#[bench]
-fn symmetric_eigen_decompose_100x100(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(100, 100);
-    bh.iter(|| test::black_box(SymmetricEigen::new(m.clone())))
+fn symmetric_eigen_decompose_100x100(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(100, 100);
+    bh.bench_function("symmetric_eigen_decompose_100x100", move |bh| bh.iter(|| test::black_box(SymmetricEigen::new(m.clone()))));
 }
 
-#[bench]
-fn symmetric_eigen_decompose_200x200(bh: &mut Bencher) {
-    let m = ::reproductible_dmatrix(200, 200);
-    bh.iter(|| test::black_box(SymmetricEigen::new(m.clone())))
+fn symmetric_eigen_decompose_200x200(bh: &mut criterion::Criterion) {
+    let m = crate::reproductible_dmatrix(200, 200);
+    bh.bench_function("symmetric_eigen_decompose_200x200", move |bh| bh.iter(|| test::black_box(SymmetricEigen::new(m.clone()))));
 }
+
+criterion_group!(symmetric_eigen,
+    symmetric_eigen_decompose_4x4,
+    symmetric_eigen_decompose_10x10,
+    symmetric_eigen_decompose_100x100,
+    symmetric_eigen_decompose_200x200
+);
diff --git a/ci/test.sh b/ci/test.sh
index 88071149d..a3a27fb27 100755
--- a/ci/test.sh
+++ b/ci/test.sh
@@ -6,7 +6,7 @@ if [ -z "$NO_STD" ]; then
     if [ -z "$LAPACK" ]; then
         cargo test --verbose;
         cargo test --verbose "arbitrary";
-        cargo test --verbose "debug arbitrary mint serde-serialize abomonation-serialize";
+        cargo test --verbose --all-features;
         cd nalgebra-glm; cargo test --verbose;
     else
         cd nalgebra-lapack; cargo test --verbose;
diff --git a/examples/dimensional_genericity.rs b/examples/dimensional_genericity.rs
index ca653d57d..411a06664 100644
--- a/examples/dimensional_genericity.rs
+++ b/examples/dimensional_genericity.rs
@@ -4,7 +4,7 @@ extern crate nalgebra as na;
 use alga::linear::FiniteDimInnerSpace;
 use na::allocator::Allocator;
 use na::dimension::Dim;
-use na::{DefaultAllocator, Real, Unit, Vector2, Vector3, VectorN};
+use na::{DefaultAllocator, RealField, Unit, Vector2, Vector3, VectorN};
 
 /// Reflects a vector wrt. the hyperplane with normal `plane_normal`.
 fn reflect_wrt_hyperplane_with_algebraic_genericity<V>(plane_normal: &Unit<V>, vector: &V) -> V
@@ -14,12 +14,12 @@ where V: FiniteDimInnerSpace + Copy {
 }
 
 /// Reflects a vector wrt. the hyperplane with normal `plane_normal`.
-fn reflect_wrt_hyperplane_with_dimensional_genericity<N: Real, D: Dim>(
+fn reflect_wrt_hyperplane_with_dimensional_genericity<N: RealField, D: Dim>(
     plane_normal: &Unit<VectorN<N, D>>,
     vector: &VectorN<N, D>,
 ) -> VectorN<N, D>
 where
-    N: Real,
+    N: RealField,
     D: Dim,
     DefaultAllocator: Allocator<N, D>,
 {
@@ -29,7 +29,7 @@ where
 
 /// Reflects a 2D vector wrt. the 2D line with normal `plane_normal`.
 fn reflect_wrt_hyperplane2<N>(plane_normal: &Unit<Vector2<N>>, vector: &Vector2<N>) -> Vector2<N>
-where N: Real {
+where N: RealField {
     let n = plane_normal.as_ref(); // Get the underlying Vector2
     vector - n * (n.dot(vector) * na::convert(2.0))
 }
@@ -37,7 +37,7 @@ where N: Real {
 /// Reflects a 3D vector wrt. the 3D plane with normal `plane_normal`.
 /// /!\ This is an exact replicate of `reflect_wrt_hyperplane2, but for 3D.
 fn reflect_wrt_hyperplane3<N>(plane_normal: &Unit<Vector3<N>>, vector: &Vector3<N>) -> Vector3<N>
-where N: Real {
+where N: RealField {
     let n = plane_normal.as_ref(); // Get the underlying Vector3
     vector - n * (n.dot(vector) * na::convert(2.0))
 }
diff --git a/examples/identity.rs b/examples/identity.rs
index 06d69f708..c20c5616c 100644
--- a/examples/identity.rs
+++ b/examples/identity.rs
@@ -36,4 +36,4 @@ fn main() {
     // They both return the same result.
     assert!(result1 == Vector3::new(100001.0, 200002.0, 300003.0));
     assert!(result2 == Vector3::new(100001.0, 200002.0, 300003.0));
-}
+}
\ No newline at end of file
diff --git a/examples/scalar_genericity.rs b/examples/scalar_genericity.rs
index 246d1efd4..75f6f9d40 100644
--- a/examples/scalar_genericity.rs
+++ b/examples/scalar_genericity.rs
@@ -1,7 +1,7 @@
 extern crate alga;
 extern crate nalgebra as na;
 
-use alga::general::{Real, RingCommutative};
+use alga::general::{RealField, RingCommutative};
 use na::{Scalar, Vector3};
 
 fn print_vector<N: Scalar>(m: &Vector3<N>) {
@@ -14,11 +14,11 @@ fn print_squared_norm<N: Scalar + RingCommutative>(v: &Vector3<N>) {
     println!("{:?}", sqnorm);
 }
 
-fn print_norm<N: Real>(v: &Vector3<N>) {
+fn print_norm<N: RealField>(v: &Vector3<N>) {
     // NOTE: alternatively, nalgebra already defines `v.norm()`.
     let norm = v.dot(v).sqrt();
 
-    // The Real bound implies that N is Display so we can
+    // The RealField bound implies that N is Display so we can
     // use "{}" instead of "{:?}" for the format string.
     println!("{}", norm)
 }
diff --git a/nalgebra-glm/Cargo.toml b/nalgebra-glm/Cargo.toml
index 1da1333d8..042c75fb6 100644
--- a/nalgebra-glm/Cargo.toml
+++ b/nalgebra-glm/Cargo.toml
@@ -11,6 +11,7 @@ readme = "../README.md"
 categories = [ "science" ]
 keywords = [ "linear", "algebra", "matrix", "vector", "math" ]
 license = "BSD-3-Clause"
+edition = "2018"
 
 [features]
 default         = [ "std" ]
diff --git a/nalgebra-glm/src/common.rs b/nalgebra-glm/src/common.rs
index 021ac3efe..c9f9c2655 100644
--- a/nalgebra-glm/src/common.rs
+++ b/nalgebra-glm/src/common.rs
@@ -1,9 +1,9 @@
-use na::{self, DefaultAllocator, Real};
+use na::{self, DefaultAllocator, RealField};
 use num::FromPrimitive;
 use std::mem;
 
-use aliases::{TMat, TVec};
-use traits::{Alloc, Dimension, Number};
+use crate::aliases::{TMat, TVec};
+use crate::traits::{Alloc, Dimension, Number};
 
 /// For each matrix or vector component `x` if `x >= 0`; otherwise, it returns `-x`.
 ///
@@ -43,7 +43,7 @@ where DefaultAllocator: Alloc<N, R, C> {
 /// * [`fract`](fn.fract.html)
 /// * [`round`](fn.round.html)
 /// * [`trunc`](fn.trunc.html)
-pub fn ceil<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
+pub fn ceil<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     x.map(|x| x.ceil())
 }
@@ -222,7 +222,7 @@ where DefaultAllocator: Alloc<f32, D> {
 /// * [`fract`](fn.fract.html)
 /// * [`round`](fn.round.html)
 /// * [`trunc`](fn.trunc.html)
-pub fn floor<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
+pub fn floor<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     x.map(|x| x.floor())
 }
@@ -249,14 +249,14 @@ where DefaultAllocator: Alloc<N, D> {
 /// * [`floor`](fn.floor.html)
 /// * [`round`](fn.round.html)
 /// * [`trunc`](fn.trunc.html)
-pub fn fract<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
+pub fn fract<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     x.map(|x| x.fract())
 }
 
 //// FIXME: should be implemented for TVec/TMat?
 ///// Returns the (significant, exponent) of this float number.
-//pub fn frexp<N: Real>(x: N, exp: N) -> (N, N) {
+//pub fn frexp<N: RealField>(x: N, exp: N) -> (N, N) {
 //    // FIXME: is there a better approach?
 //    let e = x.log2().ceil();
 //    (x * (-e).exp2(), e)
@@ -310,7 +310,7 @@ where DefaultAllocator: Alloc<f32, D> {
 //}
 
 ///// Returns the (significant, exponent) of this float number.
-//pub fn ldexp<N: Real>(x: N, exp: N) -> N {
+//pub fn ldexp<N: RealField>(x: N, exp: N) -> N {
 //    // FIXME: is there a better approach?
 //    x * (exp).exp2()
 //}
@@ -499,7 +499,7 @@ pub fn modf<N: Number>(x: N, i: N) -> N {
 /// * [`floor`](fn.floor.html)
 /// * [`fract`](fn.fract.html)
 /// * [`trunc`](fn.trunc.html)
-pub fn round<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
+pub fn round<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     x.map(|x| x.round())
 }
@@ -576,7 +576,7 @@ where DefaultAllocator: Alloc<N, D> {
 /// * [`floor`](fn.floor.html)
 /// * [`fract`](fn.fract.html)
 /// * [`round`](fn.round.html)
-pub fn trunc<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
+pub fn trunc<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     x.map(|x| x.trunc())
 }
diff --git a/nalgebra-glm/src/constructors.rs b/nalgebra-glm/src/constructors.rs
index 1651dd20b..949ea9e4a 100644
--- a/nalgebra-glm/src/constructors.rs
+++ b/nalgebra-glm/src/constructors.rs
@@ -1,7 +1,7 @@
 #![cfg_attr(rustfmt, rustfmt_skip)]
 
-use na::{Scalar, Real, U2, U3, U4};
-use aliases::{TMat, Qua, TVec1, TVec2, TVec3, TVec4, TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4,
+use na::{Scalar, RealField, U2, U3, U4};
+use crate::aliases::{TMat, Qua, TVec1, TVec2, TVec3, TVec4, TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4,
               TMat4, TMat4x2, TMat4x3};
 
 
@@ -168,6 +168,6 @@ pub fn mat4<N: Scalar>(m11: N, m12: N, m13: N, m14: N,
 }
 
 /// Creates a new quaternion.
-pub fn quat<N: Real>(x: N, y: N, z: N, w: N) -> Qua<N> {
+pub fn quat<N: RealField>(x: N, y: N, z: N, w: N) -> Qua<N> {
     Qua::new(w, x, y, z)
 }
diff --git a/nalgebra-glm/src/exponential.rs b/nalgebra-glm/src/exponential.rs
index 21b716f2a..fd54fb343 100644
--- a/nalgebra-glm/src/exponential.rs
+++ b/nalgebra-glm/src/exponential.rs
@@ -1,13 +1,13 @@
-use aliases::TVec;
-use na::{DefaultAllocator, Real};
-use traits::{Alloc, Dimension};
+use crate::aliases::TVec;
+use na::{DefaultAllocator, RealField};
+use crate::traits::{Alloc, Dimension};
 
 /// Component-wise exponential.
 ///
 /// # See also:
 ///
 /// * [`exp2`](fn.exp2.html)
-pub fn exp<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
+pub fn exp<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     v.map(|x| x.exp())
 }
@@ -17,7 +17,7 @@ where DefaultAllocator: Alloc<N, D> {
 /// # See also:
 ///
 /// * [`exp`](fn.exp.html)
-pub fn exp2<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
+pub fn exp2<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     v.map(|x| x.exp2())
 }
@@ -27,7 +27,7 @@ where DefaultAllocator: Alloc<N, D> {
 /// # See also:
 ///
 /// * [`sqrt`](fn.sqrt.html)
-pub fn inversesqrt<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
+pub fn inversesqrt<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     v.map(|x| N::one() / x.sqrt())
 }
@@ -37,7 +37,7 @@ where DefaultAllocator: Alloc<N, D> {
 /// # See also:
 ///
 /// * [`log2`](fn.log2.html)
-pub fn log<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
+pub fn log<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     v.map(|x| x.ln())
 }
@@ -47,13 +47,13 @@ where DefaultAllocator: Alloc<N, D> {
 /// # See also:
 ///
 /// * [`log`](fn.log.html)
-pub fn log2<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
+pub fn log2<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     v.map(|x| x.log2())
 }
 
 /// Component-wise power.
-pub fn pow<N: Real, D: Dimension>(base: &TVec<N, D>, exponent: &TVec<N, D>) -> TVec<N, D>
+pub fn pow<N: RealField, D: Dimension>(base: &TVec<N, D>, exponent: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     base.zip_map(exponent, |b, e| b.powf(e))
 }
@@ -66,7 +66,7 @@ where DefaultAllocator: Alloc<N, D> {
 /// * [`exp2`](fn.exp2.html)
 /// * [`inversesqrt`](fn.inversesqrt.html)
 /// * [`pow`](fn.pow.html)
-pub fn sqrt<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
+pub fn sqrt<N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     v.map(|x| x.sqrt())
 }
diff --git a/nalgebra-glm/src/ext/matrix_clip_space.rs b/nalgebra-glm/src/ext/matrix_clip_space.rs
index 02179759c..6ef1404bf 100644
--- a/nalgebra-glm/src/ext/matrix_clip_space.rs
+++ b/nalgebra-glm/src/ext/matrix_clip_space.rs
@@ -1,55 +1,55 @@
-use aliases::TMat4;
-use na::{Real};
+use crate::aliases::TMat4;
+use na::{RealField};
 
-//pub fn frustum<N: Real>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 
-//pub fn frustum_lh<N: Real>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_lh<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_lr_no<N: Real>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_lr_no<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_lh_zo<N: Real>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_lh_zo<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_no<N: Real>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_no<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_rh<N: Real>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_rh<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_rh_no<N: Real>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_rh_no<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_rh_zo<N: Real>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_rh_zo<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 //
-//pub fn frustum_zo<N: Real>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
+//pub fn frustum_zo<N: RealField>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 
-//pub fn infinite_perspective<N: Real>(fovy: N, aspect: N, near: N) -> TMat4<N> {
+//pub fn infinite_perspective<N: RealField>(fovy: N, aspect: N, near: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 //
-//pub fn infinite_perspective_lh<N: Real>(fovy: N, aspect: N, near: N) -> TMat4<N> {
+//pub fn infinite_perspective_lh<N: RealField>(fovy: N, aspect: N, near: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 //
-//pub fn infinite_perspective_rh<N: Real>(fovy: N, aspect: N, near: N) -> TMat4<N> {
+//pub fn infinite_perspective_rh<N: RealField>(fovy: N, aspect: N, near: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 //
-//pub fn infinite_ortho<N: Real>(left: N, right: N, bottom: N, top: N) -> TMat4<N> {
+//pub fn infinite_ortho<N: RealField>(left: N, right: N, bottom: N, top: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 
@@ -64,7 +64,7 @@ use na::{Real};
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
     ortho_rh_no(left, right, bottom, top, znear, zfar)
 }
 
@@ -79,7 +79,7 @@ pub fn ortho<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_lh<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho_lh<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
     ortho_lh_no(left, right, bottom, top, znear, zfar)
 }
 
@@ -94,8 +94,8 @@ pub fn ortho_lh<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_lh_no<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
-    let two    : N =  ::convert(2.0);
+pub fn ortho_lh_no<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+    let two    : N =  crate::convert(2.0);
     let mut mat : TMat4<N> = TMat4::<N>::identity();
 
     mat[(0, 0)] = two / (right - left);
@@ -119,9 +119,9 @@ pub fn ortho_lh_no<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_lh_zo<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho_lh_zo<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
     let one    : N = N::one();
-    let two    : N = ::convert(2.0);
+    let two    : N = crate::convert(2.0);
     let mut mat : TMat4<N> = TMat4::<N>::identity();
 
     mat[(0, 0)] = two / (right - left);
@@ -145,7 +145,7 @@ pub fn ortho_lh_zo<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_no<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho_no<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
     ortho_rh_no(left, right, bottom, top, znear, zfar)
 }
 
@@ -160,7 +160,7 @@ pub fn ortho_no<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_rh<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho_rh<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
     ortho_rh_no(left, right, bottom, top, znear, zfar)
 }
 
@@ -175,8 +175,8 @@ pub fn ortho_rh<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_rh_no<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
-    let two    : N =  ::convert(2.0);
+pub fn ortho_rh_no<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+    let two    : N =  crate::convert(2.0);
     let mut mat : TMat4<N> = TMat4::<N>::identity();
 
     mat[(0, 0)] = two / (right - left);
@@ -200,9 +200,9 @@ pub fn ortho_rh_no<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_rh_zo<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho_rh_zo<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
     let one    : N = N::one();
-    let two    : N =  ::convert(2.0);
+    let two    : N =  crate::convert(2.0);
     let mut mat : TMat4<N> = TMat4::<N>::identity();
 
     mat[(0, 0)] = two / (right - left);
@@ -226,7 +226,7 @@ pub fn ortho_rh_zo<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar
 /// * `znear` - Distance from the viewer to the near clipping plane
 /// * `zfar` - Distance from the viewer to the far clipping plane
 ///
-pub fn ortho_zo<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
+pub fn ortho_zo<N: RealField>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -> TMat4<N> {
     ortho_rh_zo(left, right, bottom, top, znear, zfar)
 }
 
@@ -240,7 +240,7 @@ pub fn ortho_zo<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov<N: Real>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
     perspective_fov_rh_no(fov, width, height, near, far)
 }
 
@@ -254,7 +254,7 @@ pub fn perspective_fov<N: Real>(fov: N, width: N, height: N, near: N, far: N) ->
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_lh<N: Real>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_lh<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
     perspective_fov_lh_no(fov, width, height, near, far)
 }
 
@@ -268,7 +268,7 @@ pub fn perspective_fov_lh<N: Real>(fov: N, width: N, height: N, near: N, far: N)
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_lh_no<N: Real>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_lh_no<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
     assert!(
         width > N::zero(),
         "The width must be greater than zero"
@@ -285,13 +285,13 @@ pub fn perspective_fov_lh_no<N: Real>(fov: N, width: N, height: N, near: N, far:
     let mut mat = TMat4::zeros();
 
     let rad = fov;
-    let h = (rad * ::convert(0.5)).cos() / (rad * ::convert(0.5)).sin();
+    let h = (rad * crate::convert(0.5)).cos() / (rad * crate::convert(0.5)).sin();
     let w = h * height / width;
 
     mat[(0, 0)] = w;
     mat[(1, 1)] = h;
     mat[(2, 2)] = (far + near) / (far - near);
-    mat[(2, 3)] = - (far * near * ::convert(2.0)) / (far - near);
+    mat[(2, 3)] = - (far * near * crate::convert(2.0)) / (far - near);
     mat[(3, 2)] = N::one();
 
     mat
@@ -307,7 +307,7 @@ pub fn perspective_fov_lh_no<N: Real>(fov: N, width: N, height: N, near: N, far:
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_lh_zo<N: Real>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_lh_zo<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
     assert!(
         width > N::zero(),
         "The width must be greater than zero"
@@ -324,7 +324,7 @@ pub fn perspective_fov_lh_zo<N: Real>(fov: N, width: N, height: N, near: N, far:
     let mut mat = TMat4::zeros();
 
     let rad = fov;
-    let h = (rad * ::convert(0.5)).cos() / (rad * ::convert(0.5)).sin();
+    let h = (rad * crate::convert(0.5)).cos() / (rad * crate::convert(0.5)).sin();
     let w = h * height / width;
 
     mat[(0, 0)] = w;
@@ -346,7 +346,7 @@ pub fn perspective_fov_lh_zo<N: Real>(fov: N, width: N, height: N, near: N, far:
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_no<N: Real>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_no<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
     perspective_fov_rh_no(fov, width, height, near, far)
 }
 
@@ -360,7 +360,7 @@ pub fn perspective_fov_no<N: Real>(fov: N, width: N, height: N, near: N, far: N)
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_rh<N: Real>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_rh<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
     perspective_fov_rh_no(fov, width, height, near, far)
 }
 
@@ -374,7 +374,7 @@ pub fn perspective_fov_rh<N: Real>(fov: N, width: N, height: N, near: N, far: N)
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_rh_no<N: Real>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_rh_no<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
     assert!(
         width > N::zero(),
         "The width must be greater than zero"
@@ -391,13 +391,13 @@ pub fn perspective_fov_rh_no<N: Real>(fov: N, width: N, height: N, near: N, far:
     let mut mat = TMat4::zeros();
 
     let rad = fov;
-    let h = (rad * ::convert(0.5)).cos() / (rad * ::convert(0.5)).sin();
+    let h = (rad * crate::convert(0.5)).cos() / (rad * crate::convert(0.5)).sin();
     let w = h * height / width;
 
     mat[(0, 0)] = w;
     mat[(1, 1)] = h;
     mat[(2, 2)] = - (far + near) / (far - near);
-    mat[(2, 3)] = - (far * near * ::convert(2.0)) / (far - near);
+    mat[(2, 3)] = - (far * near * crate::convert(2.0)) / (far - near);
     mat[(3, 2)] = -N::one();
 
     mat
@@ -413,7 +413,7 @@ pub fn perspective_fov_rh_no<N: Real>(fov: N, width: N, height: N, near: N, far:
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_rh_zo<N: Real>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_rh_zo<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
     assert!(
         width > N::zero(),
         "The width must be greater than zero"
@@ -430,7 +430,7 @@ pub fn perspective_fov_rh_zo<N: Real>(fov: N, width: N, height: N, near: N, far:
     let mut mat = TMat4::zeros();
 
     let rad = fov;
-    let h = (rad * ::convert(0.5)).cos() / (rad * ::convert(0.5)).sin();
+    let h = (rad * crate::convert(0.5)).cos() / (rad * crate::convert(0.5)).sin();
     let w = h * height / width;
 
     mat[(0, 0)] = w;
@@ -452,7 +452,7 @@ pub fn perspective_fov_rh_zo<N: Real>(fov: N, width: N, height: N, near: N, far:
 /// * `near` - Distance from the viewer to the near clipping plane
 /// * `far` - Distance from the viewer to the far clipping plane
 ///
-pub fn perspective_fov_zo<N: Real>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_fov_zo<N: RealField>(fov: N, width: N, height: N, near: N, far: N) -> TMat4<N> {
     perspective_fov_rh_zo(fov, width, height, near, far)
 }
 
@@ -467,7 +467,7 @@ pub fn perspective_fov_zo<N: Real>(fov: N, width: N, height: N, near: N, far: N)
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
     // TODO: Breaking change - revert back to proper glm conventions?
     //
     //       Prior to changes to support configuring the behaviour of this function it was simply
@@ -496,7 +496,7 @@ pub fn perspective<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_lh<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_lh<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
     perspective_lh_no(aspect, fovy, near, far)
 }
 
@@ -511,7 +511,7 @@ pub fn perspective_lh<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N>
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_lh_no<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_lh_no<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
     assert!(
         !relative_eq!(far - near, N::zero()),
         "The near-plane and far-plane must not be superimposed."
@@ -522,7 +522,7 @@ pub fn perspective_lh_no<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<
     );
 
     let one = N::one();
-    let two: N = ::convert( 2.0);
+    let two: N = crate::convert( 2.0);
     let mut mat : TMat4<N> = TMat4::zeros();
 
     let tan_half_fovy = (fovy / two).tan();
@@ -547,7 +547,7 @@ pub fn perspective_lh_no<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_lh_zo<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_lh_zo<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
     assert!(
         !relative_eq!(far - near, N::zero()),
         "The near-plane and far-plane must not be superimposed."
@@ -558,7 +558,7 @@ pub fn perspective_lh_zo<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<
     );
 
     let one = N::one();
-    let two: N = ::convert( 2.0);
+    let two: N = crate::convert( 2.0);
     let mut mat: TMat4<N> = TMat4::zeros();
 
     let tan_half_fovy = (fovy / two).tan();
@@ -583,7 +583,7 @@ pub fn perspective_lh_zo<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_no<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_no<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
     perspective_rh_no(aspect, fovy, near, far)
 }
 
@@ -598,7 +598,7 @@ pub fn perspective_no<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N>
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_rh<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_rh<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
     perspective_rh_no(aspect, fovy, near, far)
 }
 
@@ -613,7 +613,7 @@ pub fn perspective_rh<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N>
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_rh_no<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_rh_no<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
     assert!(
         !relative_eq!(far - near, N::zero()),
         "The near-plane and far-plane must not be superimposed."
@@ -625,7 +625,7 @@ pub fn perspective_rh_no<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<
 
     let negone = -N::one();
     let one =  N::one();
-    let two: N =   ::convert( 2.0);
+    let two: N =   crate::convert( 2.0);
     let mut mat = TMat4::zeros();
 
     let tan_half_fovy = (fovy / two).tan();
@@ -650,7 +650,7 @@ pub fn perspective_rh_no<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_rh_zo<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_rh_zo<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
     assert!(
         !relative_eq!(far - near, N::zero()),
         "The near-plane and far-plane must not be superimposed."
@@ -662,7 +662,7 @@ pub fn perspective_rh_zo<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<
 
     let negone = -N::one();
     let one =  N::one();
-    let two =   ::convert( 2.0);
+    let two =   crate::convert( 2.0);
     let mut mat = TMat4::zeros();
 
     let tan_half_fovy = (fovy / two).tan();
@@ -687,14 +687,14 @@ pub fn perspective_rh_zo<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<
 ///
 /// # Important note
 /// The `aspect` and `fovy` argument are interchanged compared to the original GLM API.
-pub fn perspective_zo<N: Real>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
+pub fn perspective_zo<N: RealField>(aspect: N, fovy: N, near: N, far: N) -> TMat4<N> {
     perspective_rh_zo(aspect, fovy, near, far)
 }
 
-//pub fn tweaked_infinite_perspective<N: Real>(fovy: N, aspect: N, near: N) -> TMat4<N> {
+//pub fn tweaked_infinite_perspective<N: RealField>(fovy: N, aspect: N, near: N) -> TMat4<N> {
 //    unimplemented!()
 //}
 //
-//pub fn tweaked_infinite_perspective_ep<N: Real>(fovy: N, aspect: N, near: N, ep: N) -> TMat4<N> {
+//pub fn tweaked_infinite_perspective_ep<N: RealField>(fovy: N, aspect: N, near: N, ep: N) -> TMat4<N> {
 //    unimplemented!()
 //}
diff --git a/nalgebra-glm/src/ext/matrix_projection.rs b/nalgebra-glm/src/ext/matrix_projection.rs
index 4ed23fb32..3048b77cd 100644
--- a/nalgebra-glm/src/ext/matrix_projection.rs
+++ b/nalgebra-glm/src/ext/matrix_projection.rs
@@ -1,6 +1,6 @@
-use na::{self, Real, U3};
+use na::{self, RealField, U3};
 
-use aliases::{TMat4, TVec2, TVec3, TVec4};
+use crate::aliases::{TMat4, TVec2, TVec3, TVec4};
 
 /// Define a picking region.
 ///
@@ -9,7 +9,7 @@ use aliases::{TMat4, TVec2, TVec3, TVec4};
 /// * `center` - Specify the center of a picking region in window coordinates.
 /// * `delta` - Specify the width and height, respectively, of the picking region in window coordinates.
 /// * `viewport` - Rendering viewport.
-pub fn pick_matrix<N: Real>(center: &TVec2<N>, delta: &TVec2<N>, viewport: &TVec4<N>) -> TMat4<N> {
+pub fn pick_matrix<N: RealField>(center: &TVec2<N>, delta: &TVec2<N>, viewport: &TVec4<N>) -> TMat4<N> {
     let shift = TVec3::new(
         (viewport.z - (center.x - viewport.x) * na::convert(2.0)) / delta.x,
         (viewport.w - (center.y - viewport.y) * na::convert(2.0)) / delta.y,
@@ -41,7 +41,7 @@ pub fn pick_matrix<N: Real>(center: &TVec2<N>, delta: &TVec2<N>, viewport: &TVec
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_no`](fn.unproject_no.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn project<N: Real>(
+pub fn project<N: RealField>(
     obj: &TVec3<N>,
     model: &TMat4<N>,
     proj: &TMat4<N>,
@@ -69,7 +69,7 @@ pub fn project<N: Real>(
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_no`](fn.unproject_no.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn project_no<N: Real>(
+pub fn project_no<N: RealField>(
     obj: &TVec3<N>,
     model: &TMat4<N>,
     proj: &TMat4<N>,
@@ -98,7 +98,7 @@ pub fn project_no<N: Real>(
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_no`](fn.unproject_no.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn project_zo<N: Real>(
+pub fn project_zo<N: RealField>(
     obj: &TVec3<N>,
     model: &TMat4<N>,
     proj: &TMat4<N>,
@@ -132,7 +132,7 @@ pub fn project_zo<N: Real>(
 /// * [`project_zo`](fn.project_zo.html)
 /// * [`unproject_no`](fn.unproject_no.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn unproject<N: Real>(
+pub fn unproject<N: RealField>(
     win: &TVec3<N>,
     model: &TMat4<N>,
     proj: &TMat4<N>,
@@ -160,7 +160,7 @@ pub fn unproject<N: Real>(
 /// * [`project_zo`](fn.project_zo.html)
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn unproject_no<N: Real>(
+pub fn unproject_no<N: RealField>(
     win: &TVec3<N>,
     model: &TMat4<N>,
     proj: &TMat4<N>,
@@ -198,7 +198,7 @@ pub fn unproject_no<N: Real>(
 /// * [`project_zo`](fn.project_zo.html)
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_no`](fn.unproject_no.html)
-pub fn unproject_zo<N: Real>(
+pub fn unproject_zo<N: RealField>(
     win: &TVec3<N>,
     model: &TMat4<N>,
     proj: &TMat4<N>,
diff --git a/nalgebra-glm/src/ext/matrix_relationnal.rs b/nalgebra-glm/src/ext/matrix_relationnal.rs
index 80fb8b6fd..7866e72a1 100644
--- a/nalgebra-glm/src/ext/matrix_relationnal.rs
+++ b/nalgebra-glm/src/ext/matrix_relationnal.rs
@@ -1,7 +1,7 @@
 use na::DefaultAllocator;
 
-use aliases::{TMat, TVec};
-use traits::{Alloc, Dimension, Number};
+use crate::aliases::{TMat, TVec};
+use crate::traits::{Alloc, Dimension, Number};
 
 /// Perform a component-wise equal-to comparison of two matrices.
 ///
diff --git a/nalgebra-glm/src/ext/matrix_transform.rs b/nalgebra-glm/src/ext/matrix_transform.rs
index 829262494..c7f6b72df 100644
--- a/nalgebra-glm/src/ext/matrix_transform.rs
+++ b/nalgebra-glm/src/ext/matrix_transform.rs
@@ -1,7 +1,7 @@
-use na::{DefaultAllocator, Point3, Real, Rotation3, Unit};
+use na::{DefaultAllocator, Point3, RealField, Rotation3, Unit};
 
-use aliases::{TMat, TMat4, TVec, TVec3};
-use traits::{Alloc, Dimension, Number};
+use crate::aliases::{TMat, TMat4, TVec, TVec3};
+use crate::traits::{Alloc, Dimension, Number};
 
 /// The identity matrix.
 pub fn identity<N: Number, D: Dimension>() -> TMat<N, D, D>
@@ -21,7 +21,7 @@ where DefaultAllocator: Alloc<N, D, D> {
 ///
 /// * [`look_at_lh`](fn.look_at_lh.html)
 /// * [`look_at_rh`](fn.look_at_rh.html)
-pub fn look_at<N: Real>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
+pub fn look_at<N: RealField>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
     look_at_rh(eye, center, up)
 }
 
@@ -37,7 +37,7 @@ pub fn look_at<N: Real>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMa
 ///
 /// * [`look_at`](fn.look_at.html)
 /// * [`look_at_rh`](fn.look_at_rh.html)
-pub fn look_at_lh<N: Real>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
+pub fn look_at_lh<N: RealField>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
     TMat::look_at_lh(&Point3::from(*eye), &Point3::from(*center), up)
 }
 
@@ -53,7 +53,7 @@ pub fn look_at_lh<N: Real>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) ->
 ///
 /// * [`look_at`](fn.look_at.html)
 /// * [`look_at_lh`](fn.look_at_lh.html)
-pub fn look_at_rh<N: Real>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
+pub fn look_at_rh<N: RealField>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
     TMat::look_at_rh(&Point3::from(*eye), &Point3::from(*center), up)
 }
 
@@ -72,7 +72,7 @@ pub fn look_at_rh<N: Real>(eye: &TVec3<N>, center: &TVec3<N>, up: &TVec3<N>) ->
 /// * [`rotate_z`](fn.rotate_z.html)
 /// * [`scale`](fn.scale.html)
 /// * [`translate`](fn.translate.html)
-pub fn rotate<N: Real>(m: &TMat4<N>, angle: N, axis: &TVec3<N>) -> TMat4<N> {
+pub fn rotate<N: RealField>(m: &TMat4<N>, angle: N, axis: &TVec3<N>) -> TMat4<N> {
     m * Rotation3::from_axis_angle(&Unit::new_normalize(*axis), angle).to_homogeneous()
 }
 
@@ -90,7 +90,7 @@ pub fn rotate<N: Real>(m: &TMat4<N>, angle: N, axis: &TVec3<N>) -> TMat4<N> {
 /// * [`rotate_z`](fn.rotate_z.html)
 /// * [`scale`](fn.scale.html)
 /// * [`translate`](fn.translate.html)
-pub fn rotate_x<N: Real>(m: &TMat4<N>, angle: N) -> TMat4<N> {
+pub fn rotate_x<N: RealField>(m: &TMat4<N>, angle: N) -> TMat4<N> {
     rotate(m, angle, &TVec::x())
 }
 
@@ -108,7 +108,7 @@ pub fn rotate_x<N: Real>(m: &TMat4<N>, angle: N) -> TMat4<N> {
 /// * [`rotate_z`](fn.rotate_z.html)
 /// * [`scale`](fn.scale.html)
 /// * [`translate`](fn.translate.html)
-pub fn rotate_y<N: Real>(m: &TMat4<N>, angle: N) -> TMat4<N> {
+pub fn rotate_y<N: RealField>(m: &TMat4<N>, angle: N) -> TMat4<N> {
     rotate(m, angle, &TVec::y())
 }
 
@@ -126,7 +126,7 @@ pub fn rotate_y<N: Real>(m: &TMat4<N>, angle: N) -> TMat4<N> {
 /// * [`rotate_y`](fn.rotate_y.html)
 /// * [`scale`](fn.scale.html)
 /// * [`translate`](fn.translate.html)
-pub fn rotate_z<N: Real>(m: &TMat4<N>, angle: N) -> TMat4<N> {
+pub fn rotate_z<N: RealField>(m: &TMat4<N>, angle: N) -> TMat4<N> {
     rotate(m, angle, &TVec::z())
 }
 
diff --git a/nalgebra-glm/src/ext/quaternion_common.rs b/nalgebra-glm/src/ext/quaternion_common.rs
index 3a91d0c7c..072b57e21 100644
--- a/nalgebra-glm/src/ext/quaternion_common.rs
+++ b/nalgebra-glm/src/ext/quaternion_common.rs
@@ -1,36 +1,36 @@
-use na::{self, Real, Unit};
+use na::{self, RealField, Unit};
 
-use aliases::Qua;
+use crate::aliases::Qua;
 
 /// The conjugate of `q`.
-pub fn quat_conjugate<N: Real>(q: &Qua<N>) -> Qua<N> {
+pub fn quat_conjugate<N: RealField>(q: &Qua<N>) -> Qua<N> {
     q.conjugate()
 }
 
 /// The inverse of `q`.
-pub fn quat_inverse<N: Real>(q: &Qua<N>) -> Qua<N> {
+pub fn quat_inverse<N: RealField>(q: &Qua<N>) -> Qua<N> {
     q.try_inverse().unwrap_or_else(na::zero)
 }
 
-//pub fn quat_isinf<N: Real>(x: &Qua<N>) -> TVec<bool, U4> {
+//pub fn quat_isinf<N: RealField>(x: &Qua<N>) -> TVec<bool, U4> {
 //    x.coords.map(|e| e.is_inf())
 //}
 
-//pub fn quat_isnan<N: Real>(x: &Qua<N>) -> TVec<bool, U4> {
+//pub fn quat_isnan<N: RealField>(x: &Qua<N>) -> TVec<bool, U4> {
 //    x.coords.map(|e| e.is_nan())
 //}
 
 /// Interpolate linearly between `x` and `y`.
-pub fn quat_lerp<N: Real>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
+pub fn quat_lerp<N: RealField>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
     x.lerp(y, a)
 }
 
-//pub fn quat_mix<N: Real>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
+//pub fn quat_mix<N: RealField>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
 //    x * (N::one() - a) + y * a
 //}
 
 /// Interpolate spherically between `x` and `y`.
-pub fn quat_slerp<N: Real>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
+pub fn quat_slerp<N: RealField>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
     Unit::new_normalize(*x)
         .slerp(&Unit::new_normalize(*y), a)
         .into_inner()
diff --git a/nalgebra-glm/src/ext/quaternion_geometric.rs b/nalgebra-glm/src/ext/quaternion_geometric.rs
index a67de587f..24d9310de 100644
--- a/nalgebra-glm/src/ext/quaternion_geometric.rs
+++ b/nalgebra-glm/src/ext/quaternion_geometric.rs
@@ -1,28 +1,28 @@
-use na::Real;
+use na::RealField;
 
-use aliases::Qua;
+use crate::aliases::Qua;
 
 /// Multiplies two quaternions.
-pub fn quat_cross<N: Real>(q1: &Qua<N>, q2: &Qua<N>) -> Qua<N> {
+pub fn quat_cross<N: RealField>(q1: &Qua<N>, q2: &Qua<N>) -> Qua<N> {
     q1 * q2
 }
 
 /// The scalar product of two quaternions.
-pub fn quat_dot<N: Real>(x: &Qua<N>, y: &Qua<N>) -> N {
+pub fn quat_dot<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> N {
     x.dot(y)
 }
 
 /// The magnitude of the quaternion `q`.
-pub fn quat_length<N: Real>(q: &Qua<N>) -> N {
+pub fn quat_length<N: RealField>(q: &Qua<N>) -> N {
     q.norm()
 }
 
 /// The magnitude of the quaternion `q`.
-pub fn quat_magnitude<N: Real>(q: &Qua<N>) -> N {
+pub fn quat_magnitude<N: RealField>(q: &Qua<N>) -> N {
     q.norm()
 }
 
 /// Normalizes the quaternion `q`.
-pub fn quat_normalize<N: Real>(q: &Qua<N>) -> Qua<N> {
+pub fn quat_normalize<N: RealField>(q: &Qua<N>) -> Qua<N> {
     q.normalize()
 }
diff --git a/nalgebra-glm/src/ext/quaternion_relational.rs b/nalgebra-glm/src/ext/quaternion_relational.rs
index e459054fb..bd24edbe7 100644
--- a/nalgebra-glm/src/ext/quaternion_relational.rs
+++ b/nalgebra-glm/src/ext/quaternion_relational.rs
@@ -1,23 +1,23 @@
-use na::{Real, U4};
+use na::{RealField, U4};
 
-use aliases::{Qua, TVec};
+use crate::aliases::{Qua, TVec};
 
 /// Component-wise equality comparison between two quaternions.
-pub fn quat_equal<N: Real>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
-    ::equal(&x.coords, &y.coords)
+pub fn quat_equal<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+    crate::equal(&x.coords, &y.coords)
 }
 
 /// Component-wise approximate equality comparison between two quaternions.
-pub fn quat_equal_eps<N: Real>(x: &Qua<N>, y: &Qua<N>, epsilon: N) -> TVec<bool, U4> {
-    ::equal_eps(&x.coords, &y.coords, epsilon)
+pub fn quat_equal_eps<N: RealField>(x: &Qua<N>, y: &Qua<N>, epsilon: N) -> TVec<bool, U4> {
+    crate::equal_eps(&x.coords, &y.coords, epsilon)
 }
 
 /// Component-wise non-equality comparison between two quaternions.
-pub fn quat_not_equal<N: Real>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
-    ::not_equal(&x.coords, &y.coords)
+pub fn quat_not_equal<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+    crate::not_equal(&x.coords, &y.coords)
 }
 
 /// Component-wise approximate non-equality comparison between two quaternions.
-pub fn quat_not_equal_eps<N: Real>(x: &Qua<N>, y: &Qua<N>, epsilon: N) -> TVec<bool, U4> {
-    ::not_equal_eps(&x.coords, &y.coords, epsilon)
+pub fn quat_not_equal_eps<N: RealField>(x: &Qua<N>, y: &Qua<N>, epsilon: N) -> TVec<bool, U4> {
+    crate::not_equal_eps(&x.coords, &y.coords, epsilon)
 }
diff --git a/nalgebra-glm/src/ext/quaternion_transform.rs b/nalgebra-glm/src/ext/quaternion_transform.rs
index a4a60210f..1e4e97713 100644
--- a/nalgebra-glm/src/ext/quaternion_transform.rs
+++ b/nalgebra-glm/src/ext/quaternion_transform.rs
@@ -1,27 +1,27 @@
-use na::{Real, Unit, UnitQuaternion};
+use na::{RealField, Unit, UnitQuaternion};
 
-use aliases::{Qua, TVec3};
+use crate::aliases::{Qua, TVec3};
 
 /// Computes the quaternion exponential.
-pub fn quat_exp<N: Real>(q: &Qua<N>) -> Qua<N> {
+pub fn quat_exp<N: RealField>(q: &Qua<N>) -> Qua<N> {
     q.exp()
 }
 
 /// Computes the quaternion logarithm.
-pub fn quat_log<N: Real>(q: &Qua<N>) -> Qua<N> {
+pub fn quat_log<N: RealField>(q: &Qua<N>) -> Qua<N> {
     q.ln()
 }
 
 /// Raises the quaternion `q` to the power `y`.
-pub fn quat_pow<N: Real>(q: &Qua<N>, y: N) -> Qua<N> {
+pub fn quat_pow<N: RealField>(q: &Qua<N>, y: N) -> Qua<N> {
     q.powf(y)
 }
 
 /// Builds a quaternion from an axis and an angle, and right-multiply it to the quaternion `q`.
-pub fn quat_rotate<N: Real>(q: &Qua<N>, angle: N, axis: &TVec3<N>) -> Qua<N> {
+pub fn quat_rotate<N: RealField>(q: &Qua<N>, angle: N, axis: &TVec3<N>) -> Qua<N> {
     q * UnitQuaternion::from_axis_angle(&Unit::new_normalize(*axis), angle).into_inner()
 }
 
-//pub fn quat_sqrt<N: Real>(q: &Qua<N>) -> Qua<N> {
+//pub fn quat_sqrt<N: RealField>(q: &Qua<N>) -> Qua<N> {
 //    unimplemented!()
 //}
diff --git a/nalgebra-glm/src/ext/quaternion_trigonometric.rs b/nalgebra-glm/src/ext/quaternion_trigonometric.rs
index 762bd9e97..a711e69ac 100644
--- a/nalgebra-glm/src/ext/quaternion_trigonometric.rs
+++ b/nalgebra-glm/src/ext/quaternion_trigonometric.rs
@@ -1,19 +1,19 @@
-use na::{Real, Unit, UnitQuaternion};
+use na::{RealField, Unit, UnitQuaternion};
 
-use aliases::{Qua, TVec3};
+use crate::aliases::{Qua, TVec3};
 
 /// The rotation angle of this quaternion assumed to be normalized.
-pub fn quat_angle<N: Real>(x: &Qua<N>) -> N {
+pub fn quat_angle<N: RealField>(x: &Qua<N>) -> N {
     UnitQuaternion::from_quaternion(*x).angle()
 }
 
 /// Creates a quaternion from an axis and an angle.
-pub fn quat_angle_axis<N: Real>(angle: N, axis: &TVec3<N>) -> Qua<N> {
+pub fn quat_angle_axis<N: RealField>(angle: N, axis: &TVec3<N>) -> Qua<N> {
     UnitQuaternion::from_axis_angle(&Unit::new_normalize(*axis), angle).into_inner()
 }
 
 /// The rotation axis of a quaternion assumed to be normalized.
-pub fn quat_axis<N: Real>(x: &Qua<N>) -> TVec3<N> {
+pub fn quat_axis<N: RealField>(x: &Qua<N>) -> TVec3<N> {
     if let Some(a) = UnitQuaternion::from_quaternion(*x).axis() {
         a.into_inner()
     } else {
diff --git a/nalgebra-glm/src/ext/scalar_common.rs b/nalgebra-glm/src/ext/scalar_common.rs
index 48d3255de..11104ce2d 100644
--- a/nalgebra-glm/src/ext/scalar_common.rs
+++ b/nalgebra-glm/src/ext/scalar_common.rs
@@ -1,6 +1,6 @@
 use na;
 
-use traits::Number;
+use crate::traits::Number;
 
 /// Returns the maximum among three values.
 ///
diff --git a/nalgebra-glm/src/ext/scalar_constants.rs b/nalgebra-glm/src/ext/scalar_constants.rs
index 2b9ed14dd..e0741465f 100644
--- a/nalgebra-glm/src/ext/scalar_constants.rs
+++ b/nalgebra-glm/src/ext/scalar_constants.rs
@@ -1,5 +1,5 @@
 use approx::AbsDiffEq;
-use na::Real;
+use na::RealField;
 
 /// Default epsilon value used for approximate comparison.
 pub fn epsilon<N: AbsDiffEq<Epsilon = N>>() -> N {
@@ -22,6 +22,6 @@ pub fn epsilon<N: AbsDiffEq<Epsilon = N>>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn pi<N: Real>() -> N {
+pub fn pi<N: RealField>() -> N {
     N::pi()
 }
diff --git a/nalgebra-glm/src/ext/vector_common.rs b/nalgebra-glm/src/ext/vector_common.rs
index c0318067e..a6418ef86 100644
--- a/nalgebra-glm/src/ext/vector_common.rs
+++ b/nalgebra-glm/src/ext/vector_common.rs
@@ -1,7 +1,7 @@
 use na::{self, DefaultAllocator};
 
-use aliases::TVec;
-use traits::{Alloc, Dimension, Number};
+use crate::aliases::TVec;
+use crate::traits::{Alloc, Dimension, Number};
 
 /// Component-wise maximum between a vector and a scalar.
 ///
diff --git a/nalgebra-glm/src/ext/vector_relational.rs b/nalgebra-glm/src/ext/vector_relational.rs
index ee418588f..a50713361 100644
--- a/nalgebra-glm/src/ext/vector_relational.rs
+++ b/nalgebra-glm/src/ext/vector_relational.rs
@@ -1,7 +1,7 @@
 use na::DefaultAllocator;
 
-use aliases::TVec;
-use traits::{Alloc, Dimension, Number};
+use crate::aliases::TVec;
+use crate::traits::{Alloc, Dimension, Number};
 
 /// Component-wise approximate equality of two vectors, using a scalar epsilon.
 ///
diff --git a/nalgebra-glm/src/geometric.rs b/nalgebra-glm/src/geometric.rs
index 998709d66..ffdc825ae 100644
--- a/nalgebra-glm/src/geometric.rs
+++ b/nalgebra-glm/src/geometric.rs
@@ -1,7 +1,7 @@
-use na::{DefaultAllocator, Real};
+use na::{DefaultAllocator, RealField};
 
-use aliases::{TVec, TVec3};
-use traits::{Alloc, Dimension, Number};
+use crate::aliases::{TVec, TVec3};
+use crate::traits::{Alloc, Dimension, Number};
 
 /// The cross product of two vectors.
 pub fn cross<N: Number, D: Dimension>(x: &TVec3<N>, y: &TVec3<N>) -> TVec3<N> {
@@ -13,7 +13,7 @@ pub fn cross<N: Number, D: Dimension>(x: &TVec3<N>, y: &TVec3<N>) -> TVec3<N> {
 /// # See also:
 ///
 /// * [`distance2`](fn.distance2.html)
-pub fn distance<N: Real, D: Dimension>(p0: &TVec<N, D>, p1: &TVec<N, D>) -> N
+pub fn distance<N: RealField, D: Dimension>(p0: &TVec<N, D>, p1: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     (p1 - p0).norm()
 }
@@ -49,7 +49,7 @@ where
 /// * [`length2`](fn.length2.html)
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`magnitude2`](fn.magnitude2.html)
-pub fn length<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
+pub fn length<N: RealField, D: Dimension>(x: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     x.norm()
 }
@@ -63,13 +63,13 @@ where DefaultAllocator: Alloc<N, D> {
 /// * [`length`](fn.length.html)
 /// * [`magnitude2`](fn.magnitude2.html)
 /// * [`nalgebra::norm`](../nalgebra/fn.norm.html)
-pub fn magnitude<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
+pub fn magnitude<N: RealField, D: Dimension>(x: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     x.norm()
 }
 
 /// Normalizes a vector.
-pub fn normalize<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
+pub fn normalize<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     x.normalize()
 }
@@ -82,7 +82,7 @@ where DefaultAllocator: Alloc<N, D> {
 }
 
 /// For the incident vector `i` and surface normal `n`, and the ratio of indices of refraction `eta`, return the refraction vector.
-pub fn refract_vec<N: Real, D: Dimension>(i: &TVec<N, D>, n: &TVec<N, D>, eta: N) -> TVec<N, D>
+pub fn refract_vec<N: RealField, D: Dimension>(i: &TVec<N, D>, n: &TVec<N, D>, eta: N) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     let ni = n.dot(i);
     let k = N::one() - eta * eta * (N::one() - ni * ni);
diff --git a/nalgebra-glm/src/gtc/bitfield.rs b/nalgebra-glm/src/gtc/bitfield.rs
index 65fbcce05..bdf18552d 100644
--- a/nalgebra-glm/src/gtc/bitfield.rs
+++ b/nalgebra-glm/src/gtc/bitfield.rs
@@ -1,7 +1,7 @@
 use na::{Scalar, DefaultAllocator};
 
-use traits::{Alloc, Dimension};
-use aliases::*;
+use crate::traits::{Alloc, Dimension};
+use crate::aliases::*;
 
 pub fn bitfieldDeinterleave(x: u16) -> U8Vec2 {
     unimplemented!()
diff --git a/nalgebra-glm/src/gtc/constants.rs b/nalgebra-glm/src/gtc/constants.rs
index 5e2e1b0d2..4112d65e7 100644
--- a/nalgebra-glm/src/gtc/constants.rs
+++ b/nalgebra-glm/src/gtc/constants.rs
@@ -1,14 +1,14 @@
-use na::{self, Real};
+use na::{self, RealField};
 
 /// The Euler constant.
 ///
 /// This is a shorthand alias for [`euler`](fn.euler.html).
-pub fn e<N: Real>() -> N {
+pub fn e<N: RealField>() -> N {
     N::e()
 }
 
 /// The Euler constant.
-pub fn euler<N: Real>() -> N {
+pub fn euler<N: RealField>() -> N {
     N::e()
 }
 
@@ -28,12 +28,12 @@ pub fn euler<N: Real>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn four_over_pi<N: Real>() -> N {
+pub fn four_over_pi<N: RealField>() -> N {
     na::convert::<_, N>(4.0) / N::pi()
 }
 
 /// Returns the golden ratio.
-pub fn golden_ratio<N: Real>() -> N {
+pub fn golden_ratio<N: RealField>() -> N {
     (N::one() + root_five()) / na::convert(2.0)
 }
 
@@ -53,7 +53,7 @@ pub fn golden_ratio<N: Real>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn half_pi<N: Real>() -> N {
+pub fn half_pi<N: RealField>() -> N {
     N::frac_pi_2()
 }
 
@@ -63,7 +63,7 @@ pub fn half_pi<N: Real>() -> N {
 ///
 /// * [`ln_ten`](fn.ln_ten.html)
 /// * [`ln_two`](fn.ln_two.html)
-pub fn ln_ln_two<N: Real>() -> N {
+pub fn ln_ln_two<N: RealField>() -> N {
     N::ln_2().ln()
 }
 
@@ -73,7 +73,7 @@ pub fn ln_ln_two<N: Real>() -> N {
 ///
 /// * [`ln_ln_two`](fn.ln_ln_two.html)
 /// * [`ln_two`](fn.ln_two.html)
-pub fn ln_ten<N: Real>() -> N {
+pub fn ln_ten<N: RealField>() -> N {
     N::ln_10()
 }
 
@@ -83,7 +83,7 @@ pub fn ln_ten<N: Real>() -> N {
 ///
 /// * [`ln_ln_two`](fn.ln_ln_two.html)
 /// * [`ln_ten`](fn.ln_ten.html)
-pub fn ln_two<N: Real>() -> N {
+pub fn ln_two<N: RealField>() -> N {
     N::ln_2()
 }
 
@@ -106,12 +106,12 @@ pub use na::one;
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn one_over_pi<N: Real>() -> N {
+pub fn one_over_pi<N: RealField>() -> N {
     N::frac_1_pi()
 }
 
 /// Returns `1 / sqrt(2)`.
-pub fn one_over_root_two<N: Real>() -> N {
+pub fn one_over_root_two<N: RealField>() -> N {
     N::one() / root_two()
 }
 
@@ -131,7 +131,7 @@ pub fn one_over_root_two<N: Real>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn one_over_two_pi<N: Real>() -> N {
+pub fn one_over_two_pi<N: RealField>() -> N {
     N::frac_1_pi() * na::convert(0.5)
 }
 
@@ -151,7 +151,7 @@ pub fn one_over_two_pi<N: Real>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn quarter_pi<N: Real>() -> N {
+pub fn quarter_pi<N: RealField>() -> N {
     N::frac_pi_4()
 }
 
@@ -161,7 +161,7 @@ pub fn quarter_pi<N: Real>() -> N {
 ///
 /// * [`root_three`](fn.root_three.html)
 /// * [`root_two`](fn.root_two.html)
-pub fn root_five<N: Real>() -> N {
+pub fn root_five<N: RealField>() -> N {
     na::convert::<_, N>(5.0).sqrt()
 }
 
@@ -181,12 +181,12 @@ pub fn root_five<N: Real>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn root_half_pi<N: Real>() -> N {
+pub fn root_half_pi<N: RealField>() -> N {
     (N::pi() / na::convert(2.0)).sqrt()
 }
 
 /// Returns `sqrt(ln(4))`.
-pub fn root_ln_four<N: Real>() -> N {
+pub fn root_ln_four<N: RealField>() -> N {
     na::convert::<_, N>(4.0).ln().sqrt()
 }
 
@@ -206,7 +206,7 @@ pub fn root_ln_four<N: Real>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn root_pi<N: Real>() -> N {
+pub fn root_pi<N: RealField>() -> N {
     N::pi().sqrt()
 }
 
@@ -216,7 +216,7 @@ pub fn root_pi<N: Real>() -> N {
 ///
 /// * [`root_five`](fn.root_five.html)
 /// * [`root_two`](fn.root_two.html)
-pub fn root_three<N: Real>() -> N {
+pub fn root_three<N: RealField>() -> N {
     na::convert::<_, N>(3.0).sqrt()
 }
 
@@ -226,8 +226,8 @@ pub fn root_three<N: Real>() -> N {
 ///
 /// * [`root_five`](fn.root_five.html)
 /// * [`root_three`](fn.root_three.html)
-pub fn root_two<N: Real>() -> N {
-    // FIXME: there should be a ::sqrt_2() on the Real trait.
+pub fn root_two<N: RealField>() -> N {
+    // FIXME: there should be a crate::sqrt_2() on the RealField trait.
     na::convert::<_, N>(2.0).sqrt()
 }
 
@@ -247,7 +247,7 @@ pub fn root_two<N: Real>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn root_two_pi<N: Real>() -> N {
+pub fn root_two_pi<N: RealField>() -> N {
     N::two_pi().sqrt()
 }
 
@@ -256,7 +256,7 @@ pub fn root_two_pi<N: Real>() -> N {
 /// # See also:
 ///
 /// * [`two_thirds`](fn.two_thirds.html)
-pub fn third<N: Real>() -> N {
+pub fn third<N: RealField>() -> N {
     na::convert(1.0 / 3.0)
 }
 
@@ -276,7 +276,7 @@ pub fn third<N: Real>() -> N {
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn three_over_two_pi<N: Real>() -> N {
+pub fn three_over_two_pi<N: RealField>() -> N {
     na::convert::<_, N>(3.0) / N::two_pi()
 }
 
@@ -295,7 +295,7 @@ pub fn three_over_two_pi<N: Real>() -> N {
 /// * [`three_over_two_pi`](fn.three_over_two_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn two_over_pi<N: Real>() -> N {
+pub fn two_over_pi<N: RealField>() -> N {
     N::frac_2_pi()
 }
 
@@ -315,7 +315,7 @@ pub fn two_over_pi<N: Real>() -> N {
 /// * [`three_over_two_pi`](fn.three_over_two_pi.html)
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_pi`](fn.two_pi.html)
-pub fn two_over_root_pi<N: Real>() -> N {
+pub fn two_over_root_pi<N: RealField>() -> N {
     N::frac_2_sqrt_pi()
 }
 
@@ -335,7 +335,7 @@ pub fn two_over_root_pi<N: Real>() -> N {
 /// * [`three_over_two_pi`](fn.three_over_two_pi.html)
 /// * [`two_over_pi`](fn.two_over_pi.html)
 /// * [`two_over_root_pi`](fn.two_over_root_pi.html)
-pub fn two_pi<N: Real>() -> N {
+pub fn two_pi<N: RealField>() -> N {
     N::two_pi()
 }
 
@@ -344,7 +344,7 @@ pub fn two_pi<N: Real>() -> N {
 /// # See also:
 ///
 /// * [`third`](fn.third.html)
-pub fn two_thirds<N: Real>() -> N {
+pub fn two_thirds<N: RealField>() -> N {
     na::convert(2.0 / 3.0)
 }
 
diff --git a/nalgebra-glm/src/gtc/epsilon.rs b/nalgebra-glm/src/gtc/epsilon.rs
index 4fd7138a7..81ac2e6c9 100644
--- a/nalgebra-glm/src/gtc/epsilon.rs
+++ b/nalgebra-glm/src/gtc/epsilon.rs
@@ -4,8 +4,8 @@
 use approx::AbsDiffEq;
 use na::DefaultAllocator;
 
-use traits::{Alloc, Number, Dimension};
-use aliases::TVec;
+use crate::traits::{Alloc, Number, Dimension};
+use crate::aliases::TVec;
 
 /// Component-wise approximate equality beween two vectors.
 pub fn epsilon_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, epsilon: N) -> TVec<bool, D>
diff --git a/nalgebra-glm/src/gtc/integer.rs b/nalgebra-glm/src/gtc/integer.rs
index df65843fd..a972a4ab8 100644
--- a/nalgebra-glm/src/gtc/integer.rs
+++ b/nalgebra-glm/src/gtc/integer.rs
@@ -1,7 +1,7 @@
 //use na::{Scalar, DefaultAllocator};
 //
-//use traits::{Alloc, Dimension};
-//use aliases::TVec;
+//use crate::traits::{Alloc, Dimension};
+//use crate::aliases::TVec;
 
 //pub fn iround<N: Scalar, D: Dimension>(x: &TVec<N, D>) -> TVec<i32, D>
 //    where DefaultAllocator: Alloc<N, D> {
diff --git a/nalgebra-glm/src/gtc/matrix_access.rs b/nalgebra-glm/src/gtc/matrix_access.rs
index 3eabf5e26..f61d97821 100644
--- a/nalgebra-glm/src/gtc/matrix_access.rs
+++ b/nalgebra-glm/src/gtc/matrix_access.rs
@@ -1,7 +1,7 @@
 use na::{DefaultAllocator, Scalar};
 
-use aliases::{TMat, TVec};
-use traits::{Alloc, Dimension};
+use crate::aliases::{TMat, TVec};
+use crate::traits::{Alloc, Dimension};
 
 /// The `index`-th column of the matrix `m`.
 ///
diff --git a/nalgebra-glm/src/gtc/matrix_inverse.rs b/nalgebra-glm/src/gtc/matrix_inverse.rs
index 4fc305e07..eab0b995b 100644
--- a/nalgebra-glm/src/gtc/matrix_inverse.rs
+++ b/nalgebra-glm/src/gtc/matrix_inverse.rs
@@ -1,17 +1,17 @@
-use na::{DefaultAllocator, Real};
+use na::{DefaultAllocator, RealField};
 
-use aliases::TMat;
-use traits::{Alloc, Dimension};
+use crate::aliases::TMat;
+use crate::traits::{Alloc, Dimension};
 
 /// Fast matrix inverse for affine matrix.
-pub fn affine_inverse<N: Real, D: Dimension>(m: TMat<N, D, D>) -> TMat<N, D, D>
+pub fn affine_inverse<N: RealField, D: Dimension>(m: TMat<N, D, D>) -> TMat<N, D, D>
 where DefaultAllocator: Alloc<N, D, D> {
     // FIXME: this should be optimized.
     m.try_inverse().unwrap_or_else(TMat::<_, D, D>::zeros)
 }
 
 /// Compute the transpose of the inverse of a matrix.
-pub fn inverse_transpose<N: Real, D: Dimension>(m: TMat<N, D, D>) -> TMat<N, D, D>
+pub fn inverse_transpose<N: RealField, D: Dimension>(m: TMat<N, D, D>) -> TMat<N, D, D>
 where DefaultAllocator: Alloc<N, D, D> {
     m.try_inverse()
         .unwrap_or_else(TMat::<_, D, D>::zeros)
diff --git a/nalgebra-glm/src/gtc/packing.rs b/nalgebra-glm/src/gtc/packing.rs
index b02612398..ea5acac45 100644
--- a/nalgebra-glm/src/gtc/packing.rs
+++ b/nalgebra-glm/src/gtc/packing.rs
@@ -1,7 +1,7 @@
-use na::{Scalar, Real, DefaultAllocator, U3, U4};
+use na::{Scalar, RealField, DefaultAllocator, U3, U4};
 
-use traits::{Alloc, Dimension};
-use aliases::*;
+use crate::traits::{Alloc, Dimension};
+use crate::aliases::*;
 
 
 pub fn packF2x11_1x10(v: &Vec3) -> i32 {
@@ -53,7 +53,7 @@ pub fn packRGBM<N: Scalar>(rgb: &TVec3<N>) -> TVec4<N> {
     unimplemented!()
 }
 
-pub fn packSnorm<I: Scalar, N: Real, D: Dimension>(v: TVec<N, D>) -> TVec<I, D>
+pub fn packSnorm<I: Scalar, N: RealField, D: Dimension>(v: TVec<N, D>) -> TVec<I, D>
     where DefaultAllocator: Alloc<N, D> + Alloc<I, D> {
     unimplemented!()
 }
@@ -102,7 +102,7 @@ pub fn packUint4x8(v: &U8Vec4) -> i32 {
     unimplemented!()
 }
 
-pub fn packUnorm<UI: Scalar, N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<UI, D>
+pub fn packUnorm<UI: Scalar, N: RealField, D: Dimension>(v: &TVec<N, D>) -> TVec<UI, D>
     where DefaultAllocator: Alloc<N, D> + Alloc<UI, D> {
     unimplemented!()
 }
@@ -196,7 +196,7 @@ pub fn unpackRGBM<N: Scalar>(rgbm: &TVec4<N>) -> TVec3<N> {
     unimplemented!()
 }
 
-pub fn unpackSnorm<I: Scalar, N: Real, D: Dimension>(v: &TVec<I, D>) -> TVec<N, D>
+pub fn unpackSnorm<I: Scalar, N: RealField, D: Dimension>(v: &TVec<I, D>) -> TVec<N, D>
     where DefaultAllocator: Alloc<N, D> + Alloc<I, D> {
     unimplemented!()
 }
@@ -245,7 +245,7 @@ pub fn unpackUint4x8(p: i32) -> U8Vec4 {
     unimplemented!()
 }
 
-pub fn unpackUnorm<UI: Scalar, N: Real, D: Dimension>(v: &TVec<UI, D>) -> TVec<N, D>
+pub fn unpackUnorm<UI: Scalar, N: RealField, D: Dimension>(v: &TVec<UI, D>) -> TVec<N, D>
     where DefaultAllocator: Alloc<N, D> + Alloc<UI, D> {
     unimplemented!()
 }
diff --git a/nalgebra-glm/src/gtc/quaternion.rs b/nalgebra-glm/src/gtc/quaternion.rs
index d31a0bcbb..36977e96c 100644
--- a/nalgebra-glm/src/gtc/quaternion.rs
+++ b/nalgebra-glm/src/gtc/quaternion.rs
@@ -1,37 +1,37 @@
-use na::{Real, UnitQuaternion, U4};
+use na::{RealField, UnitQuaternion, U4};
 
-use aliases::{Qua, TMat4, TVec, TVec3};
+use crate::aliases::{Qua, TMat4, TVec, TVec3};
 
 /// Euler angles of the quaternion `q` as (pitch, yaw, roll).
-pub fn quat_euler_angles<N: Real>(x: &Qua<N>) -> TVec3<N> {
+pub fn quat_euler_angles<N: RealField>(x: &Qua<N>) -> TVec3<N> {
     let q = UnitQuaternion::new_unchecked(*x);
     let a = q.euler_angles();
     TVec3::new(a.2, a.1, a.0)
 }
 
 /// Component-wise `>` comparison between two quaternions.
-pub fn quat_greater_than<N: Real>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
-    ::greater_than(&x.coords, &y.coords)
+pub fn quat_greater_than<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+    crate::greater_than(&x.coords, &y.coords)
 }
 
 /// Component-wise `>=` comparison between two quaternions.
-pub fn quat_greater_than_equal<N: Real>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
-    ::greater_than_equal(&x.coords, &y.coords)
+pub fn quat_greater_than_equal<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+    crate::greater_than_equal(&x.coords, &y.coords)
 }
 
 /// Component-wise `<` comparison between two quaternions.
-pub fn quat_less_than<N: Real>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
-    ::less_than(&x.coords, &y.coords)
+pub fn quat_less_than<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+    crate::less_than(&x.coords, &y.coords)
 }
 
 /// Component-wise `<=` comparison between two quaternions.
-pub fn quat_less_than_equal<N: Real>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
-    ::less_than_equal(&x.coords, &y.coords)
+pub fn quat_less_than_equal<N: RealField>(x: &Qua<N>, y: &Qua<N>) -> TVec<bool, U4> {
+    crate::less_than_equal(&x.coords, &y.coords)
 }
 
 /// Convert a quaternion to a rotation matrix in homogeneous coordinates.
-pub fn quat_cast<N: Real>(x: &Qua<N>) -> TMat4<N> {
-    ::quat_to_mat4(x)
+pub fn quat_cast<N: RealField>(x: &Qua<N>) -> TMat4<N> {
+    crate::quat_to_mat4(x)
 }
 
 /// Computes a right hand look-at quaternion
@@ -41,34 +41,34 @@ pub fn quat_cast<N: Real>(x: &Qua<N>) -> TMat4<N> {
 /// * `direction` - Direction vector point at where to look
 /// * `up` - Object up vector
 ///
-pub fn quat_look_at<N: Real>(direction: &TVec3<N>, up: &TVec3<N>) -> Qua<N> {
+pub fn quat_look_at<N: RealField>(direction: &TVec3<N>, up: &TVec3<N>) -> Qua<N> {
     quat_look_at_rh(direction, up)
 }
 
 /// Computes a left-handed look-at quaternion (equivalent to a left-handed look-at matrix).
-pub fn quat_look_at_lh<N: Real>(direction: &TVec3<N>, up: &TVec3<N>) -> Qua<N> {
+pub fn quat_look_at_lh<N: RealField>(direction: &TVec3<N>, up: &TVec3<N>) -> Qua<N> {
     UnitQuaternion::look_at_lh(direction, up).into_inner()
 }
 
 /// Computes a right-handed look-at quaternion (equivalent to a right-handed look-at matrix).
-pub fn quat_look_at_rh<N: Real>(direction: &TVec3<N>, up: &TVec3<N>) -> Qua<N> {
+pub fn quat_look_at_rh<N: RealField>(direction: &TVec3<N>, up: &TVec3<N>) -> Qua<N> {
     UnitQuaternion::look_at_rh(direction, up).into_inner()
 }
 
 /// The "roll" Euler angle of the quaternion `x` assumed to be normalized.
-pub fn quat_roll<N: Real>(x: &Qua<N>) -> N {
+pub fn quat_roll<N: RealField>(x: &Qua<N>) -> N {
     // FIXME: optimize this.
     quat_euler_angles(x).z
 }
 
 /// The "yaw" Euler angle of the quaternion `x` assumed to be normalized.
-pub fn quat_yaw<N: Real>(x: &Qua<N>) -> N {
+pub fn quat_yaw<N: RealField>(x: &Qua<N>) -> N {
     // FIXME: optimize this.
     quat_euler_angles(x).y
 }
 
 /// The "pitch" Euler angle of the quaternion `x` assumed to be normalized.
-pub fn quat_pitch<N: Real>(x: &Qua<N>) -> N {
+pub fn quat_pitch<N: RealField>(x: &Qua<N>) -> N {
     // FIXME: optimize this.
     quat_euler_angles(x).x
 }
diff --git a/nalgebra-glm/src/gtc/round.rs b/nalgebra-glm/src/gtc/round.rs
index 75bd44623..5ad95780b 100644
--- a/nalgebra-glm/src/gtc/round.rs
+++ b/nalgebra-glm/src/gtc/round.rs
@@ -1,7 +1,7 @@
-use na::{Scalar, Real, U3, DefaultAllocator};
+use na::{Scalar, RealField, U3, DefaultAllocator};
 
-use traits::{Number, Alloc, Dimension};
-use aliases::TVec;
+use crate::traits::{Number, Alloc, Dimension};
+use crate::aliases::TVec;
 
 
 pub fn ceilMultiple<T>(v: T, Multiple: T) -> T {
diff --git a/nalgebra-glm/src/gtc/type_ptr.rs b/nalgebra-glm/src/gtc/type_ptr.rs
index ed901f20b..4029bf01a 100644
--- a/nalgebra-glm/src/gtc/type_ptr.rs
+++ b/nalgebra-glm/src/gtc/type_ptr.rs
@@ -1,10 +1,10 @@
-use na::{DefaultAllocator, Quaternion, Real, Scalar};
+use na::{DefaultAllocator, Quaternion, RealField, Scalar};
 
-use aliases::{
+use crate::aliases::{
     Qua, TMat, TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4, TMat4, TMat4x2, TMat4x3, TVec1,
     TVec2, TVec3, TVec4,
 };
-use traits::{Alloc, Dimension, Number};
+use crate::traits::{Alloc, Dimension, Number};
 
 /// Creates a 2x2 matrix from a slice arranged in column-major order.
 pub fn make_mat2<N: Scalar>(ptr: &[N]) -> TMat2<N> {
@@ -112,7 +112,7 @@ pub fn mat4_to_mat2<N: Scalar>(m: &TMat4<N>) -> TMat2<N> {
 }
 
 /// Creates a quaternion from a slice arranged as `[x, y, z, w]`.
-pub fn make_quat<N: Real>(ptr: &[N]) -> Qua<N> {
+pub fn make_quat<N: RealField>(ptr: &[N]) -> Qua<N> {
     Quaternion::from(TVec4::from_column_slice(ptr))
 }
 
diff --git a/nalgebra-glm/src/gtc/ulp.rs b/nalgebra-glm/src/gtc/ulp.rs
index 860d73be1..8258d0df4 100644
--- a/nalgebra-glm/src/gtc/ulp.rs
+++ b/nalgebra-glm/src/gtc/ulp.rs
@@ -1,6 +1,6 @@
 use na::{Scalar, U2};
 
-use aliases::TVec;
+use crate::aliases::TVec;
 
 
 pub fn float_distance<T>(x: T, y: T) -> u64 {
diff --git a/nalgebra-glm/src/gtx/component_wise.rs b/nalgebra-glm/src/gtx/component_wise.rs
index 338f43800..7c4af7a0a 100644
--- a/nalgebra-glm/src/gtx/component_wise.rs
+++ b/nalgebra-glm/src/gtx/component_wise.rs
@@ -1,7 +1,7 @@
 use na::{self, DefaultAllocator};
 
-use aliases::TMat;
-use traits::{Alloc, Dimension, Number};
+use crate::aliases::TMat;
+use crate::traits::{Alloc, Dimension, Number};
 
 /// The sum of every component of the given matrix or vector.
 ///
diff --git a/nalgebra-glm/src/gtx/euler_angles.rs b/nalgebra-glm/src/gtx/euler_angles.rs
index 2c4940a69..c9d16738f 100644
--- a/nalgebra-glm/src/gtx/euler_angles.rs
+++ b/nalgebra-glm/src/gtx/euler_angles.rs
@@ -1,163 +1,163 @@
-use na::{Real, U3, U4};
+use na::{RealField, U3, U4};
 
-use aliases::{TVec, TMat};
+use crate::aliases::{TVec, TMat};
 
-pub fn derivedEulerAngleX<N: Real>(angleX: N, angularVelocityX: N) -> TMat4<N> {
+pub fn derivedEulerAngleX<N: RealField>(angleX: N, angularVelocityX: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn derivedEulerAngleY<N: Real>(angleY: N, angularVelocityY: N) -> TMat4<N> {
+pub fn derivedEulerAngleY<N: RealField>(angleY: N, angularVelocityY: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn derivedEulerAngleZ<N: Real>(angleZ: N, angularVelocityZ: N) -> TMat4<N> {
+pub fn derivedEulerAngleZ<N: RealField>(angleZ: N, angularVelocityZ: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleX<N: Real>(angleX: N) -> TMat4<N> {
+pub fn eulerAngleX<N: RealField>(angleX: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleXY<N: Real>(angleX: N, angleY: N) -> TMat4<N> {
+pub fn eulerAngleXY<N: RealField>(angleX: N, angleY: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleXYX<N: Real>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleXYX<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleXYZ<N: Real>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleXYZ<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleXZ<N: Real>(angleX: N, angleZ: N) -> TMat4<N> {
+pub fn eulerAngleXZ<N: RealField>(angleX: N, angleZ: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleXZX<N: Real>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleXZX<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleXZY<N: Real>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleXZY<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleY<N: Real>(angleY: N) -> TMat4<N> {
+pub fn eulerAngleY<N: RealField>(angleY: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleYX<N: Real>(angleY: N, angleX: N) -> TMat4<N> {
+pub fn eulerAngleYX<N: RealField>(angleY: N, angleX: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleYXY<N: Real>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleYXY<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleYXZ<N: Real>(yaw: N, pitch: N, roll: N) -> TMat4<N> {
+pub fn eulerAngleYXZ<N: RealField>(yaw: N, pitch: N, roll: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleYZ<N: Real>(angleY: N, angleZ: N) -> TMat4<N> {
+pub fn eulerAngleYZ<N: RealField>(angleY: N, angleZ: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleYZX<N: Real>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleYZX<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleYZY<N: Real>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleYZY<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleZ<N: Real>(angleZ: N) -> TMat4<N> {
+pub fn eulerAngleZ<N: RealField>(angleZ: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleZX<N: Real>(angle: N, angleX: N) -> TMat4<N> {
+pub fn eulerAngleZX<N: RealField>(angle: N, angleX: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleZXY<N: Real>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleZXY<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleZXZ<N: Real>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleZXZ<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleZY<N: Real>(angleZ: N, angleY: N) -> TMat4<N> {
+pub fn eulerAngleZY<N: RealField>(angleZ: N, angleY: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleZYX<N: Real>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleZYX<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn eulerAngleZYZ<N: Real>(t1: N, t2: N, t3: N) -> TMat4<N> {
+pub fn eulerAngleZYZ<N: RealField>(t1: N, t2: N, t3: N) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn extractEulerAngleXYX<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleXYX<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleXYZ<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleXYZ<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleXZX<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleXZX<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleXZY<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleXZY<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleYXY<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleYXY<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleYXZ<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleYXZ<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleYZX<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleYZX<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleYZY<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleYZY<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleZXY<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleZXY<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleZXZ<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleZXZ<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleZYX<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleZYX<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn extractEulerAngleZYZ<N: Real>(M: &TMat4<N>) -> (N, N, N) {
+pub fn extractEulerAngleZYZ<N: RealField>(M: &TMat4<N>) -> (N, N, N) {
     unimplemented!()
 }
 
-pub fn orientate2<N: Real>(angle: N) -> TMat3x3<N> {
+pub fn orientate2<N: RealField>(angle: N) -> TMat3x3<N> {
     unimplemented!()
 }
 
-pub fn orientate3<N: Real>(angles: TVec3<N>) -> TMat3x3<N> {
+pub fn orientate3<N: RealField>(angles: TVec3<N>) -> TMat3x3<N> {
     unimplemented!()
 }
 
-pub fn orientate4<N: Real>(angles: TVec3<N>) -> TMat4<N> {
+pub fn orientate4<N: RealField>(angles: TVec3<N>) -> TMat4<N> {
     unimplemented!()
 }
 
-pub fn yawPitchRoll<N: Real>(yaw: N, pitch: N, roll: N) -> TMat4<N> {
+pub fn yawPitchRoll<N: RealField>(yaw: N, pitch: N, roll: N) -> TMat4<N> {
     unimplemented!()
 }
diff --git a/nalgebra-glm/src/gtx/exterior_product.rs b/nalgebra-glm/src/gtx/exterior_product.rs
index cc58597bf..a95c557b8 100644
--- a/nalgebra-glm/src/gtx/exterior_product.rs
+++ b/nalgebra-glm/src/gtx/exterior_product.rs
@@ -1,5 +1,5 @@
-use aliases::TVec2;
-use traits::Number;
+use crate::aliases::TVec2;
+use crate::traits::Number;
 
 /// The 2D perpendicular product between two vectors.
 pub fn cross2d<N: Number>(v: &TVec2<N>, u: &TVec2<N>) -> N {
diff --git a/nalgebra-glm/src/gtx/handed_coordinate_space.rs b/nalgebra-glm/src/gtx/handed_coordinate_space.rs
index ee1979adc..22d250564 100644
--- a/nalgebra-glm/src/gtx/handed_coordinate_space.rs
+++ b/nalgebra-glm/src/gtx/handed_coordinate_space.rs
@@ -1,5 +1,5 @@
-use aliases::TVec3;
-use traits::Number;
+use crate::aliases::TVec3;
+use crate::traits::Number;
 
 /// Returns `true` if `{a, b, c}` forms a left-handed trihedron.
 ///
diff --git a/nalgebra-glm/src/gtx/matrix_cross_product.rs b/nalgebra-glm/src/gtx/matrix_cross_product.rs
index 7d70d438a..40aa03e82 100644
--- a/nalgebra-glm/src/gtx/matrix_cross_product.rs
+++ b/nalgebra-glm/src/gtx/matrix_cross_product.rs
@@ -1,13 +1,13 @@
-use na::Real;
+use na::RealField;
 
-use aliases::{TMat3, TMat4, TVec3};
+use crate::aliases::{TMat3, TMat4, TVec3};
 
 /// Builds a 3x3 matrix `m` such that for any `v`: `m * v == cross(x, v)`.
 ///
 /// # See also:
 ///
 /// * [`matrix_cross`](fn.matrix_cross.html)
-pub fn matrix_cross3<N: Real>(x: &TVec3<N>) -> TMat3<N> {
+pub fn matrix_cross3<N: RealField>(x: &TVec3<N>) -> TMat3<N> {
     x.cross_matrix()
 }
 
@@ -16,6 +16,6 @@ pub fn matrix_cross3<N: Real>(x: &TVec3<N>) -> TMat3<N> {
 /// # See also:
 ///
 /// * [`matrix_cross3`](fn.matrix_cross3.html)
-pub fn matrix_cross<N: Real>(x: &TVec3<N>) -> TMat4<N> {
-    ::mat3_to_mat4(&x.cross_matrix())
+pub fn matrix_cross<N: RealField>(x: &TVec3<N>) -> TMat4<N> {
+    crate::mat3_to_mat4(&x.cross_matrix())
 }
diff --git a/nalgebra-glm/src/gtx/matrix_operation.rs b/nalgebra-glm/src/gtx/matrix_operation.rs
index 954607ef7..cc0512732 100644
--- a/nalgebra-glm/src/gtx/matrix_operation.rs
+++ b/nalgebra-glm/src/gtx/matrix_operation.rs
@@ -1,7 +1,7 @@
-use aliases::{
+use crate::aliases::{
     TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4, TMat4, TMat4x2, TMat4x3, TVec2, TVec3, TVec4,
 };
-use traits::Number;
+use crate::traits::Number;
 
 /// Builds a 2x2 diagonal matrix.
 ///
diff --git a/nalgebra-glm/src/gtx/norm.rs b/nalgebra-glm/src/gtx/norm.rs
index 0a2875300..9332c0107 100644
--- a/nalgebra-glm/src/gtx/norm.rs
+++ b/nalgebra-glm/src/gtx/norm.rs
@@ -1,14 +1,14 @@
-use na::{DefaultAllocator, Real};
+use na::{DefaultAllocator, RealField};
 
-use aliases::TVec;
-use traits::{Alloc, Dimension};
+use crate::aliases::TVec;
+use crate::traits::{Alloc, Dimension};
 
 /// The squared distance between two points.
 ///
 /// # See also:
 ///
 /// * [`distance`](fn.distance.html)
-pub fn distance2<N: Real, D: Dimension>(p0: &TVec<N, D>, p1: &TVec<N, D>) -> N
+pub fn distance2<N: RealField, D: Dimension>(p0: &TVec<N, D>, p1: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     (p1 - p0).norm_squared()
 }
@@ -20,7 +20,7 @@ where DefaultAllocator: Alloc<N, D> {
 /// * [`l1_norm`](fn.l1_norm.html)
 /// * [`l2_distance`](fn.l2_distance.html)
 /// * [`l2_norm`](fn.l2_norm.html)
-pub fn l1_distance<N: Real, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
+pub fn l1_distance<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     l1_norm(&(y - x))
 }
@@ -35,9 +35,9 @@ where DefaultAllocator: Alloc<N, D> {
 /// * [`l1_distance`](fn.l1_distance.html)
 /// * [`l2_distance`](fn.l2_distance.html)
 /// * [`l2_norm`](fn.l2_norm.html)
-pub fn l1_norm<N: Real, D: Dimension>(v: &TVec<N, D>) -> N
+pub fn l1_norm<N: RealField, D: Dimension>(v: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
-    ::comp_add(&v.abs())
+    crate::comp_add(&v.abs())
 }
 
 /// The l2-norm of `x - y`.
@@ -54,7 +54,7 @@ where DefaultAllocator: Alloc<N, D> {
 /// * [`length2`](fn.length2.html)
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`magnitude2`](fn.magnitude2.html)
-pub fn l2_distance<N: Real, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
+pub fn l2_distance<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     l2_norm(&(y - x))
 }
@@ -75,7 +75,7 @@ where DefaultAllocator: Alloc<N, D> {
 /// * [`length2`](fn.length2.html)
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`magnitude2`](fn.magnitude2.html)
-pub fn l2_norm<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
+pub fn l2_norm<N: RealField, D: Dimension>(x: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     x.norm()
 }
@@ -91,7 +91,7 @@ where DefaultAllocator: Alloc<N, D> {
 /// * [`length`](fn.length.html)
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`magnitude2`](fn.magnitude2.html)
-pub fn length2<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
+pub fn length2<N: RealField, D: Dimension>(x: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     x.norm_squared()
 }
@@ -107,17 +107,17 @@ where DefaultAllocator: Alloc<N, D> {
 /// * [`length2`](fn.length2.html)
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`nalgebra::norm_squared`](../nalgebra/fn.norm_squared.html)
-pub fn magnitude2<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
+pub fn magnitude2<N: RealField, D: Dimension>(x: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     x.norm_squared()
 }
 
-//pub fn lxNorm<N: Real, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, unsigned int Depth) -> N
+//pub fn lxNorm<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, unsigned int Depth) -> N
 //    where DefaultAllocator: Alloc<N, D> {
 //    unimplemented!()
 //}
 //
-//pub fn lxNorm<N: Real, D: Dimension>(x: &TVec<N, D>, unsigned int Depth) -> N
+//pub fn lxNorm<N: RealField, D: Dimension>(x: &TVec<N, D>, unsigned int Depth) -> N
 //    where DefaultAllocator: Alloc<N, D> {
 //    unimplemented!()
 //}
diff --git a/nalgebra-glm/src/gtx/normal.rs b/nalgebra-glm/src/gtx/normal.rs
index 63fc9246e..d9f480342 100644
--- a/nalgebra-glm/src/gtx/normal.rs
+++ b/nalgebra-glm/src/gtx/normal.rs
@@ -1,10 +1,10 @@
-use na::Real;
+use na::RealField;
 
-use aliases::TVec3;
+use crate::aliases::TVec3;
 
 /// The normal vector of the given triangle.
 ///
 /// The normal is computed as the normalized vector `cross(p2 - p1, p3 - p1)`.
-pub fn triangle_normal<N: Real>(p1: &TVec3<N>, p2: &TVec3<N>, p3: &TVec3<N>) -> TVec3<N> {
+pub fn triangle_normal<N: RealField>(p1: &TVec3<N>, p2: &TVec3<N>, p3: &TVec3<N>) -> TVec3<N> {
     (p2 - p1).cross(&(p3 - p1)).normalize()
 }
diff --git a/nalgebra-glm/src/gtx/normalize_dot.rs b/nalgebra-glm/src/gtx/normalize_dot.rs
index df52d2c02..06ce6978e 100644
--- a/nalgebra-glm/src/gtx/normalize_dot.rs
+++ b/nalgebra-glm/src/gtx/normalize_dot.rs
@@ -1,7 +1,7 @@
-use na::{DefaultAllocator, Real};
+use na::{DefaultAllocator, RealField};
 
-use aliases::TVec;
-use traits::{Alloc, Dimension};
+use crate::aliases::TVec;
+use crate::traits::{Alloc, Dimension};
 
 /// The dot product of the normalized version of `x` and `y`.
 ///
@@ -10,7 +10,7 @@ use traits::{Alloc, Dimension};
 /// # See also:
 ///
 /// * [`normalize_dot`](fn.normalize_dot.html`)
-pub fn fast_normalize_dot<N: Real, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
+pub fn fast_normalize_dot<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     // XXX: improve those.
     x.normalize().dot(&y.normalize())
@@ -21,7 +21,7 @@ where DefaultAllocator: Alloc<N, D> {
 /// # See also:
 ///
 /// * [`fast_normalize_dot`](fn.fast_normalize_dot.html`)
-pub fn normalize_dot<N: Real, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
+pub fn normalize_dot<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     // XXX: improve those.
     x.normalize().dot(&y.normalize())
diff --git a/nalgebra-glm/src/gtx/quaternion.rs b/nalgebra-glm/src/gtx/quaternion.rs
index 70005ca86..a90760d4b 100644
--- a/nalgebra-glm/src/gtx/quaternion.rs
+++ b/nalgebra-glm/src/gtx/quaternion.rs
@@ -1,97 +1,97 @@
-use na::{Real, Rotation3, Unit, UnitQuaternion, U3};
+use na::{RealField, Rotation3, Unit, UnitQuaternion, U3};
 
-use aliases::{Qua, TMat3, TMat4, TVec3, TVec4};
+use crate::aliases::{Qua, TMat3, TMat4, TVec3, TVec4};
 
 /// Rotate the vector `v` by the quaternion `q` assumed to be normalized.
-pub fn quat_cross_vec<N: Real>(q: &Qua<N>, v: &TVec3<N>) -> TVec3<N> {
+pub fn quat_cross_vec<N: RealField>(q: &Qua<N>, v: &TVec3<N>) -> TVec3<N> {
     UnitQuaternion::new_unchecked(*q) * v
 }
 
 /// Rotate the vector `v` by the inverse of the quaternion `q` assumed to be normalized.
-pub fn quat_inv_cross_vec<N: Real>(v: &TVec3<N>, q: &Qua<N>) -> TVec3<N> {
+pub fn quat_inv_cross_vec<N: RealField>(v: &TVec3<N>, q: &Qua<N>) -> TVec3<N> {
     UnitQuaternion::new_unchecked(*q).inverse() * v
 }
 
 /// The quaternion `w` component.
-pub fn quat_extract_real_component<N: Real>(q: &Qua<N>) -> N {
+pub fn quat_extract_real_component<N: RealField>(q: &Qua<N>) -> N {
     q.w
 }
 
 /// Normalized linear interpolation between two quaternions.
-pub fn quat_fast_mix<N: Real>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
+pub fn quat_fast_mix<N: RealField>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
     Unit::new_unchecked(*x)
         .nlerp(&Unit::new_unchecked(*y), a)
         .into_inner()
 }
 
-//pub fn quat_intermediate<N: Real>(prev: &Qua<N>, curr: &Qua<N>, next: &Qua<N>) -> Qua<N> {
+//pub fn quat_intermediate<N: RealField>(prev: &Qua<N>, curr: &Qua<N>, next: &Qua<N>) -> Qua<N> {
 //    unimplemented!()
 //}
 
 /// The squared magnitude of a quaternion `q`.
-pub fn quat_length2<N: Real>(q: &Qua<N>) -> N {
+pub fn quat_length2<N: RealField>(q: &Qua<N>) -> N {
     q.norm_squared()
 }
 
 /// The squared magnitude of a quaternion `q`.
-pub fn quat_magnitude2<N: Real>(q: &Qua<N>) -> N {
+pub fn quat_magnitude2<N: RealField>(q: &Qua<N>) -> N {
     q.norm_squared()
 }
 
 /// The quaternion representing the identity rotation.
-pub fn quat_identity<N: Real>() -> Qua<N> {
+pub fn quat_identity<N: RealField>() -> Qua<N> {
     UnitQuaternion::identity().into_inner()
 }
 
 /// Rotates a vector by a quaternion assumed to be normalized.
-pub fn quat_rotate_vec3<N: Real>(q: &Qua<N>, v: &TVec3<N>) -> TVec3<N> {
+pub fn quat_rotate_vec3<N: RealField>(q: &Qua<N>, v: &TVec3<N>) -> TVec3<N> {
     UnitQuaternion::new_unchecked(*q) * v
 }
 
 /// Rotates a vector in homogeneous coordinates by a quaternion assumed to be normalized.
-pub fn quat_rotate_vec<N: Real>(q: &Qua<N>, v: &TVec4<N>) -> TVec4<N> {
+pub fn quat_rotate_vec<N: RealField>(q: &Qua<N>, v: &TVec4<N>) -> TVec4<N> {
     let rotated = Unit::new_unchecked(*q) * v.fixed_rows::<U3>(0);
     TVec4::new(rotated.x, rotated.y, rotated.z, v.w)
 }
 
 /// The rotation required to align `orig` to `dest`.
-pub fn quat_rotation<N: Real>(orig: &TVec3<N>, dest: &TVec3<N>) -> Qua<N> {
+pub fn quat_rotation<N: RealField>(orig: &TVec3<N>, dest: &TVec3<N>) -> Qua<N> {
     UnitQuaternion::rotation_between(orig, dest)
         .unwrap_or_else(UnitQuaternion::identity)
         .into_inner()
 }
 
 /// The spherical linear interpolation between two quaternions.
-pub fn quat_short_mix<N: Real>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
+pub fn quat_short_mix<N: RealField>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
     Unit::new_normalize(*x)
         .slerp(&Unit::new_normalize(*y), a)
         .into_inner()
 }
 
-//pub fn quat_squad<N: Real>(q1: &Qua<N>, q2: &Qua<N>, s1: &Qua<N>, s2: &Qua<N>, h: N) -> Qua<N> {
+//pub fn quat_squad<N: RealField>(q1: &Qua<N>, q2: &Qua<N>, s1: &Qua<N>, s2: &Qua<N>, h: N) -> Qua<N> {
 //    unimplemented!()
 //}
 
 /// Converts a quaternion to a rotation matrix.
-pub fn quat_to_mat3<N: Real>(x: &Qua<N>) -> TMat3<N> {
+pub fn quat_to_mat3<N: RealField>(x: &Qua<N>) -> TMat3<N> {
     UnitQuaternion::new_unchecked(*x)
         .to_rotation_matrix()
         .into_inner()
 }
 
 /// Converts a quaternion to a rotation matrix in homogenous coordinates.
-pub fn quat_to_mat4<N: Real>(x: &Qua<N>) -> TMat4<N> {
+pub fn quat_to_mat4<N: RealField>(x: &Qua<N>) -> TMat4<N> {
     UnitQuaternion::new_unchecked(*x).to_homogeneous()
 }
 
 /// Converts a rotation matrix to a quaternion.
-pub fn mat3_to_quat<N: Real>(x: &TMat3<N>) -> Qua<N> {
+pub fn mat3_to_quat<N: RealField>(x: &TMat3<N>) -> Qua<N> {
     let r = Rotation3::from_matrix_unchecked(*x);
     UnitQuaternion::from_rotation_matrix(&r).into_inner()
 }
 
 /// Converts a rotation matrix in homogeneous coordinates to a quaternion.
-pub fn to_quat<N: Real>(x: &TMat4<N>) -> Qua<N> {
+pub fn to_quat<N: RealField>(x: &TMat4<N>) -> Qua<N> {
     let rot = x.fixed_slice::<U3, U3>(0, 0).into_owned();
     mat3_to_quat(&rot)
 }
diff --git a/nalgebra-glm/src/gtx/rotate_normalized_axis.rs b/nalgebra-glm/src/gtx/rotate_normalized_axis.rs
index 224d7bfec..1672b9784 100644
--- a/nalgebra-glm/src/gtx/rotate_normalized_axis.rs
+++ b/nalgebra-glm/src/gtx/rotate_normalized_axis.rs
@@ -1,6 +1,6 @@
-use na::{Real, Rotation3, Unit, UnitQuaternion};
+use na::{RealField, Rotation3, Unit, UnitQuaternion};
 
-use aliases::{Qua, TMat4, TVec3};
+use crate::aliases::{Qua, TMat4, TVec3};
 
 /// Builds a rotation 4 * 4 matrix created from a normalized axis and an angle.
 ///
@@ -9,7 +9,7 @@ use aliases::{Qua, TMat4, TVec3};
 /// * `m` - Input matrix multiplied by this rotation matrix.
 /// * `angle` - Rotation angle expressed in radians.
 /// * `axis` - Rotation axis, must be normalized.
-pub fn rotate_normalized_axis<N: Real>(m: &TMat4<N>, angle: N, axis: &TVec3<N>) -> TMat4<N> {
+pub fn rotate_normalized_axis<N: RealField>(m: &TMat4<N>, angle: N, axis: &TVec3<N>) -> TMat4<N> {
     m * Rotation3::from_axis_angle(&Unit::new_unchecked(*axis), angle).to_homogeneous()
 }
 
@@ -20,6 +20,6 @@ pub fn rotate_normalized_axis<N: Real>(m: &TMat4<N>, angle: N, axis: &TVec3<N>)
 /// * `q` - Source orientation.
 /// * `angle` - Angle expressed in radians.
 /// * `axis` - Normalized axis of the rotation, must be normalized.
-pub fn quat_rotate_normalized_axis<N: Real>(q: &Qua<N>, angle: N, axis: &TVec3<N>) -> Qua<N> {
+pub fn quat_rotate_normalized_axis<N: RealField>(q: &Qua<N>, angle: N, axis: &TVec3<N>) -> Qua<N> {
     q * UnitQuaternion::from_axis_angle(&Unit::new_unchecked(*axis), angle).into_inner()
 }
diff --git a/nalgebra-glm/src/gtx/rotate_vector.rs b/nalgebra-glm/src/gtx/rotate_vector.rs
index 64ce72448..30abc7670 100644
--- a/nalgebra-glm/src/gtx/rotate_vector.rs
+++ b/nalgebra-glm/src/gtx/rotate_vector.rs
@@ -1,9 +1,9 @@
-use na::{Real, Rotation3, Unit, UnitComplex};
+use na::{RealField, Rotation3, Unit, UnitComplex};
 
-use aliases::{TMat4, TVec2, TVec3, TVec4};
+use crate::aliases::{TMat4, TVec2, TVec3, TVec4};
 
 /// Build the rotation matrix needed to align `normal` and `up`.
-pub fn orientation<N: Real>(normal: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
+pub fn orientation<N: RealField>(normal: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
     if let Some(r) = Rotation3::rotation_between(normal, up) {
         r.to_homogeneous()
     } else {
@@ -12,52 +12,52 @@ pub fn orientation<N: Real>(normal: &TVec3<N>, up: &TVec3<N>) -> TMat4<N> {
 }
 
 /// Rotate a two dimensional vector.
-pub fn rotate_vec2<N: Real>(v: &TVec2<N>, angle: N) -> TVec2<N> {
+pub fn rotate_vec2<N: RealField>(v: &TVec2<N>, angle: N) -> TVec2<N> {
     UnitComplex::new(angle) * v
 }
 
 /// Rotate a three dimensional vector around an axis.
-pub fn rotate_vec3<N: Real>(v: &TVec3<N>, angle: N, normal: &TVec3<N>) -> TVec3<N> {
+pub fn rotate_vec3<N: RealField>(v: &TVec3<N>, angle: N, normal: &TVec3<N>) -> TVec3<N> {
     Rotation3::from_axis_angle(&Unit::new_normalize(*normal), angle) * v
 }
 
 /// Rotate a thee dimensional vector in homogeneous coordinates around an axis.
-pub fn rotate_vec4<N: Real>(v: &TVec4<N>, angle: N, normal: &TVec3<N>) -> TVec4<N> {
+pub fn rotate_vec4<N: RealField>(v: &TVec4<N>, angle: N, normal: &TVec3<N>) -> TVec4<N> {
     Rotation3::from_axis_angle(&Unit::new_normalize(*normal), angle).to_homogeneous() * v
 }
 
 /// Rotate a three dimensional vector around the `X` axis.
-pub fn rotate_x_vec3<N: Real>(v: &TVec3<N>, angle: N) -> TVec3<N> {
+pub fn rotate_x_vec3<N: RealField>(v: &TVec3<N>, angle: N) -> TVec3<N> {
     Rotation3::from_axis_angle(&TVec3::x_axis(), angle) * v
 }
 
 /// Rotate a three dimensional vector in homogeneous coordinates around the `X` axis.
-pub fn rotate_x_vec4<N: Real>(v: &TVec4<N>, angle: N) -> TVec4<N> {
+pub fn rotate_x_vec4<N: RealField>(v: &TVec4<N>, angle: N) -> TVec4<N> {
     Rotation3::from_axis_angle(&TVec3::x_axis(), angle).to_homogeneous() * v
 }
 
 /// Rotate a three dimensional vector around the `Y` axis.
-pub fn rotate_y_vec3<N: Real>(v: &TVec3<N>, angle: N) -> TVec3<N> {
+pub fn rotate_y_vec3<N: RealField>(v: &TVec3<N>, angle: N) -> TVec3<N> {
     Rotation3::from_axis_angle(&TVec3::y_axis(), angle) * v
 }
 
 /// Rotate a three dimensional vector in homogeneous coordinates around the `Y` axis.
-pub fn rotate_y_vec4<N: Real>(v: &TVec4<N>, angle: N) -> TVec4<N> {
+pub fn rotate_y_vec4<N: RealField>(v: &TVec4<N>, angle: N) -> TVec4<N> {
     Rotation3::from_axis_angle(&TVec3::y_axis(), angle).to_homogeneous() * v
 }
 
 /// Rotate a three dimensional vector around the `Z` axis.
-pub fn rotate_z_vec3<N: Real>(v: &TVec3<N>, angle: N) -> TVec3<N> {
+pub fn rotate_z_vec3<N: RealField>(v: &TVec3<N>, angle: N) -> TVec3<N> {
     Rotation3::from_axis_angle(&TVec3::z_axis(), angle) * v
 }
 
 /// Rotate a three dimensional vector in homogeneous coordinates around the `Z` axis.
-pub fn rotate_z_vec4<N: Real>(v: &TVec4<N>, angle: N) -> TVec4<N> {
+pub fn rotate_z_vec4<N: RealField>(v: &TVec4<N>, angle: N) -> TVec4<N> {
     Rotation3::from_axis_angle(&TVec3::z_axis(), angle).to_homogeneous() * v
 }
 
 /// Computes a spherical linear interpolation between the vectors `x` and `y` assumed to be normalized.
-pub fn slerp<N: Real>(x: &TVec3<N>, y: &TVec3<N>, a: N) -> TVec3<N> {
+pub fn slerp<N: RealField>(x: &TVec3<N>, y: &TVec3<N>, a: N) -> TVec3<N> {
     Unit::new_unchecked(*x)
         .slerp(&Unit::new_unchecked(*y), a)
         .into_inner()
diff --git a/nalgebra-glm/src/gtx/transform.rs b/nalgebra-glm/src/gtx/transform.rs
index 85554fe5a..17a853c14 100644
--- a/nalgebra-glm/src/gtx/transform.rs
+++ b/nalgebra-glm/src/gtx/transform.rs
@@ -1,7 +1,7 @@
-use na::{Real, Rotation2, Rotation3, Unit};
+use na::{RealField, Rotation2, Rotation3, Unit};
 
-use aliases::{TMat3, TMat4, TVec2, TVec3};
-use traits::Number;
+use crate::aliases::{TMat3, TMat4, TVec2, TVec3};
+use crate::traits::Number;
 
 /// A rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in radians.
 ///
@@ -12,7 +12,7 @@ use traits::Number;
 /// * [`rotation2d`](fn.rotation2d.html)
 /// * [`scaling2d`](fn.scaling2d.html)
 /// * [`translation2d`](fn.translation2d.html)
-pub fn rotation<N: Real>(angle: N, v: &TVec3<N>) -> TMat4<N> {
+pub fn rotation<N: RealField>(angle: N, v: &TVec3<N>) -> TMat4<N> {
     Rotation3::from_axis_angle(&Unit::new_normalize(*v), angle).to_homogeneous()
 }
 
@@ -51,7 +51,7 @@ pub fn translation<N: Number>(v: &TVec3<N>) -> TMat4<N> {
 /// * [`translation`](fn.translation.html)
 /// * [`scaling2d`](fn.scaling2d.html)
 /// * [`translation2d`](fn.translation2d.html)
-pub fn rotation2d<N: Real>(angle: N) -> TMat3<N> {
+pub fn rotation2d<N: RealField>(angle: N) -> TMat3<N> {
     Rotation2::new(angle).to_homogeneous()
 }
 
diff --git a/nalgebra-glm/src/gtx/transform2.rs b/nalgebra-glm/src/gtx/transform2.rs
index fa5533f70..eaa74acb6 100644
--- a/nalgebra-glm/src/gtx/transform2.rs
+++ b/nalgebra-glm/src/gtx/transform2.rs
@@ -1,7 +1,7 @@
 use na::{U2, U3};
 
-use aliases::{TMat3, TMat4, TVec2, TVec3};
-use traits::Number;
+use crate::aliases::{TMat3, TMat4, TVec2, TVec3};
+use crate::traits::Number;
 
 /// Build planar projection matrix along normal axis and right-multiply it to `m`.
 pub fn proj2d<N: Number>(m: &TMat3<N>, normal: &TVec2<N>) -> TMat3<N> {
diff --git a/nalgebra-glm/src/gtx/transform2d.rs b/nalgebra-glm/src/gtx/transform2d.rs
index 3d401f566..0c7deb18b 100644
--- a/nalgebra-glm/src/gtx/transform2d.rs
+++ b/nalgebra-glm/src/gtx/transform2d.rs
@@ -1,7 +1,7 @@
-use na::{Real, UnitComplex};
+use na::{RealField, UnitComplex};
 
-use aliases::{TMat3, TVec2};
-use traits::Number;
+use crate::aliases::{TMat3, TVec2};
+use crate::traits::Number;
 
 /// Builds a 2D rotation matrix from an angle and right-multiply it to `m`.
 ///
@@ -12,7 +12,7 @@ use traits::Number;
 /// * [`scaling2d`](fn.scaling2d.html)
 /// * [`translate2d`](fn.translate2d.html)
 /// * [`translation2d`](fn.translation2d.html)
-pub fn rotate2d<N: Real>(m: &TMat3<N>, angle: N) -> TMat3<N> {
+pub fn rotate2d<N: RealField>(m: &TMat3<N>, angle: N) -> TMat3<N> {
     m * UnitComplex::new(angle).to_homogeneous()
 }
 
diff --git a/nalgebra-glm/src/gtx/vector_angle.rs b/nalgebra-glm/src/gtx/vector_angle.rs
index 1ebb39a44..8753ccd0a 100644
--- a/nalgebra-glm/src/gtx/vector_angle.rs
+++ b/nalgebra-glm/src/gtx/vector_angle.rs
@@ -1,18 +1,18 @@
-use na::{DefaultAllocator, Real};
+use na::{DefaultAllocator, RealField};
 
-use aliases::TVec;
-use traits::{Alloc, Dimension};
+use crate::aliases::TVec;
+use crate::traits::{Alloc, Dimension};
 
 /// The angle between two vectors.
-pub fn angle<N: Real, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
+pub fn angle<N: RealField, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
 where DefaultAllocator: Alloc<N, D> {
     x.angle(y)
 }
 
-//pub fn oriented_angle<N: Real>(x: &TVec2<N>, y: &TVec2<N>) -> N {
+//pub fn oriented_angle<N: RealField>(x: &TVec2<N>, y: &TVec2<N>) -> N {
 //    unimplemented!()
 //}
 //
-//pub fn oriented_angle_ref<N: Real>(x: &TVec3<N>, y: &TVec3<N>, refv: &TVec3<N>) -> N {
+//pub fn oriented_angle_ref<N: RealField>(x: &TVec3<N>, y: &TVec3<N>, refv: &TVec3<N>) -> N {
 //    unimplemented!()
 //}
diff --git a/nalgebra-glm/src/gtx/vector_query.rs b/nalgebra-glm/src/gtx/vector_query.rs
index f408a4b39..2a127f007 100644
--- a/nalgebra-glm/src/gtx/vector_query.rs
+++ b/nalgebra-glm/src/gtx/vector_query.rs
@@ -1,7 +1,7 @@
-use na::{DefaultAllocator, Real};
+use na::{DefaultAllocator, RealField};
 
-use aliases::{TVec, TVec2, TVec3};
-use traits::{Alloc, Dimension, Number};
+use crate::aliases::{TVec, TVec2, TVec3};
+use crate::traits::{Alloc, Dimension, Number};
 
 /// Returns `true` if two vectors are collinear (up to an epsilon).
 ///
@@ -45,7 +45,7 @@ where DefaultAllocator: Alloc<N, D> {
 }
 
 /// Returns `true` if `v` has a magnitude of 1 (up to an epsilon).
-pub fn is_normalized<N: Real, D: Dimension>(v: &TVec<N, D>, epsilon: N) -> bool
+pub fn is_normalized<N: RealField, D: Dimension>(v: &TVec<N, D>, epsilon: N) -> bool
 where DefaultAllocator: Alloc<N, D> {
     abs_diff_eq!(v.norm_squared(), N::one(), epsilon = epsilon * epsilon)
 }
diff --git a/nalgebra-glm/src/integer.rs b/nalgebra-glm/src/integer.rs
index 67a0116ca..198d737a8 100644
--- a/nalgebra-glm/src/integer.rs
+++ b/nalgebra-glm/src/integer.rs
@@ -1,7 +1,7 @@
-use na::{Scalar, Real, U3, DefaultAllocator};
+use na::{Scalar, RealField, U3, DefaultAllocator};
 
-use traits::{Number, Alloc, Dimension};
-use aliases::TVec;
+use crate::traits::{Number, Alloc, Dimension};
+use crate::aliases::TVec;
 
 pub fn bitCount<T>(v: T) -> i32 {
     unimplemented!()
diff --git a/nalgebra-glm/src/lib.rs b/nalgebra-glm/src/lib.rs
index 53830f2bb..66502e73b 100644
--- a/nalgebra-glm/src/lib.rs
+++ b/nalgebra-glm/src/lib.rs
@@ -119,7 +119,7 @@ extern crate approx;
 extern crate alga;
 extern crate nalgebra as na;
 
-pub use aliases::*;
+pub use crate::aliases::*;
 pub use common::{
     abs, ceil, clamp, clamp_scalar, clamp_vec, float_bits_to_int, float_bits_to_int_vec,
     float_bits_to_uint, float_bits_to_uint_vec, floor, fract, int_bits_to_float,
@@ -133,7 +133,7 @@ pub use geometric::{
     cross, distance, dot, faceforward, length, magnitude, normalize, reflect_vec, refract_vec,
 };
 pub use matrix::{determinant, inverse, matrix_comp_mult, outer_product, transpose};
-pub use traits::{Alloc, Dimension, Number};
+pub use crate::traits::{Alloc, Dimension, Number};
 pub use trigonometric::{
     acos, acosh, asin, asinh, atan, atan2, atanh, cos, cosh, degrees, radians, sin, sinh, tan, tanh,
 };
@@ -191,7 +191,7 @@ pub use gtx::{
 pub use na::{
     convert, convert_ref, convert_ref_unchecked, convert_unchecked, try_convert, try_convert_ref,
 };
-pub use na::{DefaultAllocator, Real, Scalar, U1, U2, U3, U4};
+pub use na::{DefaultAllocator, RealField, Scalar, U1, U2, U3, U4};
 
 mod aliases;
 mod common;
diff --git a/nalgebra-glm/src/matrix.rs b/nalgebra-glm/src/matrix.rs
index 812122484..a4c4efe9f 100644
--- a/nalgebra-glm/src/matrix.rs
+++ b/nalgebra-glm/src/matrix.rs
@@ -1,16 +1,16 @@
-use na::{DefaultAllocator, Real, Scalar};
+use na::{DefaultAllocator, RealField, Scalar};
 
-use aliases::{TMat, TVec};
-use traits::{Alloc, Dimension, Number};
+use crate::aliases::{TMat, TVec};
+use crate::traits::{Alloc, Dimension, Number};
 
 /// The determinant of the matrix `m`.
-pub fn determinant<N: Real, D: Dimension>(m: &TMat<N, D, D>) -> N
+pub fn determinant<N: RealField, D: Dimension>(m: &TMat<N, D, D>) -> N
 where DefaultAllocator: Alloc<N, D, D> {
     m.determinant()
 }
 
 /// The inverse of the matrix `m`.
-pub fn inverse<N: Real, D: Dimension>(m: &TMat<N, D, D>) -> TMat<N, D, D>
+pub fn inverse<N: RealField, D: Dimension>(m: &TMat<N, D, D>) -> TMat<N, D, D>
 where DefaultAllocator: Alloc<N, D, D> {
     m.clone()
         .try_inverse()
diff --git a/nalgebra-glm/src/packing.rs b/nalgebra-glm/src/packing.rs
index 71df195ca..3273fb266 100644
--- a/nalgebra-glm/src/packing.rs
+++ b/nalgebra-glm/src/packing.rs
@@ -1,6 +1,6 @@
 use na::Scalar;
 
-use aliases::{Vec2, Vec4, UVec2};
+use crate::aliases::{Vec2, Vec4, UVec2};
 
 
 pub fn packDouble2x32<N: Scalar>(v: &UVec2) -> f64 {
diff --git a/nalgebra-glm/src/trigonometric.rs b/nalgebra-glm/src/trigonometric.rs
index cf0b26529..139a48dab 100644
--- a/nalgebra-glm/src/trigonometric.rs
+++ b/nalgebra-glm/src/trigonometric.rs
@@ -1,94 +1,94 @@
-use na::{self, DefaultAllocator, Real};
+use na::{self, DefaultAllocator, RealField};
 
-use aliases::TVec;
-use traits::{Alloc, Dimension};
+use crate::aliases::TVec;
+use crate::traits::{Alloc, Dimension};
 
 /// Component-wise arc-cosinus.
-pub fn acos<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
+pub fn acos<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     x.map(|e| e.acos())
 }
 
 /// Component-wise hyperbolic arc-cosinus.
-pub fn acosh<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
+pub fn acosh<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     x.map(|e| e.acosh())
 }
 
 /// Component-wise arc-sinus.
-pub fn asin<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
+pub fn asin<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     x.map(|e| e.asin())
 }
 
 /// Component-wise hyperbolic arc-sinus.
-pub fn asinh<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
+pub fn asinh<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     x.map(|e| e.asinh())
 }
 
 /// Component-wise arc-tangent of `y / x`.
-pub fn atan2<N: Real, D: Dimension>(y: &TVec<N, D>, x: &TVec<N, D>) -> TVec<N, D>
+pub fn atan2<N: RealField, D: Dimension>(y: &TVec<N, D>, x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     y.zip_map(x, |y, x| y.atan2(x))
 }
 
 /// Component-wise arc-tangent.
-pub fn atan<N: Real, D: Dimension>(y_over_x: &TVec<N, D>) -> TVec<N, D>
+pub fn atan<N: RealField, D: Dimension>(y_over_x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     y_over_x.map(|e| e.atan())
 }
 
 /// Component-wise hyperbolic arc-tangent.
-pub fn atanh<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
+pub fn atanh<N: RealField, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     x.map(|e| e.atanh())
 }
 
 /// Component-wise cosinus.
-pub fn cos<N: Real, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
+pub fn cos<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     angle.map(|e| e.cos())
 }
 
 /// Component-wise hyperbolic cosinus.
-pub fn cosh<N: Real, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
+pub fn cosh<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     angle.map(|e| e.cosh())
 }
 
 /// Component-wise conversion from radians to degrees.
-pub fn degrees<N: Real, D: Dimension>(radians: &TVec<N, D>) -> TVec<N, D>
+pub fn degrees<N: RealField, D: Dimension>(radians: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     radians.map(|e| e * na::convert(180.0) / N::pi())
 }
 
 /// Component-wise conversion fro degrees to radians.
-pub fn radians<N: Real, D: Dimension>(degrees: &TVec<N, D>) -> TVec<N, D>
+pub fn radians<N: RealField, D: Dimension>(degrees: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     degrees.map(|e| e * N::pi() / na::convert(180.0))
 }
 
 /// Component-wise sinus.
-pub fn sin<N: Real, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
+pub fn sin<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     angle.map(|e| e.sin())
 }
 
 /// Component-wise hyperbolic sinus.
-pub fn sinh<N: Real, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
+pub fn sinh<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     angle.map(|e| e.sinh())
 }
 
 /// Component-wise tangent.
-pub fn tan<N: Real, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
+pub fn tan<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     angle.map(|e| e.tan())
 }
 
 /// Component-wise hyperbolic tangent.
-pub fn tanh<N: Real, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
+pub fn tanh<N: RealField, D: Dimension>(angle: &TVec<N, D>) -> TVec<N, D>
 where DefaultAllocator: Alloc<N, D> {
     angle.map(|e| e.tanh())
 }
diff --git a/nalgebra-glm/src/vector_relational.rs b/nalgebra-glm/src/vector_relational.rs
index c92f69fe8..844936fef 100644
--- a/nalgebra-glm/src/vector_relational.rs
+++ b/nalgebra-glm/src/vector_relational.rs
@@ -1,7 +1,7 @@
 use na::DefaultAllocator;
 
-use aliases::TVec;
-use traits::{Alloc, Dimension, Number};
+use crate::aliases::TVec;
+use crate::traits::{Alloc, Dimension, Number};
 
 /// Checks that all the vector components are `true`.
 ///
diff --git a/nalgebra-lapack/Cargo.toml b/nalgebra-lapack/Cargo.toml
index ac54589c8..3d8a24d8f 100644
--- a/nalgebra-lapack/Cargo.toml
+++ b/nalgebra-lapack/Cargo.toml
@@ -10,6 +10,7 @@ repository    = "https://github.com/rustsim/nalgebra"
 readme        = "README.md"
 keywords      = [ "linear", "algebra", "matrix", "vector" ]
 license       = "BSD-3-Clause"
+edition       = "2018"
 
 [features]
 serde-serialize = [ "serde", "serde_derive" ]
diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index fbc49319a..d5397841b 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -4,13 +4,13 @@ use serde::{Deserialize, Serialize};
 use num::Zero;
 use num_complex::Complex;
 
-use alga::general::Real;
+use alga::general::RealField;
 
 use na::allocator::Allocator;
 use na::dimension::{Dim, U1};
 use na::storage::Storage;
 use na::{DefaultAllocator, Matrix, MatrixN, Scalar, VectorN};
-use ComplexHelper;
+use crate::ComplexHelper;
 
 use lapack;
 
@@ -51,7 +51,7 @@ where
     MatrixN<N, D>: Copy,
 {}
 
-impl<N: EigenScalar + Real, D: Dim> Eigen<N, D>
+impl<N: EigenScalar + RealField, D: Dim> Eigen<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     /// Computes the eigenvalues and eigenvectors of the square matrix `m`.
@@ -101,7 +101,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 
         lapack_check!(info);
 
-        let mut work = unsafe { ::uninitialized_vec(lwork as usize) };
+        let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
         match (left_eigenvectors, eigenvectors) {
             (true, true) => {
@@ -263,7 +263,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 
         lapack_panic!(info);
 
-        let mut work = unsafe { ::uninitialized_vec(lwork as usize) };
+        let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
         N::xgeev(
             b'N',
diff --git a/nalgebra-lapack/src/hessenberg.rs b/nalgebra-lapack/src/hessenberg.rs
index 65a27d1ea..c9f8d2821 100644
--- a/nalgebra-lapack/src/hessenberg.rs
+++ b/nalgebra-lapack/src/hessenberg.rs
@@ -5,7 +5,7 @@ use na::allocator::Allocator;
 use na::dimension::{DimDiff, DimSub, U1};
 use na::storage::Storage;
 use na::{DefaultAllocator, Matrix, MatrixN, Scalar, VectorN};
-use ComplexHelper;
+use crate::ComplexHelper;
 
 use lapack;
 
@@ -66,7 +66,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>
         let mut info = 0;
         let lwork =
             N::xgehrd_work_size(n, 1, n, m.as_mut_slice(), n, tau.as_mut_slice(), &mut info);
-        let mut work = unsafe { ::uninitialized_vec(lwork as usize) };
+        let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
         lapack_panic!(info);
 
diff --git a/nalgebra-lapack/src/lib.rs b/nalgebra-lapack/src/lib.rs
index c343ba836..a1a7b7b79 100644
--- a/nalgebra-lapack/src/lib.rs
+++ b/nalgebra-lapack/src/lib.rs
@@ -98,7 +98,7 @@ pub use self::eigen::Eigen;
 pub use self::hessenberg::Hessenberg;
 pub use self::lu::{LUScalar, LU};
 pub use self::qr::QR;
-pub use self::schur::RealSchur;
+pub use self::schur::Schur;
 pub use self::svd::SVD;
 pub use self::symmetric_eigen::SymmetricEigen;
 
diff --git a/nalgebra-lapack/src/lu.rs b/nalgebra-lapack/src/lu.rs
index ad76e2451..ada9bb34e 100644
--- a/nalgebra-lapack/src/lu.rs
+++ b/nalgebra-lapack/src/lu.rs
@@ -5,7 +5,7 @@ use na::allocator::Allocator;
 use na::dimension::{Dim, DimMin, DimMinimum, U1};
 use na::storage::Storage;
 use na::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar, VectorN};
-use ComplexHelper;
+use crate::ComplexHelper;
 
 use lapack;
 
@@ -214,7 +214,7 @@ where
         }
     }
 
-    /// Solves the linear system `self.conjugate_transpose() * x = b`, where `x` is the unknown to
+    /// Solves the linear system `self.adjoint() * x = b`, where `x` is the unknown to
     /// be determined.
     pub fn solve_conjugate_transpose<R2: Dim, C2: Dim, S2>(
         &self,
@@ -249,11 +249,11 @@ where
         self.generic_solve_mut(b'T', b)
     }
 
-    /// Solves in-place the linear system `self.conjugate_transpose() * x = b`, where `x` is the unknown to
+    /// Solves in-place the linear system `self.adjoint() * x = b`, where `x` is the unknown to
     /// be determined.
     ///
     /// Returns `false` if no solution was found (the decomposed matrix is singular).
-    pub fn solve_conjugate_transpose_mut<R2: Dim, C2: Dim>(
+    pub fn solve_adjoint_mut<R2: Dim, C2: Dim>(
         &self,
         b: &mut MatrixMN<N, R2, C2>,
     ) -> bool
@@ -283,7 +283,7 @@ where
         );
         lapack_check!(info);
 
-        let mut work = unsafe { ::uninitialized_vec(lwork as usize) };
+        let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
         N::xgetri(
             dim,
diff --git a/nalgebra-lapack/src/qr.rs b/nalgebra-lapack/src/qr.rs
index 1fa9b0664..5d4b3108a 100644
--- a/nalgebra-lapack/src/qr.rs
+++ b/nalgebra-lapack/src/qr.rs
@@ -8,7 +8,7 @@ use na::allocator::Allocator;
 use na::dimension::{Dim, DimMin, DimMinimum, U1};
 use na::storage::Storage;
 use na::{DefaultAllocator, Matrix, MatrixMN, Scalar, VectorN};
-use ComplexHelper;
+use crate::ComplexHelper;
 
 use lapack;
 
@@ -73,7 +73,7 @@ where DefaultAllocator: Allocator<N, R, C>
             &mut info,
         );
 
-        let mut work = unsafe { ::uninitialized_vec(lwork as usize) };
+        let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
         N::xgeqrf(
             nrows.value() as i32,
diff --git a/nalgebra-lapack/src/schur.rs b/nalgebra-lapack/src/schur.rs
index a09b31ff3..eb618fe9c 100644
--- a/nalgebra-lapack/src/schur.rs
+++ b/nalgebra-lapack/src/schur.rs
@@ -4,13 +4,13 @@ use serde::{Deserialize, Serialize};
 use num::Zero;
 use num_complex::Complex;
 
-use alga::general::Real;
+use alga::general::RealField;
 
 use na::allocator::Allocator;
 use na::dimension::{Dim, U1};
 use na::storage::Storage;
 use na::{DefaultAllocator, Matrix, MatrixN, Scalar, VectorN};
-use ComplexHelper;
+use crate::ComplexHelper;
 
 use lapack;
 
@@ -33,7 +33,7 @@ use lapack;
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct RealSchur<N: Scalar, D: Dim>
+pub struct Schur<N: Scalar, D: Dim>
 where DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>
 {
     re: VectorN<N, D>,
@@ -42,21 +42,21 @@ where DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>
     q: MatrixN<N, D>,
 }
 
-impl<N: Scalar, D: Dim> Copy for RealSchur<N, D>
+impl<N: Scalar, D: Dim> Copy for Schur<N, D>
 where
     DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
     MatrixN<N, D>: Copy,
     VectorN<N, D>: Copy,
 {}
 
-impl<N: RealSchurScalar + Real, D: Dim> RealSchur<N, D>
+impl<N: SchurScalar + RealField, D: Dim> Schur<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     /// Computes the eigenvalues and real Schur form of the matrix `m`.
     ///
     /// Panics if the method did not converge.
     pub fn new(m: MatrixN<N, D>) -> Self {
-        Self::try_new(m).expect("RealSchur decomposition: convergence failed.")
+        Self::try_new(m).expect("Schur decomposition: convergence failed.")
     }
 
     /// Computes the eigenvalues and real Schur form of the matrix `m`.
@@ -98,7 +98,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
         );
         lapack_check!(info);
 
-        let mut work = unsafe { ::uninitialized_vec(lwork as usize) };
+        let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
         N::xgees(
             b'V',
@@ -118,7 +118,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
         );
         lapack_check!(info);
 
-        Some(RealSchur {
+        Some(Schur {
             re: wr,
             im: wi,
             t: m,
@@ -161,8 +161,8 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
  * Lapack functions dispatch.
  *
  */
-/// Trait implemented by scalars for which Lapack implements the Real Schur decomposition.
-pub trait RealSchurScalar: Scalar {
+/// Trait implemented by scalars for which Lapack implements the RealField Schur decomposition.
+pub trait SchurScalar: Scalar {
     #[allow(missing_docs)]
     fn xgees(
         jobvs: u8,
@@ -202,7 +202,7 @@ pub trait RealSchurScalar: Scalar {
 
 macro_rules! real_eigensystem_scalar_impl (
     ($N: ty, $xgees: path) => (
-        impl RealSchurScalar for $N {
+        impl SchurScalar for $N {
             #[inline]
             fn xgees(jobvs:  u8,
                      sort:   u8,
diff --git a/nalgebra-lapack/src/svd.rs b/nalgebra-lapack/src/svd.rs
index 2d048bf3b..9363fcedb 100644
--- a/nalgebra-lapack/src/svd.rs
+++ b/nalgebra-lapack/src/svd.rs
@@ -109,7 +109,7 @@ macro_rules! svd_impl(
                 let mut work  = [ 0.0 ];
                 let mut lwork = -1 as i32;
                 let mut info  = 0;
-                let mut iwork = unsafe { ::uninitialized_vec(8 * cmp::min(nrows.value(), ncols.value())) };
+                let mut iwork = unsafe { crate::uninitialized_vec(8 * cmp::min(nrows.value(), ncols.value())) };
 
                 unsafe {
                     $lapack_func(job, nrows.value() as i32, ncols.value() as i32, m.as_mut_slice(),
@@ -119,7 +119,7 @@ macro_rules! svd_impl(
                 lapack_check!(info);
 
                 lwork = work[0] as i32;
-                let mut work = unsafe { ::uninitialized_vec(lwork as usize) };
+                let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
                 unsafe {
                 $lapack_func(job, nrows.value() as i32, ncols.value() as i32, m.as_mut_slice(),
diff --git a/nalgebra-lapack/src/symmetric_eigen.rs b/nalgebra-lapack/src/symmetric_eigen.rs
index 48e444ba7..d34b3fcec 100644
--- a/nalgebra-lapack/src/symmetric_eigen.rs
+++ b/nalgebra-lapack/src/symmetric_eigen.rs
@@ -4,13 +4,13 @@ use serde::{Deserialize, Serialize};
 use num::Zero;
 use std::ops::MulAssign;
 
-use alga::general::Real;
+use alga::general::RealField;
 
 use na::allocator::Allocator;
 use na::dimension::{Dim, U1};
 use na::storage::Storage;
 use na::{DefaultAllocator, Matrix, MatrixN, Scalar, VectorN};
-use ComplexHelper;
+use crate::ComplexHelper;
 
 use lapack;
 
@@ -52,7 +52,7 @@ where
     VectorN<N, D>: Copy,
 {}
 
-impl<N: SymmetricEigenScalar + Real, D: Dim> SymmetricEigen<N, D>
+impl<N: SymmetricEigenScalar + RealField, D: Dim> SymmetricEigen<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     /// Computes the eigenvalues and eigenvectors of the symmetric matrix `m`.
@@ -102,7 +102,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
         let lwork = N::xsyev_work_size(jobz, b'L', n as i32, m.as_mut_slice(), lda, &mut info);
         lapack_check!(info);
 
-        let mut work = unsafe { ::uninitialized_vec(lwork as usize) };
+        let mut work = unsafe { crate::uninitialized_vec(lwork as usize) };
 
         N::xsyev(
             jobz,
diff --git a/nalgebra-lapack/tests/linalg/mod.rs b/nalgebra-lapack/tests/linalg/mod.rs
index ba2283085..a67422172 100644
--- a/nalgebra-lapack/tests/linalg/mod.rs
+++ b/nalgebra-lapack/tests/linalg/mod.rs
@@ -2,6 +2,6 @@ mod cholesky;
 mod lu;
 mod qr;
 mod real_eigensystem;
-mod real_schur;
+mod schur;
 mod svd;
 mod symmetric_eigen;
diff --git a/nalgebra-lapack/tests/linalg/real_schur.rs b/nalgebra-lapack/tests/linalg/schur.rs
similarity index 73%
rename from nalgebra-lapack/tests/linalg/real_schur.rs
rename to nalgebra-lapack/tests/linalg/schur.rs
index 127107dd3..ccdb0f0b9 100644
--- a/nalgebra-lapack/tests/linalg/real_schur.rs
+++ b/nalgebra-lapack/tests/linalg/schur.rs
@@ -1,5 +1,5 @@
 use na::{DMatrix, Matrix4};
-use nl::RealSchur;
+use nl::Schur;
 use std::cmp;
 
 quickcheck! {
@@ -7,13 +7,13 @@ quickcheck! {
         let n = cmp::max(1, cmp::min(n, 10));
         let m = DMatrix::<f64>::new_random(n, n);
 
-        let (vecs, vals) = RealSchur::new(m.clone()).unpack();
+        let (vecs, vals) = Schur::new(m.clone()).unpack();
 
         relative_eq!(&vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7)
     }
 
     fn schur_static(m: Matrix4<f64>) -> bool {
-        let (vecs, vals) = RealSchur::new(m.clone()).unpack();
+        let (vecs, vals) = Schur::new(m.clone()).unpack();
 
         relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7)
     }
diff --git a/src/base/alias.rs b/src/base/alias.rs
index f7ca2b340..a8925cf32 100644
--- a/src/base/alias.rs
+++ b/src/base/alias.rs
@@ -1,10 +1,10 @@
 #[cfg(any(feature = "alloc", feature = "std"))]
-use base::dimension::Dynamic;
-use base::dimension::{U1, U2, U3, U4, U5, U6};
+use crate::base::dimension::Dynamic;
+use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
 #[cfg(any(feature = "std", feature = "alloc"))]
-use base::vec_storage::VecStorage;
-use base::storage::Owned;
-use base::Matrix;
+use crate::base::vec_storage::VecStorage;
+use crate::base::storage::Owned;
+use crate::base::Matrix;
 
 /*
  *
diff --git a/src/base/alias_slice.rs b/src/base/alias_slice.rs
index 790e4e599..3a332defb 100644
--- a/src/base/alias_slice.rs
+++ b/src/base/alias_slice.rs
@@ -1,6 +1,6 @@
-use base::dimension::{Dynamic, U1, U2, U3, U4, U5, U6};
-use base::matrix_slice::{SliceStorage, SliceStorageMut};
-use base::Matrix;
+use crate::base::dimension::{Dynamic, U1, U2, U3, U4, U5, U6};
+use crate::base::matrix_slice::{SliceStorage, SliceStorageMut};
+use crate::base::Matrix;
 
 /*
  *
diff --git a/src/base/allocator.rs b/src/base/allocator.rs
index 5b17c1831..0ad309816 100644
--- a/src/base/allocator.rs
+++ b/src/base/allocator.rs
@@ -2,10 +2,10 @@
 
 use std::any::Any;
 
-use base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
-use base::dimension::{Dim, U1};
-use base::storage::ContiguousStorageMut;
-use base::{DefaultAllocator, Scalar};
+use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
+use crate::base::dimension::{Dim, U1};
+use crate::base::storage::ContiguousStorageMut;
+use crate::base::{DefaultAllocator, Scalar};
 
 /// A matrix allocator of a memory buffer that may contain `R::to_usize() * C::to_usize()`
 /// elements of type `N`.
diff --git a/src/base/array_storage.rs b/src/base/array_storage.rs
index 3beab9e16..bebb8740b 100644
--- a/src/base/array_storage.rs
+++ b/src/base/array_storage.rs
@@ -21,11 +21,11 @@ use abomonation::Abomonation;
 use generic_array::{ArrayLength, GenericArray};
 use typenum::Prod;
 
-use base::allocator::Allocator;
-use base::default_allocator::DefaultAllocator;
-use base::dimension::{DimName, U1};
-use base::storage::{ContiguousStorage, ContiguousStorageMut, Owned, Storage, StorageMut};
-use base::Scalar;
+use crate::base::allocator::Allocator;
+use crate::base::default_allocator::DefaultAllocator;
+use crate::base::dimension::{DimName, U1};
+use crate::base::storage::{ContiguousStorage, ContiguousStorageMut, Owned, Storage, StorageMut};
+use crate::base::Scalar;
 
 /*
  *
@@ -330,7 +330,7 @@ where
         let mut out: Self::Value = unsafe { mem::uninitialized() };
         let mut curr = 0;
 
-        while let Some(value) = try!(visitor.next_element()) {
+        while let Some(value) = visitor.next_element()? {
             *out.get_mut(curr).ok_or_else(|| V::Error::invalid_length(curr, &self))? = value;
             curr += 1;
         }
diff --git a/src/base/blas.rs b/src/base/blas.rs
index be71a1070..6e1b6c818 100644
--- a/src/base/blas.rs
+++ b/src/base/blas.rs
@@ -1,17 +1,52 @@
-use alga::general::{ClosedAdd, ClosedMul};
+use alga::general::{ClosedAdd, ClosedMul, ComplexField};
 #[cfg(feature = "std")]
 use matrixmultiply;
 use num::{One, Signed, Zero};
 #[cfg(feature = "std")]
 use std::mem;
 
-use base::allocator::Allocator;
-use base::constraint::{
+use crate::base::allocator::Allocator;
+use crate::base::constraint::{
     AreMultipliable, DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint,
 };
-use base::dimension::{Dim, Dynamic, U1, U2, U3, U4};
-use base::storage::{Storage, StorageMut};
-use base::{DefaultAllocator, Matrix, Scalar, SquareMatrix, Vector};
+use crate::base::dimension::{Dim, Dynamic, U1, U2, U3, U4};
+use crate::base::storage::{Storage, StorageMut};
+use crate::base::{DefaultAllocator, Matrix, Scalar, SquareMatrix, Vector, DVectorSlice, VectorSliceN};
+
+
+// FIXME: find a way to avoid code duplication just for complex number support.
+impl<N: ComplexField, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
+    /// Computes the index of the vector component with the largest complex or real absolute value.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # extern crate num_complex;
+    /// # extern crate nalgebra;
+    /// # use num_complex::Complex;
+    /// # use nalgebra::Vector3;
+    /// let vec = Vector3::new(Complex::new(11.0, 3.0), Complex::new(-15.0, 0.0), Complex::new(13.0, 5.0));
+    /// assert_eq!(vec.icamax(), 2);
+    /// ```
+    #[inline]
+    pub fn icamax(&self) -> usize {
+        assert!(!self.is_empty(), "The input vector must not be empty.");
+
+        let mut the_max = unsafe { self.vget_unchecked(0).norm1() };
+        let mut the_i = 0;
+
+        for i in 1..self.nrows() {
+            let val = unsafe { self.vget_unchecked(i).norm1() };
+
+            if val > the_max {
+                the_max = val;
+                the_i = i;
+            }
+        }
+
+        the_i
+    }
+}
 
 impl<N: Scalar + PartialOrd, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
     /// Computes the index and value of the vector component with the largest value.
@@ -157,6 +192,44 @@ impl<N: Scalar + PartialOrd, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
     }
 }
 
+// FIXME: find a way to avoid code duplication just for complex number support.
+impl<N: ComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+    /// Computes the index of the matrix component with the largest absolute value.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # extern crate num_complex;
+    /// # extern crate nalgebra;
+    /// # use num_complex::Complex;
+    /// # use nalgebra::Matrix2x3;
+    /// let mat = Matrix2x3::new(Complex::new(11.0, 1.0), Complex::new(-12.0, 2.0), Complex::new(13.0, 3.0),
+    ///                          Complex::new(21.0, 43.0), Complex::new(22.0, 5.0), Complex::new(-23.0, 0.0));
+    /// assert_eq!(mat.icamax_full(), (1, 0));
+    /// ```
+    #[inline]
+    pub fn icamax_full(&self) -> (usize, usize) {
+        assert!(!self.is_empty(), "The input matrix must not be empty.");
+
+        let mut the_max = unsafe { self.get_unchecked((0, 0)).norm1() };
+        let mut the_ij = (0, 0);
+
+        for j in 0..self.ncols() {
+            for i in 0..self.nrows() {
+                let val = unsafe { self.get_unchecked((i, j)).norm1() };
+
+                if val > the_max {
+                    the_max = val;
+                    the_ij = (i, j);
+                }
+            }
+        }
+
+        the_ij
+    }
+}
+
+
 impl<N: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Computes the index of the matrix component with the largest absolute value.
     ///
@@ -193,30 +266,11 @@ impl<N: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<N, R, C>> Matri
 impl<N, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
 where N: Scalar + Zero + ClosedAdd + ClosedMul
 {
-    /// The dot product between two vectors or matrices (seen as vectors).
-    ///
-    /// Note that this is **not** the matrix multiplication as in, e.g., numpy. For matrix
-    /// multiplication, use one of: `.gemm`, `.mul_to`, `.mul`, the `*` operator.
-    ///
-    /// # Examples:
-    ///
-    /// ```
-    /// # use nalgebra::{Vector3, Matrix2x3};
-    /// let vec1 = Vector3::new(1.0, 2.0, 3.0);
-    /// let vec2 = Vector3::new(0.1, 0.2, 0.3);
-    /// assert_eq!(vec1.dot(&vec2), 1.4);
-    ///
-    /// let mat1 = Matrix2x3::new(1.0, 2.0, 3.0,
-    ///                           4.0, 5.0, 6.0);
-    /// let mat2 = Matrix2x3::new(0.1, 0.2, 0.3,
-    ///                           0.4, 0.5, 0.6);
-    /// assert_eq!(mat1.dot(&mat2), 9.1);
-    /// ```
-    #[inline]
-    pub fn dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N
-    where
-        SB: Storage<N, R2, C2>,
-        ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
+    #[inline(always)]
+    fn dotx<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>, conjugate: impl Fn(N) -> N) -> N
+        where
+            SB: Storage<N, R2, C2>,
+            ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
     {
         assert!(
             self.nrows() == rhs.nrows(),
@@ -227,27 +281,27 @@ where N: Scalar + Zero + ClosedAdd + ClosedMul
         // because the `for` loop below won't be very efficient on those.
         if (R::is::<U2>() || R2::is::<U2>()) && (C::is::<U1>() || C2::is::<U1>()) {
             unsafe {
-                let a = *self.get_unchecked((0, 0)) * *rhs.get_unchecked((0, 0));
-                let b = *self.get_unchecked((1, 0)) * *rhs.get_unchecked((1, 0));
+                let a = conjugate(*self.get_unchecked((0, 0))) * *rhs.get_unchecked((0, 0));
+                let b = conjugate(*self.get_unchecked((1, 0))) * *rhs.get_unchecked((1, 0));
 
                 return a + b;
             }
         }
         if (R::is::<U3>() || R2::is::<U3>()) && (C::is::<U1>() || C2::is::<U1>()) {
             unsafe {
-                let a = *self.get_unchecked((0, 0)) * *rhs.get_unchecked((0, 0));
-                let b = *self.get_unchecked((1, 0)) * *rhs.get_unchecked((1, 0));
-                let c = *self.get_unchecked((2, 0)) * *rhs.get_unchecked((2, 0));
+                let a = conjugate(*self.get_unchecked((0, 0))) * *rhs.get_unchecked((0, 0));
+                let b = conjugate(*self.get_unchecked((1, 0))) * *rhs.get_unchecked((1, 0));
+                let c = conjugate(*self.get_unchecked((2, 0))) * *rhs.get_unchecked((2, 0));
 
                 return a + b + c;
             }
         }
         if (R::is::<U4>() || R2::is::<U4>()) && (C::is::<U1>() || C2::is::<U1>()) {
             unsafe {
-                let mut a = *self.get_unchecked((0, 0)) * *rhs.get_unchecked((0, 0));
-                let mut b = *self.get_unchecked((1, 0)) * *rhs.get_unchecked((1, 0));
-                let c = *self.get_unchecked((2, 0)) * *rhs.get_unchecked((2, 0));
-                let d = *self.get_unchecked((3, 0)) * *rhs.get_unchecked((3, 0));
+                let mut a = conjugate(*self.get_unchecked((0, 0))) * *rhs.get_unchecked((0, 0));
+                let mut b = conjugate(*self.get_unchecked((1, 0))) * *rhs.get_unchecked((1, 0));
+                let c = conjugate(*self.get_unchecked((2, 0))) * *rhs.get_unchecked((2, 0));
+                let d = conjugate(*self.get_unchecked((3, 0))) * *rhs.get_unchecked((3, 0));
 
                 a += c;
                 b += d;
@@ -287,14 +341,14 @@ where N: Scalar + Zero + ClosedAdd + ClosedMul
             acc7 = N::zero();
 
             while self.nrows() - i >= 8 {
-                acc0 += unsafe { *self.get_unchecked((i + 0, j)) * *rhs.get_unchecked((i + 0, j)) };
-                acc1 += unsafe { *self.get_unchecked((i + 1, j)) * *rhs.get_unchecked((i + 1, j)) };
-                acc2 += unsafe { *self.get_unchecked((i + 2, j)) * *rhs.get_unchecked((i + 2, j)) };
-                acc3 += unsafe { *self.get_unchecked((i + 3, j)) * *rhs.get_unchecked((i + 3, j)) };
-                acc4 += unsafe { *self.get_unchecked((i + 4, j)) * *rhs.get_unchecked((i + 4, j)) };
-                acc5 += unsafe { *self.get_unchecked((i + 5, j)) * *rhs.get_unchecked((i + 5, j)) };
-                acc6 += unsafe { *self.get_unchecked((i + 6, j)) * *rhs.get_unchecked((i + 6, j)) };
-                acc7 += unsafe { *self.get_unchecked((i + 7, j)) * *rhs.get_unchecked((i + 7, j)) };
+                acc0 += unsafe { conjugate(*self.get_unchecked((i + 0, j))) * *rhs.get_unchecked((i + 0, j)) };
+                acc1 += unsafe { conjugate(*self.get_unchecked((i + 1, j))) * *rhs.get_unchecked((i + 1, j)) };
+                acc2 += unsafe { conjugate(*self.get_unchecked((i + 2, j))) * *rhs.get_unchecked((i + 2, j)) };
+                acc3 += unsafe { conjugate(*self.get_unchecked((i + 3, j))) * *rhs.get_unchecked((i + 3, j)) };
+                acc4 += unsafe { conjugate(*self.get_unchecked((i + 4, j))) * *rhs.get_unchecked((i + 4, j)) };
+                acc5 += unsafe { conjugate(*self.get_unchecked((i + 5, j))) * *rhs.get_unchecked((i + 5, j)) };
+                acc6 += unsafe { conjugate(*self.get_unchecked((i + 6, j))) * *rhs.get_unchecked((i + 6, j)) };
+                acc7 += unsafe { conjugate(*self.get_unchecked((i + 7, j))) * *rhs.get_unchecked((i + 7, j)) };
                 i += 8;
             }
 
@@ -304,13 +358,75 @@ where N: Scalar + Zero + ClosedAdd + ClosedMul
             res += acc3 + acc7;
 
             for k in i..self.nrows() {
-                res += unsafe { *self.get_unchecked((k, j)) * *rhs.get_unchecked((k, j)) }
+                res += unsafe { conjugate(*self.get_unchecked((k, j))) * *rhs.get_unchecked((k, j)) }
             }
         }
 
         res
     }
 
+
+    /// The dot product between two vectors or matrices (seen as vectors).
+    ///
+    /// This is equal to `self.transpose() * rhs`. For the sesquilinear complex dot product, use
+    /// `self.dotc(rhs)`.
+    ///
+    /// Note that this is **not** the matrix multiplication as in, e.g., numpy. For matrix
+    /// multiplication, use one of: `.gemm`, `.mul_to`, `.mul`, the `*` operator.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # use nalgebra::{Vector3, Matrix2x3};
+    /// let vec1 = Vector3::new(1.0, 2.0, 3.0);
+    /// let vec2 = Vector3::new(0.1, 0.2, 0.3);
+    /// assert_eq!(vec1.dot(&vec2), 1.4);
+    ///
+    /// let mat1 = Matrix2x3::new(1.0, 2.0, 3.0,
+    ///                           4.0, 5.0, 6.0);
+    /// let mat2 = Matrix2x3::new(0.1, 0.2, 0.3,
+    ///                           0.4, 0.5, 0.6);
+    /// assert_eq!(mat1.dot(&mat2), 9.1);
+    /// ```
+    ///
+    #[inline]
+    pub fn dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N
+    where
+        SB: Storage<N, R2, C2>,
+        ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
+    {
+        self.dotx(rhs, |e| e)
+    }
+
+    /// The conjugate-linear dot product between two vectors or matrices (seen as vectors).
+    ///
+    /// This is equal to `self.adjoint() * rhs`.
+    /// For real vectors, this is identical to `self.dot(&rhs)`.
+    /// Note that this is **not** the matrix multiplication as in, e.g., numpy. For matrix
+    /// multiplication, use one of: `.gemm`, `.mul_to`, `.mul`, the `*` operator.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # use nalgebra::{Vector2, Complex};
+    /// let vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
+    /// let vec2 = Vector2::new(Complex::new(0.4, 0.3), Complex::new(0.2, 0.1));
+    /// assert_eq!(vec1.dotc(&vec2), Complex::new(2.0, -1.0));
+    ///
+    /// // Note that for complex vectors, we generally have:
+    /// // vec1.dotc(&vec2) != vec2.dot(&vec2)
+    /// assert_ne!(vec1.dotc(&vec2), vec1.dot(&vec2));
+    /// ```
+    #[inline]
+    pub fn dotc<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N
+        where
+            N: ComplexField,
+            SB: Storage<N, R2, C2>,
+            ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
+    {
+        self.dotx(rhs, ComplexField::conjugate)
+    }
+
     /// The dot product between the transpose of `self` and `rhs`.
     ///
     /// # Examples:
@@ -465,40 +581,15 @@ where
         }
     }
 
-    /// Computes `self = alpha * a * x + beta * self`, where `a` is a **symmetric** matrix, `x` a
-    /// vector, and `alpha, beta` two scalars.
-    ///
-    /// If `beta` is zero, `self` is never read. If `self` is read, only its lower-triangular part
-    /// (including the diagonal) is actually read.
-    ///
-    /// # Examples:
-    ///
-    /// ```
-    /// # use nalgebra::{Matrix2, Vector2};
-    /// let mat = Matrix2::new(1.0, 2.0,
-    ///                        2.0, 4.0);
-    /// let mut vec1 = Vector2::new(1.0, 2.0);
-    /// let vec2 = Vector2::new(0.1, 0.2);
-    /// vec1.gemv_symm(10.0, &mat, &vec2, 5.0);
-    /// assert_eq!(vec1, Vector2::new(10.0, 20.0));
-    ///
-    ///
-    /// // The matrix upper-triangular elements can be garbage because it is never
-    /// // read by this method. Therefore, it is not necessary for the caller to
-    /// // fill the matrix struct upper-triangle.
-    /// let mat = Matrix2::new(1.0, 9999999.9999999,
-    ///                        2.0, 4.0);
-    /// let mut vec1 = Vector2::new(1.0, 2.0);
-    /// vec1.gemv_symm(10.0, &mat, &vec2, 5.0);
-    /// assert_eq!(vec1, Vector2::new(10.0, 20.0));
-    /// ```
-    #[inline]
-    pub fn gemv_symm<D2: Dim, D3: Dim, SB, SC>(
+
+    #[inline(always)]
+    fn xxgemv<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
         alpha: N,
         a: &SquareMatrix<N, D2, SB>,
         x: &Vector<N, D3, SC>,
         beta: N,
+        dot: impl Fn(&DVectorSlice<N, SB::RStride, SB::CStride>, &DVectorSlice<N, SC::RStride, SC::CStride>) -> N,
     ) where
         N: One,
         SB: Storage<N, D2, D2>,
@@ -511,11 +602,11 @@ where
 
         assert!(
             a.is_square(),
-            "Syetric gemv: the input matrix must be square."
+            "Symmetric cgemv: the input matrix must be square."
         );
         assert!(
             dim2 == dim3 && dim1 == dim2,
-            "Symmetric gemv: dimensions mismatch."
+            "Symmetric cgemv: dimensions mismatch."
         );
 
         if dim2 == 0 {
@@ -526,11 +617,11 @@ where
         let col2 = a.column(0);
         let val = unsafe { *x.vget_unchecked(0) };
         self.axpy(alpha * val, &col2, beta);
-        self[0] += alpha * x.rows_range(1..).dot(&a.slice_range(1.., 0));
+        self[0] += alpha * dot(&a.slice_range(1.., 0), &x.rows_range(1..));
 
         for j in 1..dim2 {
             let col2 = a.column(j);
-            let dot = x.rows_range(j..).dot(&col2.rows_range(j..));
+            let dot = dot(&col2.rows_range(j..), &x.rows_range(j..));
 
             let val;
             unsafe {
@@ -542,31 +633,123 @@ where
         }
     }
 
-    /// Computes `self = alpha * a.transpose() * x + beta * self`, where `a` is a matrix, `x` a vector, and
-    /// `alpha, beta` two scalars.
+    /// Computes `self = alpha * a * x + beta * self`, where `a` is a **symmetric** matrix, `x` a
+    /// vector, and `alpha, beta` two scalars. DEPRECATED: use `sygemv` instead.
+    #[inline]
+    #[deprecated(note = "This is renamed `sygemv` to match the original BLAS terminology.")]
+    pub fn gemv_symm<D2: Dim, D3: Dim, SB, SC>(
+        &mut self,
+        alpha: N,
+        a: &SquareMatrix<N, D2, SB>,
+        x: &Vector<N, D3, SC>,
+        beta: N,
+    ) where
+        N: One,
+        SB: Storage<N, D2, D2>,
+        SC: Storage<N, D3>,
+        ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
+    {
+        self.sygemv(alpha, a, x, beta)
+    }
+
+    /// Computes `self = alpha * a * x + beta * self`, where `a` is a **symmetric** matrix, `x` a
+    /// vector, and `alpha, beta` two scalars.
     ///
-    /// If `beta` is zero, `self` is never read.
+    /// For hermitian matrices, use `.hegemv` instead.
+    /// If `beta` is zero, `self` is never read. If `self` is read, only its lower-triangular part
+    /// (including the diagonal) is actually read.
     ///
     /// # Examples:
     ///
     /// ```
     /// # use nalgebra::{Matrix2, Vector2};
-    /// let mat = Matrix2::new(1.0, 3.0,
+    /// let mat = Matrix2::new(1.0, 2.0,
     ///                        2.0, 4.0);
     /// let mut vec1 = Vector2::new(1.0, 2.0);
     /// let vec2 = Vector2::new(0.1, 0.2);
-    /// let expected = mat.transpose() * vec2 * 10.0 + vec1 * 5.0;
+    /// vec1.sygemv(10.0, &mat, &vec2, 5.0);
+    /// assert_eq!(vec1, Vector2::new(10.0, 20.0));
     ///
-    /// vec1.gemv_tr(10.0, &mat, &vec2, 5.0);
-    /// assert_eq!(vec1, expected);
+    ///
+    /// // The matrix upper-triangular elements can be garbage because it is never
+    /// // read by this method. Therefore, it is not necessary for the caller to
+    /// // fill the matrix struct upper-triangle.
+    /// let mat = Matrix2::new(1.0, 9999999.9999999,
+    ///                        2.0, 4.0);
+    /// let mut vec1 = Vector2::new(1.0, 2.0);
+    /// vec1.sygemv(10.0, &mat, &vec2, 5.0);
+    /// assert_eq!(vec1, Vector2::new(10.0, 20.0));
     /// ```
     #[inline]
-    pub fn gemv_tr<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
+    pub fn sygemv<D2: Dim, D3: Dim, SB, SC>(
+        &mut self,
+        alpha: N,
+        a: &SquareMatrix<N, D2, SB>,
+        x: &Vector<N, D3, SC>,
+        beta: N,
+    ) where
+        N: One,
+        SB: Storage<N, D2, D2>,
+        SC: Storage<N, D3>,
+        ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
+    {
+        self.xxgemv(alpha, a, x, beta, |a, b| a.dot(b))
+    }
+
+    /// Computes `self = alpha * a * x + beta * self`, where `a` is an **hermitian** matrix, `x` a
+    /// vector, and `alpha, beta` two scalars.
+    ///
+    /// If `beta` is zero, `self` is never read. If `self` is read, only its lower-triangular part
+    /// (including the diagonal) is actually read.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # use nalgebra::{Matrix2, Vector2, Complex};
+    /// let mat = Matrix2::new(Complex::new(1.0, 0.0), Complex::new(2.0, -0.1),
+    ///                        Complex::new(2.0, 1.0), Complex::new(4.0, 0.0));
+    /// let mut vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
+    /// let vec2 = Vector2::new(Complex::new(0.1, 0.2), Complex::new(0.3, 0.4));
+    /// vec1.sygemv(Complex::new(10.0, 20.0), &mat, &vec2, Complex::new(5.0, 15.0));
+    /// assert_eq!(vec1, Vector2::new(Complex::new(-48.0, 44.0), Complex::new(-75.0, 110.0)));
+    ///
+    ///
+    /// // The matrix upper-triangular elements can be garbage because it is never
+    /// // read by this method. Therefore, it is not necessary for the caller to
+    /// // fill the matrix struct upper-triangle.
+    ///
+    /// let mat = Matrix2::new(Complex::new(1.0, 0.0), Complex::new(99999999.9, 999999999.9),
+    ///                        Complex::new(2.0, 1.0), Complex::new(4.0, 0.0));
+    /// let mut vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
+    /// let vec2 = Vector2::new(Complex::new(0.1, 0.2), Complex::new(0.3, 0.4));
+    /// vec1.sygemv(Complex::new(10.0, 20.0), &mat, &vec2, Complex::new(5.0, 15.0));
+    /// assert_eq!(vec1, Vector2::new(Complex::new(-48.0, 44.0), Complex::new(-75.0, 110.0)));
+    /// ```
+    #[inline]
+    pub fn hegemv<D2: Dim, D3: Dim, SB, SC>(
+        &mut self,
+        alpha: N,
+        a: &SquareMatrix<N, D2, SB>,
+        x: &Vector<N, D3, SC>,
+        beta: N,
+    ) where
+        N: ComplexField,
+        SB: Storage<N, D2, D2>,
+        SC: Storage<N, D3>,
+        ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
+    {
+        self.xxgemv(alpha, a, x, beta, |a, b| a.dotc(b))
+    }
+
+
+    #[inline(always)]
+    fn gemv_xx<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
         &mut self,
         alpha: N,
         a: &Matrix<N, R2, C2, SB>,
         x: &Vector<N, D3, SC>,
         beta: N,
+        dot: impl Fn(&VectorSliceN<N, R2, SB::RStride, SB::CStride>, &Vector<N, D3, SC>) -> N,
     ) where
         N: One,
         SB: Storage<N, R2, C2>,
@@ -589,20 +772,120 @@ where
         if beta.is_zero() {
             for j in 0..ncols2 {
                 let val = unsafe { self.vget_unchecked_mut(j) };
-                *val = alpha * a.column(j).dot(x)
+                *val = alpha * dot(&a.column(j), x)
             }
         } else {
             for j in 0..ncols2 {
                 let val = unsafe { self.vget_unchecked_mut(j) };
-                *val = alpha * a.column(j).dot(x) + beta * *val;
+                *val = alpha * dot(&a.column(j), x) + beta * *val;
             }
         }
     }
+
+
+    /// Computes `self = alpha * a.transpose() * x + beta * self`, where `a` is a matrix, `x` a vector, and
+    /// `alpha, beta` two scalars.
+    ///
+    /// If `beta` is zero, `self` is never read.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # use nalgebra::{Matrix2, Vector2};
+    /// let mat = Matrix2::new(1.0, 3.0,
+    ///                        2.0, 4.0);
+    /// let mut vec1 = Vector2::new(1.0, 2.0);
+    /// let vec2 = Vector2::new(0.1, 0.2);
+    /// let expected = mat.transpose() * vec2 * 10.0 + vec1 * 5.0;
+    ///
+    /// vec1.gemv_tr(10.0, &mat, &vec2, 5.0);
+    /// assert_eq!(vec1, expected);
+    /// ```
+    #[inline]
+    pub fn gemv_tr<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
+        &mut self,
+        alpha: N,
+        a: &Matrix<N, R2, C2, SB>,
+        x: &Vector<N, D3, SC>,
+        beta: N,
+    ) where
+        N: One,
+        SB: Storage<N, R2, C2>,
+        SC: Storage<N, D3>,
+        ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, U1>,
+    {
+        self.gemv_xx(alpha, a, x, beta, |a, b| a.dot(b))
+    }
+
+    /// Computes `self = alpha * a.adjoint() * x + beta * self`, where `a` is a matrix, `x` a vector, and
+    /// `alpha, beta` two scalars.
+    ///
+    /// For real matrices, this is the same as `.gemv_tr`.
+    /// If `beta` is zero, `self` is never read.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # use nalgebra::{Matrix2, Vector2, Complex};
+    /// let mat = Matrix2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0),
+    ///                        Complex::new(5.0, 6.0), Complex::new(7.0, 8.0));
+    /// let mut vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
+    /// let vec2 = Vector2::new(Complex::new(0.1, 0.2), Complex::new(0.3, 0.4));
+    /// let expected = mat.adjoint() * vec2 * Complex::new(10.0, 20.0) + vec1 * Complex::new(5.0, 15.0);
+    ///
+    /// vec1.gemv_ad(Complex::new(10.0, 20.0), &mat, &vec2, Complex::new(5.0, 15.0));
+    /// assert_eq!(vec1, expected);
+    /// ```
+    #[inline]
+    pub fn gemv_ad<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
+        &mut self,
+        alpha: N,
+        a: &Matrix<N, R2, C2, SB>,
+        x: &Vector<N, D3, SC>,
+        beta: N,
+    ) where
+        N: ComplexField,
+        SB: Storage<N, R2, C2>,
+        SC: Storage<N, D3>,
+        ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, U1>,
+    {
+        self.gemv_xx(alpha, a, x, beta, |a, b| a.dotc(b))
+    }
 }
 
 impl<N, R1: Dim, C1: Dim, S: StorageMut<N, R1, C1>> Matrix<N, R1, C1, S>
 where N: Scalar + Zero + ClosedAdd + ClosedMul
 {
+    #[inline(always)]
+    fn gerx<D2: Dim, D3: Dim, SB, SC>(
+        &mut self,
+        alpha: N,
+        x: &Vector<N, D2, SB>,
+        y: &Vector<N, D3, SC>,
+        beta: N,
+        conjugate: impl Fn(N) -> N,
+    ) where
+        N: One,
+        SB: Storage<N, D2>,
+        SC: Storage<N, D3>,
+        ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
+    {
+        let (nrows1, ncols1) = self.shape();
+        let dim2 = x.nrows();
+        let dim3 = y.nrows();
+
+        assert!(
+            nrows1 == dim2 && ncols1 == dim3,
+            "ger: dimensions mismatch."
+        );
+
+        for j in 0..ncols1 {
+            // FIXME: avoid bound checks.
+            let val = unsafe { conjugate(*y.vget_unchecked(j)) };
+            self.column_mut(j).axpy(alpha * val, x, beta);
+        }
+    }
+
     /// Computes `self = alpha * x * y.transpose() + beta * self`.
     ///
     /// If `beta` is zero, `self` is never read.
@@ -632,20 +915,40 @@ where N: Scalar + Zero + ClosedAdd + ClosedMul
         SC: Storage<N, D3>,
         ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
     {
-        let (nrows1, ncols1) = self.shape();
-        let dim2 = x.nrows();
-        let dim3 = y.nrows();
-
-        assert!(
-            nrows1 == dim2 && ncols1 == dim3,
-            "ger: dimensions mismatch."
-        );
+        self.gerx(alpha, x, y, beta, |e| e)
+    }
 
-        for j in 0..ncols1 {
-            // FIXME: avoid bound checks.
-            let val = unsafe { *y.vget_unchecked(j) };
-            self.column_mut(j).axpy(alpha * val, x, beta);
-        }
+    /// Computes `self = alpha * x * y.adjoint() + beta * self`.
+    ///
+    /// If `beta` is zero, `self` is never read.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # #[macro_use] extern crate approx;
+    /// # use nalgebra::{Matrix2x3, Vector2, Vector3, Complex};
+    /// let mut mat = Matrix2x3::repeat(Complex::new(4.0, 5.0));
+    /// let vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
+    /// let vec2 = Vector3::new(Complex::new(0.6, 0.5), Complex::new(0.4, 0.5), Complex::new(0.2, 0.1));
+    /// let expected = vec1 * vec2.adjoint() * Complex::new(10.0, 20.0) + mat * Complex::new(5.0, 15.0);
+    ///
+    /// mat.gerc(Complex::new(10.0, 20.0), &vec1, &vec2, Complex::new(5.0, 15.0));
+    /// assert_eq!(mat, expected);
+    /// ```
+    #[inline]
+    pub fn gerc<D2: Dim, D3: Dim, SB, SC>(
+        &mut self,
+        alpha: N,
+        x: &Vector<N, D2, SB>,
+        y: &Vector<N, D3, SC>,
+        beta: N,
+    ) where
+        N: ComplexField,
+        SB: Storage<N, D2>,
+        SC: Storage<N, D3>,
+        ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
+    {
+        self.gerx(alpha, x, y, beta, ComplexField::conjugate)
     }
 
     /// Computes `self = alpha * a * b + beta * self`, where `a, b, self` are matrices.
@@ -800,7 +1103,7 @@ where N: Scalar + Zero + ClosedAdd + ClosedMul
     /// let expected = mat2.transpose() * mat3 * 10.0 + mat1 * 5.0;
     ///
     /// mat1.gemm_tr(10.0, &mat2, &mat3, 5.0);
-    /// assert_relative_eq!(mat1, expected);
+    /// assert_eq!(mat1, expected);
     /// ```
     #[inline]
     pub fn gemm_tr<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
@@ -836,11 +1139,105 @@ where N: Scalar + Zero + ClosedAdd + ClosedMul
             self.column_mut(j1).gemv_tr(alpha, a, &b.column(j1), beta);
         }
     }
+
+
+    /// Computes `self = alpha * a.adjoint() * b + beta * self`, where `a, b, self` are matrices.
+    /// `alpha` and `beta` are scalar.
+    ///
+    /// If `beta` is zero, `self` is never read.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # #[macro_use] extern crate approx;
+    /// # use nalgebra::{Matrix3x2, Matrix3x4, Matrix2x4, Complex};
+    /// let mut mat1 = Matrix2x4::identity();
+    /// let mat2 = Matrix3x2::new(Complex::new(1.0, 4.0), Complex::new(7.0, 8.0),
+    ///                           Complex::new(2.0, 5.0), Complex::new(9.0, 10.0),
+    ///                           Complex::new(3.0, 6.0), Complex::new(11.0, 12.0));
+    /// let mat3 = Matrix3x4::new(Complex::new(0.1, 1.3), Complex::new(0.2, 1.4), Complex::new(0.3, 1.5), Complex::new(0.4, 1.6),
+    ///                           Complex::new(0.5, 1.7), Complex::new(0.6, 1.8), Complex::new(0.7, 1.9), Complex::new(0.8, 2.0),
+    ///                           Complex::new(0.9, 2.1), Complex::new(1.0, 2.2), Complex::new(1.1, 2.3), Complex::new(1.2, 2.4));
+    /// let expected = mat2.adjoint() * mat3 * Complex::new(10.0, 20.0) + mat1 * Complex::new(5.0, 15.0);
+    ///
+    /// mat1.gemm_ad(Complex::new(10.0, 20.0), &mat2, &mat3, Complex::new(5.0, 15.0));
+    /// assert_eq!(mat1, expected);
+    /// ```
+    #[inline]
+    pub fn gemm_ad<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
+        &mut self,
+        alpha: N,
+        a: &Matrix<N, R2, C2, SB>,
+        b: &Matrix<N, R3, C3, SC>,
+        beta: N,
+    ) where
+        N: ComplexField,
+        SB: Storage<N, R2, C2>,
+        SC: Storage<N, R3, C3>,
+        ShapeConstraint: SameNumberOfRows<R1, C2>
+        + SameNumberOfColumns<C1, C3>
+        + AreMultipliable<C2, R2, R3, C3>,
+    {
+        let (nrows1, ncols1) = self.shape();
+        let (nrows2, ncols2) = a.shape();
+        let (nrows3, ncols3) = b.shape();
+
+        assert_eq!(
+            nrows2, nrows3,
+            "gemm: dimensions mismatch for multiplication."
+        );
+        assert_eq!(
+            (nrows1, ncols1),
+            (ncols2, ncols3),
+            "gemm: dimensions mismatch for addition."
+        );
+
+        for j1 in 0..ncols1 {
+            // FIXME: avoid bound checks.
+            self.column_mut(j1).gemv_ad(alpha, a, &b.column(j1), beta);
+        }
+    }
 }
 
 impl<N, R1: Dim, C1: Dim, S: StorageMut<N, R1, C1>> Matrix<N, R1, C1, S>
 where N: Scalar + Zero + ClosedAdd + ClosedMul
 {
+    #[inline(always)]
+    fn xxgerx<D2: Dim, D3: Dim, SB, SC>(
+        &mut self,
+        alpha: N,
+        x: &Vector<N, D2, SB>,
+        y: &Vector<N, D3, SC>,
+        beta: N,
+        conjugate: impl Fn(N) -> N,
+    ) where
+        N: One,
+        SB: Storage<N, D2>,
+        SC: Storage<N, D3>,
+        ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
+    {
+        let dim1 = self.nrows();
+        let dim2 = x.nrows();
+        let dim3 = y.nrows();
+
+        assert!(
+            self.is_square(),
+            "Symmetric ger: the input matrix must be square."
+        );
+        assert!(dim1 == dim2 && dim1 == dim3, "ger: dimensions mismatch.");
+
+        for j in 0..dim1 {
+            let val = unsafe { conjugate(*y.vget_unchecked(j)) };
+            let subdim = Dynamic::new(dim1 - j);
+            // FIXME: avoid bound checks.
+            self.generic_slice_mut((j, j), (subdim, U1)).axpy(
+                alpha * val,
+                &x.rows_range(j..),
+                beta,
+            );
+        }
+    }
+
     /// Computes `self = alpha * x * y.transpose() + beta * self`, where `self` is a **symmetric**
     /// matrix.
     ///
@@ -861,6 +1258,7 @@ where N: Scalar + Zero + ClosedAdd + ClosedMul
     /// assert_eq!(mat.lower_triangle(), expected.lower_triangle());
     /// assert_eq!(mat.m12, 99999.99999); // This was untouched.
     #[inline]
+    #[deprecated(note = "This is renamed `syger` to match the original BLAS terminology.")]
     pub fn ger_symm<D2: Dim, D3: Dim, SB, SC>(
         &mut self,
         alpha: N,
@@ -873,26 +1271,78 @@ where N: Scalar + Zero + ClosedAdd + ClosedMul
         SC: Storage<N, D3>,
         ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
     {
-        let dim1 = self.nrows();
-        let dim2 = x.nrows();
-        let dim3 = y.nrows();
+        self.syger(alpha, x, y, beta)
+    }
 
-        assert!(
-            self.is_square(),
-            "Symmetric ger: the input matrix must be square."
-        );
-        assert!(dim1 == dim2 && dim1 == dim3, "ger: dimensions mismatch.");
+    /// Computes `self = alpha * x * y.transpose() + beta * self`, where `self` is a **symmetric**
+    /// matrix.
+    ///
+    /// For hermitian complex matrices, use `.hegerc` instead.
+    /// If `beta` is zero, `self` is never read. The result is symmetric. Only the lower-triangular
+    /// (including the diagonal) part of `self` is read/written.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # use nalgebra::{Matrix2, Vector2};
+    /// let mut mat = Matrix2::identity();
+    /// let vec1 = Vector2::new(1.0, 2.0);
+    /// let vec2 = Vector2::new(0.1, 0.2);
+    /// let expected = vec1 * vec2.transpose() * 10.0 + mat * 5.0;
+    /// mat.m12 = 99999.99999; // This component is on the upper-triangular part and will not be read/written.
+    ///
+    /// mat.syger(10.0, &vec1, &vec2, 5.0);
+    /// assert_eq!(mat.lower_triangle(), expected.lower_triangle());
+    /// assert_eq!(mat.m12, 99999.99999); // This was untouched.
+    #[inline]
+    pub fn syger<D2: Dim, D3: Dim, SB, SC>(
+        &mut self,
+        alpha: N,
+        x: &Vector<N, D2, SB>,
+        y: &Vector<N, D3, SC>,
+        beta: N,
+    ) where
+        N: One,
+        SB: Storage<N, D2>,
+        SC: Storage<N, D3>,
+        ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
+    {
+        self.xxgerx(alpha, x, y, beta, |e| e)
+    }
 
-        for j in 0..dim1 {
-            let val = unsafe { *y.vget_unchecked(j) };
-            let subdim = Dynamic::new(dim1 - j);
-            // FIXME: avoid bound checks.
-            self.generic_slice_mut((j, j), (subdim, U1)).axpy(
-                alpha * val,
-                &x.rows_range(j..),
-                beta,
-            );
-        }
+    /// Computes `self = alpha * x * y.adjoint() + beta * self`, where `self` is an **hermitian**
+    /// matrix.
+    ///
+    /// If `beta` is zero, `self` is never read. The result is symmetric. Only the lower-triangular
+    /// (including the diagonal) part of `self` is read/written.
+    ///
+    /// # Examples:
+    ///
+    /// ```
+    /// # use nalgebra::{Matrix2, Vector2, Complex};
+    /// let mut mat = Matrix2::identity();
+    /// let vec1 = Vector2::new(Complex::new(1.0, 3.0), Complex::new(2.0, 4.0));
+    /// let vec2 = Vector2::new(Complex::new(0.2, 0.4), Complex::new(0.1, 0.3));
+    /// let expected = vec1 * vec2.adjoint() * Complex::new(10.0, 20.0) + mat * Complex::new(5.0, 15.0);
+    /// mat.m12 = Complex::new(99999.99999, 88888.88888); // This component is on the upper-triangular part and will not be read/written.
+    ///
+    /// mat.hegerc(Complex::new(10.0, 20.0), &vec1, &vec2, Complex::new(5.0, 15.0));
+    /// assert_eq!(mat.lower_triangle(), expected.lower_triangle());
+    /// assert_eq!(mat.m12, Complex::new(99999.99999, 88888.88888)); // This was untouched.
+    #[inline]
+    pub fn hegerc<D2: Dim, D3: Dim, SB, SC>(
+        &mut self,
+        alpha: N,
+        x: &Vector<N, D2, SB>,
+        y: &Vector<N, D3, SC>,
+        beta: N,
+    ) where
+        N: ComplexField,
+        SB: Storage<N, D2>,
+        SC: Storage<N, D3>,
+        ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
+    {
+        self.xxgerx(alpha, x, y, beta, ComplexField::conjugate)
     }
 }
 
diff --git a/src/base/cg.rs b/src/base/cg.rs
index 5883e710b..4029dbc31 100644
--- a/src/base/cg.rs
+++ b/src/base/cg.rs
@@ -7,18 +7,18 @@
 
 use num::One;
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameDiff, DimNameSub, U1};
-use base::storage::{Storage, StorageMut};
-use base::{
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameDiff, DimNameSub, U1};
+use crate::base::storage::{Storage, StorageMut};
+use crate::base::{
     DefaultAllocator, Matrix3, Matrix4, MatrixN, Scalar, SquareMatrix, Unit, Vector, Vector3,
     VectorN,
 };
-use geometry::{
+use crate::geometry::{
     Isometry, IsometryMatrix3, Orthographic3, Perspective3, Point, Point3, Rotation2, Rotation3,
 };
 
-use alga::general::{Real, Ring};
+use alga::general::{RealField, Ring};
 use alga::linear::Transformation;
 
 impl<N, D: DimName> MatrixN<N, D>
@@ -65,7 +65,7 @@ where
     }
 }
 
-impl<N: Real> Matrix3<N> {
+impl<N: RealField> Matrix3<N> {
     /// Builds a 2 dimensional homogeneous rotation matrix from an angle in radian.
     #[inline]
     pub fn new_rotation(angle: N) -> Self {
@@ -73,7 +73,7 @@ impl<N: Real> Matrix3<N> {
     }
 }
 
-impl<N: Real> Matrix4<N> {
+impl<N: RealField> Matrix4<N> {
     /// Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).
     ///
     /// Returns the identity matrix if the given argument is zero.
@@ -320,7 +320,7 @@ impl<N: Scalar + Ring, D: DimName, S: StorageMut<N, D, D>> SquareMatrix<N, D, S>
     }
 }
 
-impl<N: Real, D: DimNameSub<U1>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
+impl<N: RealField, D: DimNameSub<U1>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
 where DefaultAllocator: Allocator<N, D, D>
         + Allocator<N, DimNameDiff<D, U1>>
         + Allocator<N, DimNameDiff<D, U1>, DimNameDiff<D, U1>>
@@ -364,7 +364,7 @@ where DefaultAllocator: Allocator<N, D, D>
     }
 }
 
-impl<N: Real, D: DimNameSub<U1>> Transformation<Point<N, DimNameDiff<D, U1>>> for MatrixN<N, D>
+impl<N: RealField, D: DimNameSub<U1>> Transformation<Point<N, DimNameDiff<D, U1>>> for MatrixN<N, D>
 where DefaultAllocator: Allocator<N, D, D>
         + Allocator<N, DimNameDiff<D, U1>>
         + Allocator<N, DimNameDiff<D, U1>, DimNameDiff<D, U1>>
diff --git a/src/base/componentwise.rs b/src/base/componentwise.rs
index 9081cf369..e5f4d7ecb 100644
--- a/src/base/componentwise.rs
+++ b/src/base/componentwise.rs
@@ -5,11 +5,11 @@ use std::ops::{Add, Mul};
 
 use alga::general::{ClosedDiv, ClosedMul};
 
-use base::allocator::{Allocator, SameShapeAllocator};
-use base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
-use base::dimension::Dim;
-use base::storage::{Storage, StorageMut};
-use base::{DefaultAllocator, Matrix, MatrixMN, MatrixSum, Scalar};
+use crate::base::allocator::{Allocator, SameShapeAllocator};
+use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
+use crate::base::dimension::Dim;
+use crate::base::storage::{Storage, StorageMut};
+use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixSum, Scalar};
 
 /// The type of the result of a matrix component-wise operation.
 pub type MatrixComponentOp<N, R1, C1, R2, C2> = MatrixSum<N, R1, C1, R2, C2>;
diff --git a/src/base/constraint.rs b/src/base/constraint.rs
index 3bd0540b6..89226fe3b 100644
--- a/src/base/constraint.rs
+++ b/src/base/constraint.rs
@@ -1,6 +1,6 @@
 //! Compatibility constraints between matrix shapes, e.g., for addition or multiplication.
 
-use base::dimension::{Dim, DimName, Dynamic};
+use crate::base::dimension::{Dim, DimName, Dynamic};
 
 /// A type used in `where` clauses for enforcing constraints.
 pub struct ShapeConstraint;
diff --git a/src/base/construction.rs b/src/base/construction.rs
index aeee61213..5eace4bb0 100644
--- a/src/base/construction.rs
+++ b/src/base/construction.rs
@@ -1,5 +1,5 @@
 #[cfg(feature = "arbitrary")]
-use base::storage::Owned;
+use crate::base::storage::Owned;
 #[cfg(feature = "arbitrary")]
 use quickcheck::{Arbitrary, Gen};
 
@@ -12,13 +12,13 @@ use std::iter;
 use typenum::{self, Cmp, Greater};
 
 #[cfg(feature = "std")]
-use alga::general::Real;
+use alga::general::RealField;
 use alga::general::{ClosedAdd, ClosedMul};
 
-use base::allocator::Allocator;
-use base::dimension::{Dim, DimName, Dynamic, U1, U2, U3, U4, U5, U6};
-use base::storage::Storage;
-use base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar, Unit, Vector, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{Dim, DimName, Dynamic, U1, U2, U3, U4, U5, U6};
+use crate::base::storage::Storage;
+use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar, Unit, Vector, VectorN};
 
 /*
  *
@@ -131,7 +131,7 @@ where DefaultAllocator: Allocator<N, R, C>
     where N: Zero + One {
         let mut res = Self::zeros_generic(nrows, ncols);
 
-        for i in 0..::min(nrows.value(), ncols.value()) {
+        for i in 0..crate::min(nrows.value(), ncols.value()) {
             unsafe { *res.get_unchecked_mut((i, i)) = elt }
         }
 
@@ -147,7 +147,7 @@ where DefaultAllocator: Allocator<N, R, C>
     where N: Zero {
         let mut res = Self::zeros_generic(nrows, ncols);
         assert!(
-            elts.len() <= ::min(nrows.value(), ncols.value()),
+            elts.len() <= crate::min(nrows.value(), ncols.value()),
             "Too many diagonal elements provided."
         );
 
@@ -795,7 +795,7 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<N: Real, D: DimName> Distribution<Unit<VectorN<N, D>>> for Standard
+impl<N: RealField, D: DimName> Distribution<Unit<VectorN<N, D>>> for Standard
 where
     DefaultAllocator: Allocator<N, D>,
     StandardNormal: Distribution<N>,
diff --git a/src/base/construction_slice.rs b/src/base/construction_slice.rs
index 419720bf3..0946653a5 100644
--- a/src/base/construction_slice.rs
+++ b/src/base/construction_slice.rs
@@ -1,6 +1,6 @@
-use base::dimension::{Dim, DimName, Dynamic, U1};
-use base::matrix_slice::{SliceStorage, SliceStorageMut};
-use base::{MatrixSliceMN, MatrixSliceMutMN, Scalar};
+use crate::base::dimension::{Dim, DimName, Dynamic, U1};
+use crate::base::matrix_slice::{SliceStorage, SliceStorageMut};
+use crate::base::{MatrixSliceMN, MatrixSliceMutMN, Scalar};
 
 /*
  *
diff --git a/src/base/conversion.rs b/src/base/conversion.rs
index fcb6907da..4c5bb0170 100644
--- a/src/base/conversion.rs
+++ b/src/base/conversion.rs
@@ -9,18 +9,18 @@ use generic_array::ArrayLength;
 use std::ops::Mul;
 use typenum::Prod;
 
-use base::allocator::{Allocator, SameShapeAllocator};
-use base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
-use base::dimension::{
+use crate::base::allocator::{Allocator, SameShapeAllocator};
+use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
+use crate::base::dimension::{
     Dim, DimName, U1, U10, U11, U12, U13, U14, U15, U16, U2, U3, U4, U5, U6, U7, U8, U9,
 };
 #[cfg(any(feature = "std", feature = "alloc"))]
-use base::dimension::Dynamic;
-use base::iter::{MatrixIter, MatrixIterMut};
-use base::storage::{ContiguousStorage, ContiguousStorageMut, Storage, StorageMut};
+use crate::base::dimension::Dynamic;
+use crate::base::iter::{MatrixIter, MatrixIterMut};
+use crate::base::storage::{ContiguousStorage, ContiguousStorageMut, Storage, StorageMut};
 #[cfg(any(feature = "std", feature = "alloc"))]
-use base::VecStorage;
-use base::{DefaultAllocator, Matrix, ArrayStorage, MatrixMN, MatrixSlice, MatrixSliceMut, Scalar};
+use crate::base::VecStorage;
+use crate::base::{DefaultAllocator, Matrix, ArrayStorage, MatrixMN, MatrixSlice, MatrixSliceMut, Scalar};
 
 // FIXME: too bad this won't work allo slice conversions.
 impl<N1, N2, R1, C1, R2, C2> SubsetOf<MatrixMN<N2, R2, C2>> for MatrixMN<N1, R1, C1>
@@ -331,9 +331,9 @@ macro_rules! impl_from_into_mint_2D(
 #[cfg(feature = "mint")]
 impl_from_into_mint_2D!(
     (U2, U2) => ColumnMatrix2{x, y}[2];
-    (U2, U3) => ColumnMatrix2x3{x, y}[2];
+    (U2, U3) => ColumnMatrix2x3{x, y, z}[2];
     (U3, U3) => ColumnMatrix3{x, y, z}[3];
-    (U3, U4) => ColumnMatrix3x4{x, y, z}[3];
+    (U3, U4) => ColumnMatrix3x4{x, y, z, w}[3];
     (U4, U4) => ColumnMatrix4{x, y, z, w}[4];
 );
 
diff --git a/src/base/coordinates.rs b/src/base/coordinates.rs
index 986b8e9d4..832723e39 100644
--- a/src/base/coordinates.rs
+++ b/src/base/coordinates.rs
@@ -7,9 +7,9 @@
 use std::mem;
 use std::ops::{Deref, DerefMut};
 
-use base::dimension::{U1, U2, U3, U4, U5, U6};
-use base::storage::{ContiguousStorage, ContiguousStorageMut};
-use base::{Matrix, Scalar};
+use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
+use crate::base::storage::{ContiguousStorage, ContiguousStorageMut};
+use crate::base::{Matrix, Scalar};
 
 /*
  *
diff --git a/src/base/default_allocator.rs b/src/base/default_allocator.rs
index 5926f39d8..c07c87085 100644
--- a/src/base/default_allocator.rs
+++ b/src/base/default_allocator.rs
@@ -14,15 +14,15 @@ use alloc::vec::Vec;
 use generic_array::ArrayLength;
 use typenum::Prod;
 
-use base::allocator::{Allocator, Reallocator};
+use crate::base::allocator::{Allocator, Reallocator};
 #[cfg(any(feature = "alloc", feature = "std"))]
-use base::dimension::Dynamic;
-use base::dimension::{Dim, DimName};
-use base::array_storage::ArrayStorage;
+use crate::base::dimension::Dynamic;
+use crate::base::dimension::{Dim, DimName};
+use crate::base::array_storage::ArrayStorage;
 #[cfg(any(feature = "std", feature = "alloc"))]
-use base::vec_storage::VecStorage;
-use base::storage::{Storage, StorageMut};
-use base::Scalar;
+use crate::base::vec_storage::VecStorage;
+use crate::base::storage::{Storage, StorageMut};
+use crate::base::Scalar;
 
 /*
  *
diff --git a/src/base/edition.rs b/src/base/edition.rs
index 32e2c1aa7..5b1c16c49 100644
--- a/src/base/edition.rs
+++ b/src/base/edition.rs
@@ -6,17 +6,17 @@ use std::iter::ExactSizeIterator;
 #[cfg(any(feature = "std", feature = "alloc"))]
 use std::mem;
 
-use base::allocator::{Allocator, Reallocator};
-use base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
-use base::dimension::{
+use crate::base::allocator::{Allocator, Reallocator};
+use crate::base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
+use crate::base::dimension::{
     Dim, DimAdd, DimDiff, DimMin, DimMinimum, DimName, DimSub, DimSum, U1,
 };
 #[cfg(any(feature = "std", feature = "alloc"))]
-use base::dimension::Dynamic;
-use base::storage::{Storage, StorageMut};
+use crate::base::dimension::Dynamic;
+use crate::base::storage::{Storage, StorageMut};
 #[cfg(any(feature = "std", feature = "alloc"))]
-use base::DMatrix;
-use base::{DefaultAllocator, Matrix, MatrixMN, RowVector, Scalar, Vector};
+use crate::base::DMatrix;
+use crate::base::{DefaultAllocator, Matrix, MatrixMN, RowVector, Scalar, Vector};
 
 impl<N: Scalar + Zero, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Extracts the upper triangular part of this matrix (including the diagonal).
@@ -58,7 +58,7 @@ impl<N: Scalar + Zero, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
         for j in 0..ncols.value() {
             // FIXME: use unchecked column indexing
             let mut res = res.column_mut(j);
-            let mut src = self.column(j);
+            let src = self.column(j);
 
             for (destination, source) in irows.clone().enumerate() {
                 unsafe {
@@ -137,10 +137,10 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     /// Fills the diagonal of this matrix with the content of the given vector.
     #[inline]
     pub fn set_diagonal<R2: Dim, S2>(&mut self, diag: &Vector<N, R2, S2>)
-    where
-        R: DimMin<C>,
-        S2: Storage<N, R2>,
-        ShapeConstraint: DimEq<DimMinimum<R, C>, R2>,
+        where
+            R: DimMin<C>,
+            S2: Storage<N, R2>,
+            ShapeConstraint: DimEq<DimMinimum<R, C>, R2>,
     {
         let (nrows, ncols) = self.shape();
         let min_nrows_ncols = cmp::min(nrows, ncols);
@@ -151,6 +151,21 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
         }
     }
 
+    /// Fills the diagonal of this matrix with the content of the given iterator.
+    ///
+    /// This will fill as many diagonal elements as the iterator yields, up to the
+    /// minimum of the number of rows and columns of `self`, and starting with the
+    /// diagonal element at index (0, 0).
+    #[inline]
+    pub fn set_partial_diagonal(&mut self, diag: impl Iterator<Item = N>) {
+        let (nrows, ncols) = self.shape();
+        let min_nrows_ncols = cmp::min(nrows, ncols);
+
+        for (i, val) in diag.enumerate().take(min_nrows_ncols) {
+            unsafe { *self.get_unchecked_mut((i, i)) = val }
+        }
+    }
+
     /// Fills the selected row of this matrix with the content of the given vector.
     #[inline]
     pub fn set_row<C2: Dim, S2>(&mut self, i: usize, row: &RowVector<N, C2, S2>)
diff --git a/src/base/indexing.rs b/src/base/indexing.rs
index 976eef874..ca786530a 100644
--- a/src/base/indexing.rs
+++ b/src/base/indexing.rs
@@ -1,7 +1,7 @@
 //! Indexing
 
-use base::{Dim, DimName, DimDiff, DimSub, Dynamic, Matrix, MatrixSlice, MatrixSliceMut, Scalar, U1};
-use base::storage::{Storage, StorageMut};
+use crate::base::{Dim, DimName, DimDiff, DimSub, Dynamic, Matrix, MatrixSlice, MatrixSliceMut, Scalar, U1};
+use crate::base::storage::{Storage, StorageMut};
 
 use std::ops;
 
@@ -42,7 +42,7 @@ impl<D: Dim> DimRange<D> for usize {
 
 #[test]
 fn dimrange_usize() {
-    use base::dimension::U0;
+    use crate::base::dimension::U0;
     assert_eq!(DimRange::contained_by(&0, U0), false);
     assert_eq!(DimRange::contained_by(&0, U1), true);
 }
@@ -69,7 +69,7 @@ impl<D: Dim> DimRange<D> for ops::Range<usize> {
 #[test]
 fn dimrange_range_usize() {
     use std::usize::MAX;
-    use base::dimension::U0;
+    use crate::base::dimension::U0;
     assert_eq!(DimRange::contained_by(&(0..0), U0), false);
     assert_eq!(DimRange::contained_by(&(0..1), U0), false);
     assert_eq!(DimRange::contained_by(&(0..1), U1), true);
@@ -101,7 +101,7 @@ impl<D: Dim> DimRange<D> for ops::RangeFrom<usize> {
 #[test]
 fn dimrange_rangefrom_usize() {
     use std::usize::MAX;
-    use base::dimension::U0;
+    use crate::base::dimension::U0;
     assert_eq!(DimRange::contained_by(&(0..), U0), false);
     assert_eq!(DimRange::contained_by(&(0..), U0), false);
     assert_eq!(DimRange::contained_by(&(0..), U1), true);
@@ -133,7 +133,7 @@ where D: DimSub<T>
 
 #[test]
 fn dimrange_rangefrom_dimname() {
-    use base::dimension::{U5, U4};
+    use crate::base::dimension::{U5, U4};
     assert_eq!(DimRange::length(&(U1..), U5), U4);
 }
 
@@ -158,7 +158,7 @@ impl<D: Dim> DimRange<D> for ops::RangeFull {
 
 #[test]
 fn dimrange_rangefull() {
-    use base::dimension::U0;
+    use crate::base::dimension::U0;
     assert_eq!(DimRange::contained_by(&(..), U0), true);
     assert_eq!(DimRange::length(&(..), U1), U1);
 }
@@ -190,7 +190,7 @@ impl<D: Dim> DimRange<D> for ops::RangeInclusive<usize> {
 #[test]
 fn dimrange_rangeinclusive_usize() {
     use std::usize::MAX;
-    use base::dimension::U0;
+    use crate::base::dimension::U0;
     assert_eq!(DimRange::contained_by(&(0..=0), U0), false);
     assert_eq!(DimRange::contained_by(&(0..=0), U1), true);
     assert_eq!(DimRange::contained_by(&(MAX..=MAX), Dynamic::new(MAX)), false);
@@ -225,7 +225,7 @@ impl<D: Dim> DimRange<D> for ops::RangeTo<usize>
 #[test]
 fn dimrange_rangeto_usize() {
     use std::usize::MAX;
-    use base::dimension::U0;
+    use crate::base::dimension::U0;
     assert_eq!(DimRange::contained_by(&(..0), U0), true);
     assert_eq!(DimRange::contained_by(&(..1), U0), false);
     assert_eq!(DimRange::contained_by(&(..0), U1), true);
@@ -257,7 +257,7 @@ impl<D: Dim> DimRange<D> for ops::RangeToInclusive<usize>
 #[test]
 fn dimrange_rangetoinclusive_usize() {
     use std::usize::MAX;
-    use base::dimension::U0;
+    use crate::base::dimension::U0;
     assert_eq!(DimRange::contained_by(&(..=0), U0), false);
     assert_eq!(DimRange::contained_by(&(..=1), U0), false);
     assert_eq!(DimRange::contained_by(&(..=0), U1), true);
@@ -627,7 +627,7 @@ macro_rules! impl_index_pair {
             #[doc(hidden)]
             #[inline(always)]
             unsafe fn get_unchecked(self, matrix: &'a Matrix<N, $R, $C, S>) -> Self::Output {
-                use base::SliceStorage;
+                use crate::base::SliceStorage;
 
                 let (rows, cols) = self;
                 let (nrows, ncols) = matrix.data.shape();
@@ -655,7 +655,7 @@ macro_rules! impl_index_pair {
             #[doc(hidden)]
             #[inline(always)]
             unsafe fn get_unchecked_mut(self, matrix: &'a mut Matrix<N, $R, $C, S>) -> Self::OutputMut {
-                use base::SliceStorageMut;
+                use crate::base::SliceStorageMut;
 
                 let (rows, cols) = self;
                 let (nrows, ncols) = matrix.data.shape();
diff --git a/src/base/iter.rs b/src/base/iter.rs
index 8a5f10abf..74e4f0185 100644
--- a/src/base/iter.rs
+++ b/src/base/iter.rs
@@ -3,9 +3,9 @@
 use std::marker::PhantomData;
 use std::mem;
 
-use base::dimension::{Dim, U1};
-use base::storage::{Storage, StorageMut};
-use base::{Scalar, Matrix, MatrixSlice, MatrixSliceMut};
+use crate::base::dimension::{Dim, U1};
+use crate::base::storage::{Storage, StorageMut};
+use crate::base::{Scalar, Matrix, MatrixSlice, MatrixSliceMut};
 
 macro_rules! iterator {
     (struct $Name:ident for $Storage:ident.$ptr: ident -> $Ptr:ty, $Ref:ty, $SRef: ty) => {
diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index fcd537031..6c1db1d6b 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -1,5 +1,4 @@
 use num::{One, Zero};
-use num_complex::Complex;
 #[cfg(feature = "abomonation-serialize")]
 use std::io::{Result as IOResult, Write};
 
@@ -17,16 +16,16 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
-use alga::general::{ClosedAdd, ClosedMul, ClosedSub, Real, Ring};
+use alga::general::{ClosedAdd, ClosedMul, ClosedSub, RealField, Ring, ComplexField, Field};
 
-use base::allocator::{Allocator, SameShapeAllocator, SameShapeC, SameShapeR};
-use base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
-use base::dimension::{Dim, DimAdd, DimSum, IsNotStaticOne, U1, U2, U3};
-use base::iter::{MatrixIter, MatrixIterMut, RowIter, RowIterMut, ColumnIter, ColumnIterMut};
-use base::storage::{
+use crate::base::allocator::{Allocator, SameShapeAllocator, SameShapeC, SameShapeR};
+use crate::base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
+use crate::base::dimension::{Dim, DimAdd, DimSum, IsNotStaticOne, U1, U2, U3};
+use crate::base::iter::{MatrixIter, MatrixIterMut, RowIter, RowIterMut, ColumnIter, ColumnIterMut};
+use crate::base::storage::{
     ContiguousStorage, ContiguousStorageMut, Owned, SameShapeStorage, Storage, StorageMut,
 };
-use base::{DefaultAllocator, MatrixMN, MatrixN, Scalar, Unit, VectorN};
+use crate::base::{DefaultAllocator, MatrixMN, MatrixN, Scalar, Unit, VectorN};
 
 /// A square matrix.
 pub type SquareMatrix<N, D, S> = Matrix<N, D, D, S>;
@@ -771,6 +770,14 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
         }
     }
 
+    // FIXME: rename `apply` to `apply_mut` and `apply_into` to `apply`?
+    /// Returns `self` with each of its components replaced by the result of a closure `f` applied on it.
+    #[inline]
+    pub fn apply_into<F: FnMut(N) -> N>(mut self, f: F) -> Self{
+        self.apply(f);
+        self
+    }
+
     /// Replaces each component of `self` by the result of a closure `f` applied on it.
     #[inline]
     pub fn apply<F: FnMut(N) -> N>(&mut self, mut f: F) {
@@ -906,14 +913,14 @@ impl<N: Scalar, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S> {
     }
 }
 
-impl<N: Real, R: Dim, C: Dim, S: Storage<Complex<N>, R, C>> Matrix<Complex<N>, R, C, S> {
-    /// Takes the conjugate and transposes `self` and store the result into `out`.
+impl<N: ComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+    /// Takes the adjoint (aka. conjugate-transpose) of `self` and store the result into `out`.
     #[inline]
-    pub fn conjugate_transpose_to<R2, C2, SB>(&self, out: &mut Matrix<Complex<N>, R2, C2, SB>)
+    pub fn adjoint_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>)
     where
         R2: Dim,
         C2: Dim,
-        SB: StorageMut<Complex<N>, R2, C2>,
+        SB: StorageMut<N, R2, C2>,
         ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
     {
         let (nrows, ncols) = self.shape();
@@ -926,30 +933,98 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<Complex<N>, R, C>> Matrix<Complex<N>, R
         for i in 0..nrows {
             for j in 0..ncols {
                 unsafe {
-                    *out.get_unchecked_mut((j, i)) = self.get_unchecked((i, j)).conj();
+                    *out.get_unchecked_mut((j, i)) = self.get_unchecked((i, j)).conjugate();
                 }
             }
         }
     }
 
-    /// The conjugate transposition of `self`.
+    /// The adjoint (aka. conjugate-transpose) of `self`.
     #[inline]
-    pub fn conjugate_transpose(&self) -> MatrixMN<Complex<N>, C, R>
-    where DefaultAllocator: Allocator<Complex<N>, C, R> {
+    pub fn adjoint(&self) -> MatrixMN<N, C, R>
+    where DefaultAllocator: Allocator<N, C, R> {
         let (nrows, ncols) = self.data.shape();
 
         unsafe {
             let mut res: MatrixMN<_, C, R> = Matrix::new_uninitialized_generic(ncols, nrows);
-            self.conjugate_transpose_to(&mut res);
+            self.adjoint_to(&mut res);
 
             res
         }
     }
+
+    /// Takes the conjugate and transposes `self` and store the result into `out`.
+    #[deprecated(note = "Renamed `self.adjoint_to(out)`.")]
+    #[inline]
+    pub fn conjugate_transpose_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>)
+        where
+            R2: Dim,
+            C2: Dim,
+            SB: StorageMut<N, R2, C2>,
+            ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
+    {
+        self.adjoint_to(out)
+    }
+
+    /// The conjugate transposition of `self`.
+    #[deprecated(note = "Renamed `self.adjoint()`.")]
+    #[inline]
+    pub fn conjugate_transpose(&self) -> MatrixMN<N, C, R>
+        where DefaultAllocator: Allocator<N, C, R> {
+        self.adjoint()
+    }
+
+    /// The conjugate of `self`.
+    #[inline]
+    pub fn conjugate(&self) -> MatrixMN<N, R, C>
+        where DefaultAllocator: Allocator<N, R, C> {
+        self.map(|e| e.conjugate())
+    }
+
+    /// Divides each component of the complex matrix `self` by the given real.
+    #[inline]
+    pub fn unscale(&self, real: N::RealField) -> MatrixMN<N, R, C>
+        where DefaultAllocator: Allocator<N, R, C> {
+        self.map(|e| e.unscale(real))
+    }
+
+    /// Multiplies each component of the complex matrix `self` by the given real.
+    #[inline]
+    pub fn scale(&self, real: N::RealField) -> MatrixMN<N, R, C>
+        where DefaultAllocator: Allocator<N, R, C> {
+        self.map(|e| e.scale(real))
+    }
 }
 
-impl<N: Real, D: Dim, S: StorageMut<Complex<N>, D, D>> Matrix<Complex<N>, D, D, S> {
-    /// Sets `self` to its conjugate transpose.
-    pub fn conjugate_transpose_mut(&mut self) {
+impl<N: ComplexField, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
+    /// The conjugate of the complex matrix `self` computed in-place.
+    #[inline]
+    pub fn conjugate_mut(&mut self) {
+        self.apply(|e| e.conjugate())
+    }
+
+    /// Divides each component of the complex matrix `self` by the given real.
+    #[inline]
+    pub fn unscale_mut(&mut self, real: N::RealField) {
+        self.apply(|e| e.unscale(real))
+    }
+
+    /// Multiplies each component of the complex matrix `self` by the given real.
+    #[inline]
+    pub fn scale_mut(&mut self, real: N::RealField) {
+        self.apply(|e| e.scale(real))
+    }
+}
+
+impl<N: ComplexField, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S> {
+    /// Sets `self` to its adjoint.
+    #[deprecated(note = "Renamed to `self.adjoint_mut()`.")]
+    pub fn conjugate_transform_mut(&mut self) {
+        self.adjoint_mut()
+    }
+
+    /// Sets `self` to its adjoint (aka. conjugate-transpose).
+    pub fn adjoint_mut(&mut self) {
         assert!(
             self.is_square(),
             "Unable to transpose a non-square matrix in-place."
@@ -957,26 +1032,40 @@ impl<N: Real, D: Dim, S: StorageMut<Complex<N>, D, D>> Matrix<Complex<N>, D, D,
 
         let dim = self.shape().0;
 
-        for i in 1..dim {
+        for i in 0..dim {
             for j in 0..i {
                 unsafe {
-                    let ref_ij = self.get_unchecked_mut((i, j)) as *mut Complex<N>;
-                    let ref_ji = self.get_unchecked_mut((j, i)) as *mut Complex<N>;
-                    let conj_ij = (*ref_ij).conj();
-                    let conj_ji = (*ref_ji).conj();
+                    let ref_ij = self.get_unchecked_mut((i, j)) as *mut N;
+                    let ref_ji = self.get_unchecked_mut((j, i)) as *mut N;
+                    let conj_ij = (*ref_ij).conjugate();
+                    let conj_ji = (*ref_ji).conjugate();
                     *ref_ij = conj_ji;
                     *ref_ji = conj_ij;
                 }
             }
+
+            {
+                let diag = unsafe { self.get_unchecked_mut((i, i)) };
+                *diag = diag.conjugate();
+            }
         }
     }
 }
 
 impl<N: Scalar, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
-    /// Creates a square matrix with its diagonal set to `diag` and all other entries set to 0.
+    /// The diagonal of this matrix.
     #[inline]
     pub fn diagonal(&self) -> VectorN<N, D>
-    where DefaultAllocator: Allocator<N, D> {
+        where DefaultAllocator: Allocator<N, D> {
+        self.map_diagonal(|e| e)
+    }
+
+    /// Apply the given function to this matrix's diagonal and returns it.
+    ///
+    /// This is a more efficient version of `self.diagonal().map(f)` since this
+    /// allocates only once.
+    pub fn map_diagonal<N2: Scalar>(&self, mut f: impl FnMut(N) -> N2) -> VectorN<N2, D>
+        where DefaultAllocator: Allocator<N2, D> {
         assert!(
             self.is_square(),
             "Unable to get the diagonal of a non-square matrix."
@@ -987,7 +1076,7 @@ impl<N: Scalar, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
 
         for i in 0..dim.value() {
             unsafe {
-                *res.vget_unchecked_mut(i) = *self.get_unchecked((i, i));
+                *res.vget_unchecked_mut(i) = f(*self.get_unchecked((i, i)));
             }
         }
 
@@ -997,7 +1086,7 @@ impl<N: Scalar, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// Computes a trace of a square matrix, i.e., the sum of its diagonal elements.
     #[inline]
     pub fn trace(&self) -> N
-    where N: Ring {
+        where N: Ring {
         assert!(
             self.is_square(),
             "Cannot compute the trace of non-square matrix."
@@ -1014,6 +1103,31 @@ impl<N: Scalar, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     }
 }
 
+impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
+    /// The symmetric part of `self`, i.e., `0.5 * (self + self.transpose())`.
+    #[inline]
+    pub fn symmetric_part(&self) -> MatrixMN<N, D, D>
+        where DefaultAllocator: Allocator<N, D, D> {
+        assert!(self.is_square(), "Cannot compute the symmetric part of a non-square matrix.");
+        let mut tr = self.transpose();
+        tr += self;
+        tr *= crate::convert::<_, N>(0.5);
+        tr
+    }
+
+    /// The hermitian part of `self`, i.e., `0.5 * (self + self.adjoint())`.
+    #[inline]
+    pub fn hermitian_part(&self) -> MatrixMN<N, D, D>
+        where DefaultAllocator: Allocator<N, D, D> {
+        assert!(self.is_square(), "Cannot compute the hermitian part of a non-square matrix.");
+
+        let mut tr = self.adjoint();
+        tr += self;
+        tr *= crate::convert::<_, N>(0.5);
+        tr
+    }
+}
+
 impl<N: Scalar + One + Zero, D: DimAdd<U1> + IsNotStaticOne, S: Storage<N, D, D>> Matrix<N, D, D, S> {
 
     /// Yields the homogeneous matrix for this matrix, i.e., appending an additional dimension and
@@ -1278,40 +1392,40 @@ where
         for i in 0..nrows {
             for j in 0..ncols {
                 lengths[(i, j)] = val_width(self[(i, j)], f);
-                max_length = ::max(max_length, lengths[(i, j)]);
+                max_length = crate::max(max_length, lengths[(i, j)]);
             }
         }
 
         let max_length_with_space = max_length + 1;
 
-        try!(writeln!(f));
-        try!(writeln!(
+        writeln!(f)?;
+        writeln!(
             f,
             "  ┌ {:>width$} ┐",
             "",
             width = max_length_with_space * ncols - 1
-        ));
+        )?;
 
         for i in 0..nrows {
-            try!(write!(f, "  │"));
+            write!(f, "  │")?;
             for j in 0..ncols {
                 let number_length = lengths[(i, j)] + 1;
                 let pad = max_length_with_space - number_length;
-                try!(write!(f, " {:>thepad$}", "", thepad = pad));
+                write!(f, " {:>thepad$}", "", thepad = pad)?;
                 match f.precision() {
-                    Some(precision) => try!(write!(f, "{:.1$}", (*self)[(i, j)], precision)),
-                    None => try!(write!(f, "{}", (*self)[(i, j)])),
+                    Some(precision) => write!(f, "{:.1$}", (*self)[(i, j)], precision)?,
+                    None => write!(f, "{}", (*self)[(i, j)])?,
                 }
             }
-            try!(writeln!(f, " │"));
+            writeln!(f, " │")?;
         }
 
-        try!(writeln!(
+        writeln!(
             f,
             "  └ {:>width$} ┘",
             "",
             width = max_length_with_space * ncols - 1
-        ));
+        )?;
         writeln!(f)
     }
 }
@@ -1407,7 +1521,7 @@ impl<N: Scalar + Ring, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     }
 }
 
-impl<N: Real, S: Storage<N, U3>> Vector<N, U3, S>
+impl<N: Scalar + Field, S: Storage<N, U3>> Vector<N, U3, S>
 where DefaultAllocator: Allocator<N, U3>
 {
     /// Computes the matrix `M` such that for all vector `v` we have `M * v == self.cross(&v)`.
@@ -1427,27 +1541,27 @@ where DefaultAllocator: Allocator<N, U3>
     }
 }
 
-impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<N: ComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// The smallest angle between two vectors.
     #[inline]
-    pub fn angle<R2: Dim, C2: Dim, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> N
+    pub fn angle<R2: Dim, C2: Dim, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> N::RealField
     where
         SB: Storage<N, R2, C2>,
         ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
     {
-        let prod = self.dot(other);
+        let prod = self.dotc(other);
         let n1 = self.norm();
         let n2 = other.norm();
 
         if n1.is_zero() || n2.is_zero() {
-            N::zero()
+            N::RealField::zero()
         } else {
-            let cang = prod / (n1 * n2);
+            let cang = prod.real() / (n1 * n2);
 
-            if cang > N::one() {
-                N::zero()
-            } else if cang < -N::one() {
-                N::pi()
+            if cang > N::RealField::one() {
+                N::RealField::zero()
+            } else if cang < -N::RealField::one() {
+                N::RealField::pi()
             } else {
                 cang.acos()
             }
@@ -1478,18 +1592,18 @@ impl<N: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Stor
     }
 }
 
-impl<N: Real, D: Dim, S: Storage<N, D>> Unit<Vector<N, D, S>> {
+impl<N: ComplexField, D: Dim, S: Storage<N, D>> Unit<Vector<N, D, S>> {
     /// Computes the spherical linear interpolation between two unit vectors.
     pub fn slerp<S2: Storage<N, D>>(
         &self,
         rhs: &Unit<Vector<N, D, S2>>,
-        t: N,
+        t: N::RealField,
     ) -> Unit<VectorN<N, D>>
     where
         DefaultAllocator: Allocator<N, D>,
     {
         // FIXME: the result is wrong when self and rhs are collinear with opposite direction.
-        self.try_slerp(rhs, t, N::default_epsilon())
+        self.try_slerp(rhs, t, N::RealField::default_epsilon())
             .unwrap_or(Unit::new_unchecked(self.clone_owned()))
     }
 
@@ -1500,29 +1614,30 @@ impl<N: Real, D: Dim, S: Storage<N, D>> Unit<Vector<N, D, S>> {
     pub fn try_slerp<S2: Storage<N, D>>(
         &self,
         rhs: &Unit<Vector<N, D, S2>>,
-        t: N,
-        epsilon: N,
+        t: N::RealField,
+        epsilon: N::RealField,
     ) -> Option<Unit<VectorN<N, D>>>
     where
         DefaultAllocator: Allocator<N, D>,
     {
-        let c_hang = self.dot(rhs);
+        let (c_hang, c_hang_sign) = self.dotc(rhs).to_exp();
 
         // self == other
-        if c_hang.abs() >= N::one() {
+        if c_hang >= N::RealField::one() {
             return Some(Unit::new_unchecked(self.clone_owned()));
         }
 
         let hang = c_hang.acos();
-        let s_hang = (N::one() - c_hang * c_hang).sqrt();
+        let s_hang = (N::RealField::one() - c_hang * c_hang).sqrt();
 
         // FIXME: what if s_hang is 0.0 ? The result is not well-defined.
-        if relative_eq!(s_hang, N::zero(), epsilon = epsilon) {
+        if relative_eq!(s_hang, N::RealField::zero(), epsilon = epsilon) {
             None
         } else {
-            let ta = ((N::one() - t) * hang).sin() / s_hang;
+            let ta = ((N::RealField::one() - t) * hang).sin() / s_hang;
             let tb = (t * hang).sin() / s_hang;
-            let res = &**self * ta + &**rhs * tb;
+            let mut res = self.scale(ta);
+            res.axpy(c_hang_sign.scale(tb), &**rhs, N::one());
 
             Some(Unit::new_unchecked(res))
         }
diff --git a/src/base/matrix_alga.rs b/src/base/matrix_alga.rs
index 6ce608097..ac6aced78 100644
--- a/src/base/matrix_alga.rs
+++ b/src/base/matrix_alga.rs
@@ -7,16 +7,16 @@ use alga::general::{
     AbstractGroup, AbstractGroupAbelian, AbstractLoop, AbstractMagma, AbstractModule,
     AbstractMonoid, AbstractQuasigroup, AbstractSemigroup, Additive, ClosedAdd, ClosedMul,
     ClosedNeg, Field, Identity, TwoSidedInverse, JoinSemilattice, Lattice, MeetSemilattice, Module,
-    Multiplicative, Real, RingCommutative,
+    Multiplicative, RingCommutative, ComplexField
 };
 use alga::linear::{
     FiniteDimInnerSpace, FiniteDimVectorSpace, InnerSpace, NormedSpace, VectorSpace,
 };
 
-use base::allocator::Allocator;
-use base::dimension::{Dim, DimName};
-use base::storage::{Storage, StorageMut};
-use base::{DefaultAllocator, MatrixMN, MatrixN, Scalar};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{Dim, DimName};
+use crate::base::storage::{Storage, StorageMut};
+use crate::base::{DefaultAllocator, MatrixMN, MatrixN, Scalar};
 
 /*
  *
@@ -145,16 +145,19 @@ where
     }
 }
 
-impl<N: Real, R: DimName, C: DimName> NormedSpace for MatrixMN<N, R, C>
+impl<N: ComplexField, R: DimName, C: DimName> NormedSpace for MatrixMN<N, R, C>
 where DefaultAllocator: Allocator<N, R, C>
 {
+    type RealField = N::RealField;
+    type ComplexField = N;
+
     #[inline]
-    fn norm_squared(&self) -> N {
+    fn norm_squared(&self) -> N::RealField {
         self.norm_squared()
     }
 
     #[inline]
-    fn norm(&self) -> N {
+    fn norm(&self) -> N::RealField {
         self.norm()
     }
 
@@ -164,34 +167,32 @@ where DefaultAllocator: Allocator<N, R, C>
     }
 
     #[inline]
-    fn normalize_mut(&mut self) -> N {
+    fn normalize_mut(&mut self) -> N::RealField {
         self.normalize_mut()
     }
 
     #[inline]
-    fn try_normalize(&self, min_norm: N) -> Option<Self> {
+    fn try_normalize(&self, min_norm: N::RealField) -> Option<Self> {
         self.try_normalize(min_norm)
     }
 
     #[inline]
-    fn try_normalize_mut(&mut self, min_norm: N) -> Option<N> {
+    fn try_normalize_mut(&mut self, min_norm: N::RealField) -> Option<N::RealField> {
         self.try_normalize_mut(min_norm)
     }
 }
 
-impl<N: Real, R: DimName, C: DimName> InnerSpace for MatrixMN<N, R, C>
+impl<N: ComplexField, R: DimName, C: DimName> InnerSpace for MatrixMN<N, R, C>
 where DefaultAllocator: Allocator<N, R, C>
 {
-    type Real = N;
-
     #[inline]
-    fn angle(&self, other: &Self) -> N {
+    fn angle(&self, other: &Self) -> N::RealField {
         self.angle(other)
     }
 
     #[inline]
     fn inner_product(&self, other: &Self) -> N {
-        self.dot(other)
+        self.dotc(other)
     }
 }
 
@@ -199,7 +200,7 @@ where DefaultAllocator: Allocator<N, R, C>
 // In particular:
 //   − use `x()` instead of `::canonical_basis_element`
 //   − use `::new(x, y, z)` instead of `::from_slice`
-impl<N: Real, R: DimName, C: DimName> FiniteDimInnerSpace for MatrixMN<N, R, C>
+impl<N: ComplexField, R: DimName, C: DimName> FiniteDimInnerSpace for MatrixMN<N, R, C>
 where DefaultAllocator: Allocator<N, R, C>
 {
     #[inline]
@@ -215,7 +216,7 @@ where DefaultAllocator: Allocator<N, R, C>
                 }
             }
 
-            if vs[i].try_normalize_mut(N::zero()).is_some() {
+            if vs[i].try_normalize_mut(N::RealField::zero()).is_some() {
                 // FIXME: this will be efficient on dynamically-allocated vectors but for
                 // statically-allocated ones, `.clone_from` would be better.
                 vs.swap(nbasis_elements, i);
@@ -268,7 +269,7 @@ where DefaultAllocator: Allocator<N, R, C>
                     let v = &vs[0];
                     let mut a;
 
-                    if v[0].abs() > v[1].abs() {
+                    if v[0].norm1() > v[1].norm1() {
                         a = Self::from_column_slice(&[v[2], N::zero(), -v[0]]);
                     } else {
                         a = Self::from_column_slice(&[N::zero(), -v[2], v[1]]);
@@ -300,7 +301,7 @@ where DefaultAllocator: Allocator<N, R, C>
                             elt -= v * elt.dot(v)
                         }
 
-                        if let Some(subsp_elt) = elt.try_normalize(N::zero()) {
+                        if let Some(subsp_elt) = elt.try_normalize(N::RealField::zero()) {
                             if !f(&subsp_elt) {
                                 return;
                             };
diff --git a/src/base/matrix_slice.rs b/src/base/matrix_slice.rs
index a4ce15330..be53034a5 100644
--- a/src/base/matrix_slice.rs
+++ b/src/base/matrix_slice.rs
@@ -2,12 +2,12 @@ use std::marker::PhantomData;
 use std::ops::{Range, RangeFrom, RangeFull, RangeTo};
 use std::slice;
 
-use base::allocator::Allocator;
-use base::default_allocator::DefaultAllocator;
-use base::dimension::{Dim, DimName, Dynamic, U1, IsNotStaticOne};
-use base::iter::MatrixIter;
-use base::storage::{Owned, Storage, StorageMut, ContiguousStorage, ContiguousStorageMut};
-use base::{Matrix, Scalar};
+use crate::base::allocator::Allocator;
+use crate::base::default_allocator::DefaultAllocator;
+use crate::base::dimension::{Dim, DimName, Dynamic, U1, IsNotStaticOne};
+use crate::base::iter::MatrixIter;
+use crate::base::storage::{Owned, Storage, StorageMut, ContiguousStorage, ContiguousStorageMut};
+use crate::base::{Matrix, Scalar};
 
 macro_rules! slice_storage_impl(
     ($doc: expr; $Storage: ident as $SRef: ty; $T: ident.$get_addr: ident ($Ptr: ty as $Ref: ty)) => {
diff --git a/src/base/norm.rs b/src/base/norm.rs
index 68fb88a1c..93319ddc8 100644
--- a/src/base/norm.rs
+++ b/src/base/norm.rs
@@ -1,23 +1,22 @@
-use num::Signed;
-use std::cmp::PartialOrd;
+use num::Zero;
 
-use allocator::Allocator;
-use ::{Real, Scalar};
-use storage::{Storage, StorageMut};
-use base::{DefaultAllocator, Matrix, Dim, MatrixMN};
-use constraint::{SameNumberOfRows, SameNumberOfColumns, ShapeConstraint};
+use crate::allocator::Allocator;
+use crate::{RealField, ComplexField};
+use crate::storage::{Storage, StorageMut};
+use crate::base::{DefaultAllocator, Matrix, Dim, MatrixMN};
+use crate::constraint::{SameNumberOfRows, SameNumberOfColumns, ShapeConstraint};
 
 
 // FIXME: this should be be a trait on alga?
 /// A trait for abstract matrix norms.
 ///
 /// This may be moved to the alga crate in the future.
-pub trait Norm<N: Scalar> {
+pub trait Norm<N: ComplexField> {
     /// Apply this norm to the given matrix.
-    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N
+    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N::RealField
         where R: Dim, C: Dim, S: Storage<N, R, C>;
     /// Use the metric induced by this norm to compute the metric distance between the two given matrices.
-    fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N
+    fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N::RealField
         where R1: Dim, C1: Dim, S1: Storage<N, R1, C1>,
               R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
               ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>;
@@ -30,60 +29,62 @@ pub struct LpNorm(pub i32);
 /// L-infinite norm aka. Chebytchev norm aka. uniform norm aka. suppremum norm.
 pub struct UniformNorm;
 
-impl<N: Real> Norm<N> for EuclideanNorm {
+impl<N: ComplexField> Norm<N> for EuclideanNorm {
     #[inline]
-    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N
+    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N::RealField
         where R: Dim, C: Dim, S: Storage<N, R, C> {
         m.norm_squared().sqrt()
     }
 
     #[inline]
-    fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N
+    fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N::RealField
         where R1: Dim, C1: Dim, S1: Storage<N, R1, C1>,
               R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
               ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
-        m1.zip_fold(m2, N::zero(), |acc, a, b| {
+        m1.zip_fold(m2, N::RealField::zero(), |acc, a, b| {
             let diff = a - b;
-            acc + diff * diff
+            acc + diff.modulus_squared()
         }).sqrt()
     }
 }
 
-impl<N: Real> Norm<N> for LpNorm {
+impl<N: ComplexField> Norm<N> for LpNorm {
     #[inline]
-    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N
+    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N::RealField
         where R: Dim, C: Dim, S: Storage<N, R, C> {
-        m.fold(N::zero(), |a, b| {
-            a + b.abs().powi(self.0)
-        }).powf(::convert(1.0 / (self.0 as f64)))
+        m.fold(N::RealField::zero(), |a, b| {
+            a + b.modulus().powi(self.0)
+        }).powf(crate::convert(1.0 / (self.0 as f64)))
     }
 
     #[inline]
-    fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N
+    fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N::RealField
         where R1: Dim, C1: Dim, S1: Storage<N, R1, C1>,
               R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
               ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
-        m1.zip_fold(m2, N::zero(), |acc, a, b| {
+        m1.zip_fold(m2, N::RealField::zero(), |acc, a, b| {
             let diff = a - b;
-            acc + diff.abs().powi(self.0)
-        }).powf(::convert(1.0 / (self.0 as f64)))
+            acc + diff.modulus().powi(self.0)
+        }).powf(crate::convert(1.0 / (self.0 as f64)))
     }
 }
 
-impl<N: Scalar + PartialOrd + Signed> Norm<N> for UniformNorm {
+impl<N: ComplexField> Norm<N> for UniformNorm {
     #[inline]
-    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N
+    fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N::RealField
         where R: Dim, C: Dim, S: Storage<N, R, C> {
-        m.amax()
+        // NOTE: we don't use `m.amax()` here because for the complex
+        // numbers this will return the max norm1 instead of the modulus.
+        m.fold(N::RealField::zero(), |acc, a| acc.max(a.modulus()))
     }
 
     #[inline]
-    fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N
+    fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N::RealField
         where R1: Dim, C1: Dim, S1: Storage<N, R1, C1>,
               R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
               ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
-        m1.zip_fold(m2, N::zero(), |acc, a, b| {
-            let val = (a - b).abs();
+        m1.zip_fold(m2, N::RealField::zero(), |acc, a, b| {
+            let val = (a - b).modulus();
             if val > acc {
                 val
             } else {
@@ -94,15 +95,15 @@ impl<N: Scalar + PartialOrd + Signed> Norm<N> for UniformNorm {
 }
 
 
-impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<N: ComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// The squared L2 norm of this vector.
     #[inline]
-    pub fn norm_squared(&self) -> N {
-        let mut res = N::zero();
+    pub fn norm_squared(&self) -> N::RealField {
+        let mut res = N::RealField::zero();
 
         for i in 0..self.ncols() {
             let col = self.column(i);
-            res += col.dot(&col)
+            res += col.dotc(&col).real()
         }
 
         res
@@ -112,7 +113,7 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     ///
     /// Use `.apply_norm` to apply a custom norm.
     #[inline]
-    pub fn norm(&self) -> N {
+    pub fn norm(&self) -> N::RealField {
         self.norm_squared().sqrt()
     }
 
@@ -120,7 +121,7 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     ///
     /// Use `.apply_metric_distance` to apply a custom norm.
     #[inline]
-    pub fn metric_distance<R2, C2, S2>(&self, rhs: &Matrix<N, R2, C2, S2>) -> N
+    pub fn metric_distance<R2, C2, S2>(&self, rhs: &Matrix<N, R2, C2, S2>) -> N::RealField
         where R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
               ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2> {
         self.apply_metric_distance(rhs, &EuclideanNorm)
@@ -139,7 +140,7 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(v.apply_norm(&EuclideanNorm), v.norm());
     /// ```
     #[inline]
-    pub fn apply_norm(&self, norm: &impl Norm<N>) -> N {
+    pub fn apply_norm(&self, norm: &impl Norm<N>) -> N::RealField {
         norm.norm(self)
     }
 
@@ -158,16 +159,10 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// assert_eq!(v1.apply_metric_distance(&v2, &EuclideanNorm), (v1 - v2).norm());
     /// ```
     #[inline]
-    pub fn apply_metric_distance<R2, C2, S2>(&self, rhs: &Matrix<N, R2, C2, S2>, norm: &impl Norm<N>) -> N
+    pub fn apply_metric_distance<R2, C2, S2>(&self, rhs: &Matrix<N, R2, C2, S2>, norm: &impl Norm<N>) -> N::RealField
         where R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
               ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2> {
-        norm.metric_distance(self,rhs)
-    }
-
-    /// The Lp norm of this matrix.
-    #[inline]
-    pub fn lp_norm(&self, p: i32) -> N {
-        self.apply_norm(&LpNorm(p))
+        norm.metric_distance(self, rhs)
     }
 
     /// A synonym for the norm of this matrix.
@@ -176,7 +171,7 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     ///
     /// This function is simply implemented as a call to `norm()`
     #[inline]
-    pub fn magnitude(&self) -> N {
+    pub fn magnitude(&self) -> N::RealField {
         self.norm()
     }
 
@@ -186,7 +181,7 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     ///
     /// This function is simply implemented as a call to `norm_squared()`
     #[inline]
-    pub fn magnitude_squared(&self) -> N {
+    pub fn magnitude_squared(&self) -> N::RealField {
         self.norm_squared()
     }
 
@@ -194,29 +189,36 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     #[inline]
     pub fn normalize(&self) -> MatrixMN<N, R, C>
         where DefaultAllocator: Allocator<N, R, C> {
-        self / self.norm()
+        self.unscale(self.norm())
     }
 
     /// Returns a normalized version of this matrix unless its norm as smaller or equal to `eps`.
     #[inline]
-    pub fn try_normalize(&self, min_norm: N) -> Option<MatrixMN<N, R, C>>
+    pub fn try_normalize(&self, min_norm: N::RealField) -> Option<MatrixMN<N, R, C>>
         where DefaultAllocator: Allocator<N, R, C> {
         let n = self.norm();
 
         if n <= min_norm {
             None
         } else {
-            Some(self / n)
+            Some(self.unscale(n))
         }
     }
+
+    /// The Lp norm of this matrix.
+    #[inline]
+    pub fn lp_norm(&self, p: i32) -> N::RealField {
+        self.apply_norm(&LpNorm(p))
+    }
 }
 
-impl<N: Real, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
+
+impl<N: ComplexField, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     /// Normalizes this matrix in-place and returns its norm.
     #[inline]
-    pub fn normalize_mut(&mut self) -> N {
+    pub fn normalize_mut(&mut self) -> N::RealField {
         let n = self.norm();
-        *self /= n;
+        self.unscale_mut(n);
 
         n
     }
@@ -225,13 +227,13 @@ impl<N: Real, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     ///
     /// If the normalization succeeded, returns the old normal of this matrix.
     #[inline]
-    pub fn try_normalize_mut(&mut self, min_norm: N) -> Option<N> {
+    pub fn try_normalize_mut(&mut self, min_norm: N::RealField) -> Option<N::RealField> {
         let n = self.norm();
 
         if n <= min_norm {
             None
         } else {
-            *self /= n;
+            self.unscale_mut(n);
             Some(n)
         }
     }
diff --git a/src/base/ops.rs b/src/base/ops.rs
index 301232f2e..cf921c331 100644
--- a/src/base/ops.rs
+++ b/src/base/ops.rs
@@ -5,15 +5,15 @@ use std::ops::{
     Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign,
 };
 
-use alga::general::{ClosedAdd, ClosedDiv, ClosedMul, ClosedNeg, ClosedSub};
+use alga::general::{ComplexField, ClosedAdd, ClosedDiv, ClosedMul, ClosedNeg, ClosedSub};
 
-use base::allocator::{Allocator, SameShapeAllocator, SameShapeC, SameShapeR};
-use base::constraint::{
+use crate::base::allocator::{Allocator, SameShapeAllocator, SameShapeC, SameShapeR};
+use crate::base::constraint::{
     AreMultipliable, DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint,
 };
-use base::dimension::{Dim, DimMul, DimName, DimProd, Dynamic};
-use base::storage::{ContiguousStorageMut, Storage, StorageMut};
-use base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, MatrixSum, Scalar};
+use crate::base::dimension::{Dim, DimMul, DimName, DimProd, Dynamic};
+use crate::base::storage::{ContiguousStorageMut, Storage, StorageMut};
+use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, MatrixSum, Scalar, VectorSliceN};
 
 /*
  *
@@ -689,13 +689,28 @@ where
         res
     }
 
-    /// Equivalent to `self.transpose() * rhs` but stores the result into `out` to avoid
-    /// allocations.
+    /// Equivalent to `self.adjoint() * rhs`.
     #[inline]
-    pub fn tr_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
+    pub fn ad_mul<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> MatrixMN<N, C1, C2>
+        where
+            N: ComplexField,
+            SB: Storage<N, R2, C2>,
+            DefaultAllocator: Allocator<N, C1, C2>,
+            ShapeConstraint: SameNumberOfRows<R1, R2>,
+    {
+        let mut res =
+            unsafe { Matrix::new_uninitialized_generic(self.data.shape().1, rhs.data.shape().1) };
+
+        self.ad_mul_to(rhs, &mut res);
+        res
+    }
+
+    #[inline(always)]
+    fn xx_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
         &self,
         rhs: &Matrix<N, R2, C2, SB>,
         out: &mut Matrix<N, R3, C3, SC>,
+        dot: impl Fn(&VectorSliceN<N, R1, SA::RStride, SA::CStride>, &VectorSliceN<N, R2, SB::RStride, SB::CStride>) -> N,
     ) where
         SB: Storage<N, R2, C2>,
         SC: StorageMut<N, R3, C3>,
@@ -716,12 +731,43 @@ where
 
         for i in 0..ncols1 {
             for j in 0..ncols2 {
-                let dot = self.column(i).dot(&rhs.column(j));
+                let dot = dot(&self.column(i), &rhs.column(j));
                 unsafe { *out.get_unchecked_mut((i, j)) = dot };
             }
         }
     }
 
+    /// Equivalent to `self.transpose() * rhs` but stores the result into `out` to avoid
+    /// allocations.
+    #[inline]
+    pub fn tr_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
+        &self,
+        rhs: &Matrix<N, R2, C2, SB>,
+        out: &mut Matrix<N, R3, C3, SC>,
+    ) where
+        SB: Storage<N, R2, C2>,
+        SC: StorageMut<N, R3, C3>,
+        ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
+    {
+        self.xx_mul_to(rhs, out, |a, b| a.dot(b))
+    }
+
+    /// Equivalent to `self.adjoint() * rhs` but stores the result into `out` to avoid
+    /// allocations.
+    #[inline]
+    pub fn ad_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
+        &self,
+        rhs: &Matrix<N, R2, C2, SB>,
+        out: &mut Matrix<N, R3, C3, SC>,
+    ) where
+        N: ComplexField,
+        SB: Storage<N, R2, C2>,
+        SC: StorageMut<N, R3, C3>,
+        ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
+    {
+        self.xx_mul_to(rhs, out, |a, b| a.dotc(b))
+    }
+
     /// Equivalent to `self * rhs` but stores the result into `out` to avoid allocations.
     #[inline]
     pub fn mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
@@ -820,16 +866,16 @@ where
     }
 }
 
-impl<N: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
-    /// Returns the absolute value of the component with the largest absolute value.
-    #[inline]
-    pub fn amax(&self) -> N {
-        let mut max = N::zero();
+impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+    #[inline(always)]
+    fn xcmp<N2>(&self, abs: impl Fn(N) -> N2, cmp: impl Fn(N2, N2) -> bool) -> N2
+        where N2: Scalar + PartialOrd + Zero {
+        let mut max = N2::zero();
 
         for e in self.iter() {
-            let ae = e.abs();
+            let ae = abs(*e);
 
-            if ae > max {
+            if cmp(ae, max) {
                 max = ae;
             }
         }
@@ -837,61 +883,45 @@ impl<N: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<N, R, C>> Matri
         max
     }
 
-    /// Returns the absolute value of the component with the smallest absolute value.
+    /// Returns the absolute value of the component with the largest absolute value.
     #[inline]
-    pub fn amin(&self) -> N {
-        let mut it = self.iter();
-        let mut min = it
-            .next()
-            .expect("amin: empty matrices not supported.")
-            .abs();
-
-        for e in it {
-            let ae = e.abs();
-
-            if ae < min {
-                min = ae;
-            }
-        }
+    pub fn amax(&self) -> N
+        where N: PartialOrd + Signed {
+        self.xcmp(|e| e.abs(), |a, b| a > b)
+    }
 
-        min
+    /// Returns the the 1-norm of the complex component with the largest 1-norm.
+    #[inline]
+    pub fn camax(&self) -> N::RealField
+        where N: ComplexField {
+        self.xcmp(|e| e.norm1(), |a, b| a > b)
     }
 
     /// Returns the component with the largest value.
     #[inline]
-    pub fn max(&self) -> N {
-        let mut it = self.iter();
-        let mut max = it
-            .next()
-            .expect("max: empty matrices not supported.");
-
-        for e in it {
-            let ae = e;
+    pub fn max(&self) -> N
+        where N: PartialOrd + Signed {
+        self.xcmp(|e| e, |a, b| a > b)
+    }
 
-            if ae > max {
-                max = ae;
-            }
-        }
+    /// Returns the absolute value of the component with the smallest absolute value.
+    #[inline]
+    pub fn amin(&self) -> N
+        where N: PartialOrd + Signed {
+        self.xcmp(|e| e.abs(), |a, b| a < b)
+    }
 
-        *max
+    /// Returns the the 1-norm of the complex component with the smallest 1-norm.
+    #[inline]
+    pub fn camin(&self) -> N::RealField
+        where N: ComplexField {
+        self.xcmp(|e| e.norm1(), |a, b| a < b)
     }
 
     /// Returns the component with the smallest value.
     #[inline]
-    pub fn min(&self) -> N {
-        let mut it = self.iter();
-        let mut min = it
-            .next()
-            .expect("min: empty matrices not supported.");
-
-        for e in it {
-            let ae = e;
-
-            if ae < min {
-                min = ae;
-            }
-        }
-
-        *min
+    pub fn min(&self) -> N
+        where N: PartialOrd + Signed {
+        self.xcmp(|e| e, |a, b| a < b)
     }
-}
+}
\ No newline at end of file
diff --git a/src/base/properties.rs b/src/base/properties.rs
index 7e5015758..8ca495688 100644
--- a/src/base/properties.rs
+++ b/src/base/properties.rs
@@ -2,12 +2,12 @@
 use approx::RelativeEq;
 use num::{One, Zero};
 
-use alga::general::{ClosedAdd, ClosedMul, Real};
+use alga::general::{ClosedAdd, ClosedMul, RealField, ComplexField};
 
-use base::allocator::Allocator;
-use base::dimension::{Dim, DimMin};
-use base::storage::Storage;
-use base::{DefaultAllocator, Matrix, Scalar, SquareMatrix};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{Dim, DimMin};
+use crate::base::storage::Storage;
+use crate::base::{DefaultAllocator, Matrix, Scalar, SquareMatrix};
 
 impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Indicates if this is an empty matrix.
@@ -82,24 +82,26 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
 
         true
     }
+}
 
+impl<N: ComplexField, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Checks that `Mᵀ × M = Id`.
     ///
     /// In this definition `Id` is approximately equal to the identity matrix with a relative error
     /// equal to `eps`.
     #[inline]
     pub fn is_orthogonal(&self, eps: N::Epsilon) -> bool
-    where
-        N: Zero + One + ClosedAdd + ClosedMul + RelativeEq,
-        S: Storage<N, R, C>,
-        N::Epsilon: Copy,
-        DefaultAllocator: Allocator<N, C, C>,
+        where
+            N: Zero + One + ClosedAdd + ClosedMul + RelativeEq,
+            S: Storage<N, R, C>,
+            N::Epsilon: Copy,
+            DefaultAllocator: Allocator<N, R, C> + Allocator<N, C, C>,
     {
-        (self.tr_mul(self)).is_identity(eps)
+        (self.ad_mul(self)).is_identity(eps)
     }
 }
 
-impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S>
+impl<N: RealField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S>
 where DefaultAllocator: Allocator<N, D, D>
 {
     /// Checks that this matrix is orthogonal and has a determinant equal to 1.
diff --git a/src/base/statistics.rs b/src/base/statistics.rs
index 11cc9e1c4..0fe181308 100644
--- a/src/base/statistics.rs
+++ b/src/base/statistics.rs
@@ -1,8 +1,9 @@
-use ::{Real, Dim, Matrix, VectorN, RowVectorN, DefaultAllocator, U1, VectorSliceN};
-use storage::Storage;
-use allocator::Allocator;
+use crate::{Scalar, Dim, Matrix, VectorN, RowVectorN, DefaultAllocator, U1, VectorSliceN};
+use alga::general::{Field, SupersetOf};
+use crate::storage::Storage;
+use crate::allocator::Allocator;
 
-impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Returns a row vector where each element is the result of the application of `f` on the
     /// corresponding column of the original matrix.
     #[inline]
@@ -53,7 +54,7 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     }
 }
 
-impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
+impl<N: Scalar + Field + SupersetOf<f64>, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /*
      *
      * Sum computation.
@@ -154,7 +155,7 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
             N::zero()
         } else {
             let val = self.iter().cloned().fold((N::zero(), N::zero()), |a, b| (a.0 + b * b, a.1 + b));
-            let denom = N::one() / ::convert::<_, N>(self.len() as f64);
+            let denom = N::one() / crate::convert::<_, N>(self.len() as f64);
             val.0 * denom - (val.1 * denom) * (val.1 * denom)
         }
     }
@@ -214,7 +215,7 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
         let mut mean = self.column_mean();
         mean.apply(|e| -(e * e));
 
-        let denom = N::one() / ::convert::<_, N>(ncols.value() as f64);
+        let denom = N::one() / crate::convert::<_, N>(ncols.value() as f64);
         self.compress_columns(mean, |out, col| {
             for i in 0..nrows.value() {
                 unsafe {
@@ -246,7 +247,7 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
         if self.len() == 0 {
             N::zero()
         } else {
-            self.sum() / ::convert(self.len() as f64)
+            self.sum() / crate::convert(self.len() as f64)
         }
     }
 
@@ -301,7 +302,7 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     pub fn column_mean(&self) -> VectorN<N, R>
         where DefaultAllocator: Allocator<N, R> {
         let (nrows, ncols) = self.data.shape();
-        let denom = N::one() / ::convert::<_, N>(ncols.value() as f64);
+        let denom = N::one() / crate::convert::<_, N>(ncols.value() as f64);
         self.compress_columns(VectorN::zeros_generic(nrows, U1), |out, col| {
             out.axpy(denom, &col, N::one())
         })
diff --git a/src/base/storage.rs b/src/base/storage.rs
index 0a07713b2..02941e478 100644
--- a/src/base/storage.rs
+++ b/src/base/storage.rs
@@ -3,10 +3,10 @@
 use std::fmt::Debug;
 use std::mem;
 
-use base::allocator::{Allocator, SameShapeC, SameShapeR};
-use base::default_allocator::DefaultAllocator;
-use base::dimension::{Dim, U1};
-use base::Scalar;
+use crate::base::allocator::{Allocator, SameShapeC, SameShapeR};
+use crate::base::default_allocator::DefaultAllocator;
+use crate::base::dimension::{Dim, U1};
+use crate::base::Scalar;
 
 /*
  * Aliases for allocation results.
diff --git a/src/base/swizzle.rs b/src/base/swizzle.rs
index b09316d49..4c9b0b63b 100644
--- a/src/base/swizzle.rs
+++ b/src/base/swizzle.rs
@@ -1,5 +1,5 @@
-use base::{DimName, Scalar, Vector, Vector2, Vector3};
-use storage::Storage;
+use crate::base::{DimName, Scalar, Vector, Vector2, Vector3};
+use crate::storage::Storage;
 use typenum::{self, Cmp, Greater};
 
 macro_rules! impl_swizzle {
diff --git a/src/base/unit.rs b/src/base/unit.rs
index 20f159560..6fe831da1 100644
--- a/src/base/unit.rs
+++ b/src/base/unit.rs
@@ -10,11 +10,9 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
-use alga::general::SubsetOf;
+use alga::general::{SubsetOf, ComplexField};
 use alga::linear::NormedSpace;
 
-use ::Real;
-
 /// A wrapper that ensures the underlying algebraic entity has a unit norm.
 ///
 /// Use `.as_ref()` or `.into_inner()` to obtain the underlying value by-reference or by-move.
@@ -66,13 +64,13 @@ impl<T: NormedSpace> Unit<T> {
     ///
     /// Returns `None` if the norm was smaller or equal to `min_norm`.
     #[inline]
-    pub fn try_new(value: T, min_norm: T::Field) -> Option<Self> {
+    pub fn try_new(value: T, min_norm: T::RealField) -> Option<Self> {
         Self::try_new_and_get(value, min_norm).map(|res| res.0)
     }
 
     /// Normalize the given value and return it wrapped on a `Unit` structure and its norm.
     #[inline]
-    pub fn new_and_get(mut value: T) -> (Self, T::Field) {
+    pub fn new_and_get(mut value: T) -> (Self, T::RealField) {
         let n = value.normalize_mut();
 
         (Unit { value: value }, n)
@@ -82,7 +80,7 @@ impl<T: NormedSpace> Unit<T> {
     ///
     /// Returns `None` if the norm was smaller or equal to `min_norm`.
     #[inline]
-    pub fn try_new_and_get(mut value: T, min_norm: T::Field) -> Option<(Self, T::Field)> {
+    pub fn try_new_and_get(mut value: T, min_norm: T::RealField) -> Option<(Self, T::RealField)> {
         if let Some(n) = value.try_normalize_mut(min_norm) {
             Some((Unit { value: value }, n))
         } else {
@@ -96,7 +94,7 @@ impl<T: NormedSpace> Unit<T> {
     /// Returns the norm before re-normalization. See `.renormalize_fast` for a faster alternative
     /// that may be slightly less accurate if `self` drifted significantly from having a unit length.
     #[inline]
-    pub fn renormalize(&mut self) -> T::Field {
+    pub fn renormalize(&mut self) -> T::RealField {
         self.value.normalize_mut()
     }
 
@@ -104,12 +102,11 @@ impl<T: NormedSpace> Unit<T> {
     /// This is useful when repeated computations might cause a drift in the norm
     /// because of float inaccuracies.
     #[inline]
-    pub fn renormalize_fast(&mut self)
-        where T::Field: Real {
+    pub fn renormalize_fast(&mut self) {
         let sq_norm = self.value.norm_squared();
-        let _3: T::Field = ::convert(3.0);
-        let _0_5: T::Field = ::convert(0.5);
-        self.value *= _0_5 * (_3 - sq_norm);
+        let _3: T::RealField = crate::convert(3.0);
+        let _0_5: T::RealField = crate::convert(0.5);
+        self.value *= T::ComplexField::from_real(_0_5 * (_3 - sq_norm));
     }
 }
 
@@ -171,7 +168,7 @@ where T::Field: RelativeEq
 
     #[inline]
     fn is_in_subset(value: &T) -> bool {
-        relative_eq!(value.norm_squared(), ::one())
+        relative_eq!(value.norm_squared(), crate::one())
     }
 
     #[inline]
diff --git a/src/base/vec_storage.rs b/src/base/vec_storage.rs
index afde36775..2b4bf7432 100644
--- a/src/base/vec_storage.rs
+++ b/src/base/vec_storage.rs
@@ -4,12 +4,12 @@ use std::io::{Result as IOResult, Write};
 #[cfg(all(feature = "alloc", not(feature = "std")))]
 use alloc::vec::Vec;
 
-use base::allocator::Allocator;
-use base::default_allocator::DefaultAllocator;
-use base::dimension::{Dim, DimName, Dynamic, U1};
-use base::storage::{ContiguousStorage, ContiguousStorageMut, Owned, Storage, StorageMut};
-use base::{Scalar, Vector};
-use base::constraint::{SameNumberOfRows, ShapeConstraint};
+use crate::base::allocator::Allocator;
+use crate::base::default_allocator::DefaultAllocator;
+use crate::base::dimension::{Dim, DimName, Dynamic, U1};
+use crate::base::storage::{ContiguousStorage, ContiguousStorageMut, Owned, Storage, StorageMut};
+use crate::base::{Scalar, Vector};
+use crate::base::constraint::{SameNumberOfRows, ShapeConstraint};
 
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
diff --git a/src/debug/random_orthogonal.rs b/src/debug/random_orthogonal.rs
index 6d393a24d..421b041a6 100644
--- a/src/debug/random_orthogonal.rs
+++ b/src/debug/random_orthogonal.rs
@@ -1,24 +1,24 @@
 #[cfg(feature = "arbitrary")]
-use base::storage::Owned;
+use crate::base::storage::Owned;
 #[cfg(feature = "arbitrary")]
 use quickcheck::{Arbitrary, Gen};
 
-use alga::general::Real;
-use base::allocator::Allocator;
-use base::dimension::{Dim, Dynamic, U2};
-use base::{DefaultAllocator, MatrixN};
-use geometry::UnitComplex;
-use num_complex::Complex;
+use alga::general::ComplexField;
+use crate::base::Scalar;
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{Dim, Dynamic, U2};
+use crate::base::{DefaultAllocator, MatrixN};
+use crate::linalg::givens::GivensRotation;
 
 /// A random orthogonal matrix.
 #[derive(Clone, Debug)]
-pub struct RandomOrthogonal<N: Real, D: Dim = Dynamic>
+pub struct RandomOrthogonal<N: Scalar, D: Dim = Dynamic>
 where DefaultAllocator: Allocator<N, D, D>
 {
     m: MatrixN<N, D>,
 }
 
-impl<N: Real, D: Dim> RandomOrthogonal<N, D>
+impl<N: ComplexField, D: Dim> RandomOrthogonal<N, D>
 where DefaultAllocator: Allocator<N, D, D>
 {
     /// Retrieve the generated matrix.
@@ -30,10 +30,9 @@ where DefaultAllocator: Allocator<N, D, D>
     pub fn new<Rand: FnMut() -> N>(dim: D, mut rand: Rand) -> Self {
         let mut res = MatrixN::identity_generic(dim, dim);
 
-        // Create an orthogonal matrix by compositing planar 2D rotations.
+        // Create an orthogonal matrix by composing random Givens rotations rotations.
         for i in 0..dim.value() - 1 {
-            let c = Complex::new(rand(), rand());
-            let rot: UnitComplex<N> = UnitComplex::from_complex(c);
+            let rot = GivensRotation::new(rand(), rand()).0;
             rot.rotate(&mut res.fixed_rows_mut::<U2>(i));
         }
 
@@ -42,7 +41,7 @@ where DefaultAllocator: Allocator<N, D, D>
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: Real + Arbitrary + Send, D: Dim> Arbitrary for RandomOrthogonal<N, D>
+impl<N: ComplexField + Arbitrary + Send, D: Dim> Arbitrary for RandomOrthogonal<N, D>
 where
     DefaultAllocator: Allocator<N, D, D>,
     Owned<N, D, D>: Clone + Send,
diff --git a/src/debug/random_sdp.rs b/src/debug/random_sdp.rs
index 7835c775b..47e3ca601 100644
--- a/src/debug/random_sdp.rs
+++ b/src/debug/random_sdp.rs
@@ -1,24 +1,25 @@
 #[cfg(feature = "arbitrary")]
-use base::storage::Owned;
+use crate::base::storage::Owned;
 #[cfg(feature = "arbitrary")]
 use quickcheck::{Arbitrary, Gen};
 
-use alga::general::Real;
-use base::allocator::Allocator;
-use base::dimension::{Dim, Dynamic};
-use base::{DefaultAllocator, MatrixN};
+use alga::general::ComplexField;
+use crate::base::Scalar;
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{Dim, Dynamic};
+use crate::base::{DefaultAllocator, MatrixN};
 
-use debug::RandomOrthogonal;
+use crate::debug::RandomOrthogonal;
 
 /// A random, well-conditioned, symmetric definite-positive matrix.
 #[derive(Clone, Debug)]
-pub struct RandomSDP<N: Real, D: Dim = Dynamic>
+pub struct RandomSDP<N: Scalar, D: Dim = Dynamic>
 where DefaultAllocator: Allocator<N, D, D>
 {
     m: MatrixN<N, D>,
 }
 
-impl<N: Real, D: Dim> RandomSDP<N, D>
+impl<N: ComplexField, D: Dim> RandomSDP<N, D>
 where DefaultAllocator: Allocator<N, D, D>
 {
     /// Retrieve the generated matrix.
@@ -30,11 +31,11 @@ where DefaultAllocator: Allocator<N, D, D>
     /// random reals generators.
     pub fn new<Rand: FnMut() -> N>(dim: D, mut rand: Rand) -> Self {
         let mut m = RandomOrthogonal::new(dim, || rand()).unwrap();
-        let mt = m.transpose();
+        let mt = m.adjoint();
 
         for i in 0..dim.value() {
             let mut col = m.column_mut(i);
-            let eigenval = N::one() + rand().abs();
+            let eigenval = N::one() + N::from_real(rand().modulus());
             col *= eigenval;
         }
 
@@ -43,7 +44,7 @@ where DefaultAllocator: Allocator<N, D, D>
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: Real + Arbitrary + Send, D: Dim> Arbitrary for RandomSDP<N, D>
+impl<N: ComplexField + Arbitrary + Send, D: Dim> Arbitrary for RandomSDP<N, D>
 where
     DefaultAllocator: Allocator<N, D, D>,
     Owned<N, D, D>: Clone + Send,
diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs
index 1ffbbe3ad..888a8307c 100755
--- a/src/geometry/isometry.rs
+++ b/src/geometry/isometry.rs
@@ -11,14 +11,14 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
-use alga::general::{Real, SubsetOf};
+use alga::general::{RealField, SubsetOf};
 use alga::linear::Rotation;
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use base::storage::Owned;
-use base::{DefaultAllocator, MatrixN, VectorN};
-use geometry::{Point, Translation};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::storage::Owned;
+use crate::base::{DefaultAllocator, MatrixN, VectorN};
+use crate::geometry::{Point, Translation};
 
 /// A direct isometry, i.e., a rotation followed by a translation, aka. a rigid-body motion, aka. an element of a Special Euclidean (SE) group.
 #[repr(C)]
@@ -36,7 +36,7 @@ use geometry::{Point, Translation};
                        DefaultAllocator: Allocator<N, D>,
                        Owned<N, D>: Deserialize<'de>"))
 )]
-pub struct Isometry<N: Real, D: DimName, R>
+pub struct Isometry<N: RealField, D: DimName, R>
 where DefaultAllocator: Allocator<N, D>
 {
     /// The pure rotational part of this isometry.
@@ -55,7 +55,7 @@ where DefaultAllocator: Allocator<N, D>
 #[cfg(feature = "abomonation-serialize")]
 impl<N, D, R> Abomonation for Isometry<N, D, R>
 where
-    N: Real,
+    N: RealField,
     D: DimName,
     R: Abomonation,
     Translation<N, D>: Abomonation,
@@ -77,7 +77,7 @@ where
     }
 }
 
-impl<N: Real + hash::Hash, D: DimName + hash::Hash, R: hash::Hash> hash::Hash for Isometry<N, D, R>
+impl<N: RealField + hash::Hash, D: DimName + hash::Hash, R: hash::Hash> hash::Hash for Isometry<N, D, R>
 where
     DefaultAllocator: Allocator<N, D>,
     Owned<N, D>: hash::Hash,
@@ -88,14 +88,14 @@ where
     }
 }
 
-impl<N: Real, D: DimName + Copy, R: Rotation<Point<N, D>> + Copy> Copy for Isometry<N, D, R>
+impl<N: RealField, D: DimName + Copy, R: Rotation<Point<N, D>> + Copy> Copy for Isometry<N, D, R>
 where
     DefaultAllocator: Allocator<N, D>,
     Owned<N, D>: Copy,
 {
 }
 
-impl<N: Real, D: DimName, R: Rotation<Point<N, D>> + Clone> Clone for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R: Rotation<Point<N, D>> + Clone> Clone for Isometry<N, D, R>
 where DefaultAllocator: Allocator<N, D>
 {
     #[inline]
@@ -104,7 +104,7 @@ where DefaultAllocator: Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName, R: Rotation<Point<N, D>>> Isometry<N, D, R>
+impl<N: RealField, D: DimName, R: Rotation<Point<N, D>>> Isometry<N, D, R>
 where DefaultAllocator: Allocator<N, D>
 {
     /// Creates a new isometry from its rotational and translational parts.
@@ -351,7 +351,7 @@ where DefaultAllocator: Allocator<N, D>
 // and makes it hard to use it, e.g., for Transform × Isometry implementation.
 // This is OK since all constructors of the isometry enforce the Rotation bound already (and
 // explicit struct construction is prevented by the dummy ZST field).
-impl<N: Real, D: DimName, R> Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> Isometry<N, D, R>
 where DefaultAllocator: Allocator<N, D>
 {
     /// Converts this isometry into its equivalent homogeneous transformation matrix.
@@ -376,7 +376,7 @@ where DefaultAllocator: Allocator<N, D>
         R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
         DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
     {
-        let mut res: MatrixN<N, _> = ::convert_ref(&self.rotation);
+        let mut res: MatrixN<N, _> = crate::convert_ref(&self.rotation);
         res.fixed_slice_mut::<D, U1>(0, D::dim())
             .copy_from(&self.translation.vector);
 
@@ -384,14 +384,14 @@ where DefaultAllocator: Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName, R> Eq for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> Eq for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>> + Eq,
     DefaultAllocator: Allocator<N, D>,
 {
 }
 
-impl<N: Real, D: DimName, R> PartialEq for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> PartialEq for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>> + PartialEq,
     DefaultAllocator: Allocator<N, D>,
@@ -402,7 +402,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> AbsDiffEq for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> AbsDiffEq for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>> + AbsDiffEq<Epsilon = N::Epsilon>,
     DefaultAllocator: Allocator<N, D>,
@@ -422,7 +422,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> RelativeEq for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> RelativeEq for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>> + RelativeEq<Epsilon = N::Epsilon>,
     DefaultAllocator: Allocator<N, D>,
@@ -449,7 +449,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> UlpsEq for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> UlpsEq for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>> + UlpsEq<Epsilon = N::Epsilon>,
     DefaultAllocator: Allocator<N, D>,
@@ -473,7 +473,7 @@ where
  * Display
  *
  */
-impl<N: Real + fmt::Display, D: DimName, R> fmt::Display for Isometry<N, D, R>
+impl<N: RealField + fmt::Display, D: DimName, R> fmt::Display for Isometry<N, D, R>
 where
     R: fmt::Display,
     DefaultAllocator: Allocator<N, D> + Allocator<usize, D>,
@@ -481,9 +481,9 @@ where
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let precision = f.precision().unwrap_or(3);
 
-        try!(writeln!(f, "Isometry {{"));
-        try!(write!(f, "{:.*}", precision, self.translation));
-        try!(write!(f, "{:.*}", precision, self.rotation));
+        writeln!(f, "Isometry {{")?;
+        write!(f, "{:.*}", precision, self.translation)?;
+        write!(f, "{:.*}", precision, self.rotation)?;
         writeln!(f, "}}")
     }
 }
diff --git a/src/geometry/isometry_alga.rs b/src/geometry/isometry_alga.rs
index 5a4f749cc..e68b269c2 100755
--- a/src/geometry/isometry_alga.rs
+++ b/src/geometry/isometry_alga.rs
@@ -1,6 +1,6 @@
 use alga::general::{
     AbstractGroup, AbstractLoop, AbstractMagma, AbstractMonoid, AbstractQuasigroup,
-    AbstractSemigroup, Id, Identity, TwoSidedInverse, Multiplicative, Real,
+    AbstractSemigroup, Id, Identity, TwoSidedInverse, Multiplicative, RealField,
 };
 use alga::linear::Isometry as AlgaIsometry;
 use alga::linear::{
@@ -8,18 +8,18 @@ use alga::linear::{
     Transformation,
 };
 
-use base::allocator::Allocator;
-use base::dimension::DimName;
-use base::{DefaultAllocator, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::DimName;
+use crate::base::{DefaultAllocator, VectorN};
 
-use geometry::{Isometry, Point, Translation};
+use crate::geometry::{Isometry, Point, Translation};
 
 /*
  *
  * Algebraic structures.
  *
  */
-impl<N: Real, D: DimName, R> Identity<Multiplicative> for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> Identity<Multiplicative> for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -30,7 +30,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> TwoSidedInverse<Multiplicative> for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> TwoSidedInverse<Multiplicative> for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -46,7 +46,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> AbstractMagma<Multiplicative> for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> AbstractMagma<Multiplicative> for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -59,7 +59,7 @@ where
 
 macro_rules! impl_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: Real, D: DimName, R> $marker<$operator> for Isometry<N, D, R>
+        impl<N: RealField, D: DimName, R> $marker<$operator> for Isometry<N, D, R>
             where R: Rotation<Point<N, D>>,
                   DefaultAllocator: Allocator<N, D> { }
     )*}
@@ -78,7 +78,7 @@ impl_multiplicative_structures!(
  * Transformation groups.
  *
  */
-impl<N: Real, D: DimName, R> Transformation<Point<N, D>> for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> Transformation<Point<N, D>> for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -94,7 +94,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> ProjectiveTransformation<Point<N, D>> for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> ProjectiveTransformation<Point<N, D>> for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -110,7 +110,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> AffineTransformation<Point<N, D>> for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> AffineTransformation<Point<N, D>> for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -168,7 +168,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> Similarity<Point<N, D>> for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R> Similarity<Point<N, D>> for Isometry<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -193,7 +193,7 @@ where
 
 macro_rules! marker_impl(
     ($($Trait: ident),*) => {$(
-        impl<N: Real, D: DimName, R> $Trait<Point<N, D>> for Isometry<N, D, R>
+        impl<N: RealField, D: DimName, R> $Trait<Point<N, D>> for Isometry<N, D, R>
         where R: Rotation<Point<N, D>>,
               DefaultAllocator: Allocator<N, D> { }
     )*}
diff --git a/src/geometry/isometry_alias.rs b/src/geometry/isometry_alias.rs
index a0804b5c5..ba9a69e7d 100644
--- a/src/geometry/isometry_alias.rs
+++ b/src/geometry/isometry_alias.rs
@@ -1,6 +1,6 @@
-use base::dimension::{U2, U3};
+use crate::base::dimension::{U2, U3};
 
-use geometry::{Isometry, Rotation2, Rotation3, UnitComplex, UnitQuaternion};
+use crate::geometry::{Isometry, Rotation2, Rotation3, UnitComplex, UnitQuaternion};
 
 /// A 2-dimensional direct isometry using a unit complex number for its rotational part. Also known as a rigid-body motion, or as an element of SE(2).
 pub type Isometry2<N> = Isometry<N, U2, UnitComplex<N>>;
diff --git a/src/geometry/isometry_construction.rs b/src/geometry/isometry_construction.rs
index 5a402c0a2..979c39556 100644
--- a/src/geometry/isometry_construction.rs
+++ b/src/geometry/isometry_construction.rs
@@ -1,5 +1,5 @@
 #[cfg(feature = "arbitrary")]
-use base::storage::Owned;
+use crate::base::storage::Owned;
 #[cfg(feature = "arbitrary")]
 use quickcheck::{Arbitrary, Gen};
 
@@ -7,19 +7,19 @@ use num::One;
 use rand::distributions::{Distribution, Standard};
 use rand::Rng;
 
-use alga::general::Real;
+use alga::general::RealField;
 use alga::linear::Rotation as AlgaRotation;
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, U2, U3};
-use base::{DefaultAllocator, Vector2, Vector3};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, U2, U3};
+use crate::base::{DefaultAllocator, Vector2, Vector3};
 
-use geometry::{
+use crate::geometry::{
     Isometry, Point, Point3, Rotation, Rotation2, Rotation3, Translation, UnitComplex,
     UnitQuaternion, Translation2, Translation3
 };
 
-impl<N: Real, D: DimName, R: AlgaRotation<Point<N, D>>> Isometry<N, D, R>
+impl<N: RealField, D: DimName, R: AlgaRotation<Point<N, D>>> Isometry<N, D, R>
 where DefaultAllocator: Allocator<N, D>
 {
     /// Creates a new identity isometry.
@@ -65,7 +65,7 @@ where DefaultAllocator: Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName, R: AlgaRotation<Point<N, D>>> One for Isometry<N, D, R>
+impl<N: RealField, D: DimName, R: AlgaRotation<Point<N, D>>> One for Isometry<N, D, R>
 where DefaultAllocator: Allocator<N, D>
 {
     /// Creates a new identity isometry.
@@ -75,7 +75,7 @@ where DefaultAllocator: Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName, R> Distribution<Isometry<N, D, R>> for Standard
+impl<N: RealField, D: DimName, R> Distribution<Isometry<N, D, R>> for Standard
 where
     R: AlgaRotation<Point<N, D>>,
     Standard: Distribution<N> + Distribution<R>,
@@ -90,7 +90,7 @@ where
 #[cfg(feature = "arbitrary")]
 impl<N, D: DimName, R> Arbitrary for Isometry<N, D, R>
 where
-    N: Real + Arbitrary + Send,
+    N: RealField + Arbitrary + Send,
     R: AlgaRotation<Point<N, D>> + Arbitrary + Send,
     Owned<N, D>: Send,
     DefaultAllocator: Allocator<N, D>,
@@ -108,7 +108,7 @@ where
  */
 
 // 2D rotation.
-impl<N: Real> Isometry<N, U2, Rotation2<N>> {
+impl<N: RealField> Isometry<N, U2, Rotation2<N>> {
     /// Creates a new 2D isometry from a translation and a rotation angle.
     ///
     /// Its rotational part is represented as a 2x2 rotation matrix.
@@ -143,7 +143,7 @@ impl<N: Real> Isometry<N, U2, Rotation2<N>> {
     }
 }
 
-impl<N: Real> Isometry<N, U2, UnitComplex<N>> {
+impl<N: RealField> Isometry<N, U2, UnitComplex<N>> {
     /// Creates a new 2D isometry from a translation and a rotation angle.
     ///
     /// Its rotational part is represented as an unit complex number.
@@ -181,7 +181,7 @@ impl<N: Real> Isometry<N, U2, UnitComplex<N>> {
 // 3D rotation.
 macro_rules! isometry_construction_impl(
     ($RotId: ident < $($RotParams: ident),*>, $RRDim: ty, $RCDim: ty) => {
-        impl<N: Real> Isometry<N, U3, $RotId<$($RotParams),*>> {
+        impl<N: RealField> Isometry<N, U3, $RotId<$($RotParams),*>> {
             /// Creates a new isometry from a translation and a rotation axis-angle.
             ///
             /// # Example
diff --git a/src/geometry/isometry_conversion.rs b/src/geometry/isometry_conversion.rs
index 5dc460094..4a794f55e 100644
--- a/src/geometry/isometry_conversion.rs
+++ b/src/geometry/isometry_conversion.rs
@@ -1,11 +1,11 @@
-use alga::general::{Real, SubsetOf, SupersetOf};
+use alga::general::{RealField, SubsetOf, SupersetOf};
 use alga::linear::Rotation;
 
-use base::allocator::Allocator;
-use base::dimension::{DimMin, DimName, DimNameAdd, DimNameSum, U1};
-use base::{DefaultAllocator, MatrixN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimMin, DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::{DefaultAllocator, MatrixN};
 
-use geometry::{Isometry, Point, Similarity, SuperTCategoryOf, TAffine, Transform, Translation};
+use crate::geometry::{Isometry, Point, Similarity, SuperTCategoryOf, TAffine, Transform, Translation};
 
 /*
  * This file provides the following conversions:
@@ -19,8 +19,8 @@ use geometry::{Isometry, Point, Similarity, SuperTCategoryOf, TAffine, Transform
 
 impl<N1, N2, D: DimName, R1, R2> SubsetOf<Isometry<N2, D, R2>> for Isometry<N1, D, R1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
     R2: Rotation<Point<N2, D>>,
     DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
@@ -32,8 +32,8 @@ where
 
     #[inline]
     fn is_in_subset(iso: &Isometry<N2, D, R2>) -> bool {
-        ::is_convertible::<_, Translation<N1, D>>(&iso.translation)
-            && ::is_convertible::<_, R1>(&iso.rotation)
+        crate::is_convertible::<_, Translation<N1, D>>(&iso.translation)
+            && crate::is_convertible::<_, R1>(&iso.rotation)
     }
 
     #[inline]
@@ -47,8 +47,8 @@ where
 
 impl<N1, N2, D: DimName, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Isometry<N1, D, R1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
     R2: Rotation<Point<N2, D>>,
     DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
@@ -60,19 +60,19 @@ where
 
     #[inline]
     fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool {
-        ::is_convertible::<_, Isometry<N1, D, R1>>(&sim.isometry) && sim.scaling() == N2::one()
+        crate::is_convertible::<_, Isometry<N1, D, R1>>(&sim.isometry) && sim.scaling() == N2::one()
     }
 
     #[inline]
     unsafe fn from_superset_unchecked(sim: &Similarity<N2, D, R2>) -> Self {
-        ::convert_ref_unchecked(&sim.isometry)
+        crate::convert_ref_unchecked(&sim.isometry)
     }
 }
 
 impl<N1, N2, D, R, C> SubsetOf<Transform<N2, D, C>> for Isometry<N1, D, R>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     C: SuperTCategoryOf<TAffine>,
     R: Rotation<Point<N1, D>>
         + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>>
@@ -105,8 +105,8 @@ where
 
 impl<N1, N2, D, R> SubsetOf<MatrixN<N2, DimNameSum<D, U1>>> for Isometry<N1, D, R>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R: Rotation<Point<N1, D>>
         + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>>
         + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
@@ -133,7 +133,7 @@ where
         // Scalar types agree.
         m.iter().all(|e| SupersetOf::<N1>::is_in_subset(e)) &&
         // The block part is a rotation.
-        rot.is_special_orthogonal(N2::default_epsilon() * ::convert(100.0)) &&
+        rot.is_special_orthogonal(N2::default_epsilon() * crate::convert(100.0)) &&
         // The bottom row is (0, 0, ..., 1)
         bottom.iter().all(|e| e.is_zero()) && m[(D::dim(), D::dim())] == N2::one()
     }
@@ -142,14 +142,14 @@ where
     unsafe fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self {
         let t = m.fixed_slice::<D, U1>(0, D::dim()).into_owned();
         let t = Translation {
-            vector: ::convert_unchecked(t),
+            vector: crate::convert_unchecked(t),
         };
 
-        Self::from_parts(t, ::convert_unchecked(m.clone_owned()))
+        Self::from_parts(t, crate::convert_unchecked(m.clone_owned()))
     }
 }
 
-impl<N: Real, D: DimName, R> From<Isometry<N, D, R>> for MatrixN<N, DimNameSum<D, U1>>
+impl<N: RealField, D: DimName, R> From<Isometry<N, D, R>> for MatrixN<N, DimNameSum<D, U1>>
 where
     D: DimNameAdd<U1>,
     R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
diff --git a/src/geometry/isometry_ops.rs b/src/geometry/isometry_ops.rs
index 6a4b921ea..6ba9eb3ef 100644
--- a/src/geometry/isometry_ops.rs
+++ b/src/geometry/isometry_ops.rs
@@ -1,13 +1,13 @@
 use std::ops::{Div, DivAssign, Mul, MulAssign};
 
-use alga::general::Real;
+use alga::general::RealField;
 use alga::linear::Rotation as AlgaRotation;
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, U1, U3, U4};
-use base::{DefaultAllocator, Unit, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, U1, U3, U4};
+use crate::base::{DefaultAllocator, Unit, VectorN};
 
-use geometry::{Isometry, Point, Rotation, Translation, UnitQuaternion};
+use crate::geometry::{Isometry, Point, Rotation, Translation, UnitQuaternion};
 
 // FIXME: there are several cloning of rotations that we could probably get rid of (but we didn't
 // yet because that would require to add a bound like `where for<'a, 'b> &'a R: Mul<&'b R, Output = R>`
@@ -64,7 +64,7 @@ macro_rules! isometry_binop_impl(
     ($Op: ident, $op: ident;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: Real, D: DimName, R> $Op<$Rhs> for $Lhs
+        impl<$($lives ,)* N: RealField, D: DimName, R> $Op<$Rhs> for $Lhs
             where R: AlgaRotation<Point<N, D>>,
                   DefaultAllocator: Allocator<N, D> {
             type Output = $Output;
@@ -111,7 +111,7 @@ macro_rules! isometry_binop_assign_impl_all(
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty;
      [val] => $action_val: expr;
      [ref] => $action_ref: expr;) => {
-        impl<N: Real, D: DimName, R> $OpAssign<$Rhs> for $Lhs
+        impl<N: RealField, D: DimName, R> $OpAssign<$Rhs> for $Lhs
             where R: AlgaRotation<Point<N, D>>,
                   DefaultAllocator: Allocator<N, D> {
             #[inline]
@@ -120,7 +120,7 @@ macro_rules! isometry_binop_assign_impl_all(
             }
         }
 
-        impl<'b, N: Real, D: DimName, R> $OpAssign<&'b $Rhs> for $Lhs
+        impl<'b, N: RealField, D: DimName, R> $OpAssign<&'b $Rhs> for $Lhs
             where R: AlgaRotation<Point<N, D>>,
                   DefaultAllocator: Allocator<N, D> {
             #[inline]
@@ -286,7 +286,7 @@ macro_rules! isometry_from_composition_impl(
      ($R1: ty, $C1: ty),($R2: ty, $C2: ty) $(for $Dims: ident: $DimsBound: ident),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: Real $(, $Dims: $DimsBound)*> $Op<$Rhs> for $Lhs
+        impl<$($lives ,)* N: RealField $(, $Dims: $DimsBound)*> $Op<$Rhs> for $Lhs
             where DefaultAllocator: Allocator<N, $R1, $C1> +
                                     Allocator<N, $R2, $C2> {
             type Output = $Output;
diff --git a/src/geometry/orthographic.rs b/src/geometry/orthographic.rs
index 3117c1b62..2c7131182 100644
--- a/src/geometry/orthographic.rs
+++ b/src/geometry/orthographic.rs
@@ -7,36 +7,36 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt;
 use std::mem;
 
-use alga::general::Real;
+use alga::general::RealField;
 
-use base::dimension::U3;
-use base::helper;
-use base::storage::Storage;
-use base::{Matrix4, Vector, Vector3};
+use crate::base::dimension::U3;
+use crate::base::helper;
+use crate::base::storage::Storage;
+use crate::base::{Matrix4, Vector, Vector3};
 
-use geometry::{Point3, Projective3};
+use crate::geometry::{Point3, Projective3};
 
 /// A 3D orthographic projection stored as an homogeneous 4x4 matrix.
-pub struct Orthographic3<N: Real> {
+pub struct Orthographic3<N: RealField> {
     matrix: Matrix4<N>,
 }
 
-impl<N: Real> Copy for Orthographic3<N> {}
+impl<N: RealField> Copy for Orthographic3<N> {}
 
-impl<N: Real> Clone for Orthographic3<N> {
+impl<N: RealField> Clone for Orthographic3<N> {
     #[inline]
     fn clone(&self) -> Self {
         Self::from_matrix_unchecked(self.matrix.clone())
     }
 }
 
-impl<N: Real> fmt::Debug for Orthographic3<N> {
+impl<N: RealField> fmt::Debug for Orthographic3<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         self.matrix.fmt(f)
     }
 }
 
-impl<N: Real> PartialEq for Orthographic3<N> {
+impl<N: RealField> PartialEq for Orthographic3<N> {
     #[inline]
     fn eq(&self, right: &Self) -> bool {
         self.matrix == right.matrix
@@ -44,7 +44,7 @@ impl<N: Real> PartialEq for Orthographic3<N> {
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: Real + Serialize> Serialize for Orthographic3<N> {
+impl<N: RealField + Serialize> Serialize for Orthographic3<N> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where S: Serializer {
         self.matrix.serialize(serializer)
@@ -52,7 +52,7 @@ impl<N: Real + Serialize> Serialize for Orthographic3<N> {
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: Real + Deserialize<'a>> Deserialize<'a> for Orthographic3<N> {
+impl<'a, N: RealField + Deserialize<'a>> Deserialize<'a> for Orthographic3<N> {
     fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
     where Des: Deserializer<'a> {
         let matrix = Matrix4::<N>::deserialize(deserializer)?;
@@ -61,7 +61,7 @@ impl<'a, N: Real + Deserialize<'a>> Deserialize<'a> for Orthographic3<N> {
     }
 }
 
-impl<N: Real> Orthographic3<N> {
+impl<N: RealField> Orthographic3<N> {
     /// Creates a new orthographic projection matrix.
     ///
     /// This follows the OpenGL convention, so this will flip the `z` axis.
@@ -150,7 +150,7 @@ impl<N: Real> Orthographic3<N> {
             "The apsect ratio must not be zero."
         );
 
-        let half: N = ::convert(0.5);
+        let half: N = crate::convert(0.5);
         let width = zfar * (vfov * half).tan();
         let height = width / aspect;
 
@@ -623,7 +623,7 @@ impl<N: Real> Orthographic3<N> {
             left != right,
             "The left corner must not be equal to the right corner."
         );
-        self.matrix[(0, 0)] = ::convert::<_, N>(2.0) / (right - left);
+        self.matrix[(0, 0)] = crate::convert::<_, N>(2.0) / (right - left);
         self.matrix[(0, 3)] = -(right + left) / (right - left);
     }
 
@@ -648,7 +648,7 @@ impl<N: Real> Orthographic3<N> {
             bottom != top,
             "The top corner must not be equal to the bottom corner."
         );
-        self.matrix[(1, 1)] = ::convert::<_, N>(2.0) / (top - bottom);
+        self.matrix[(1, 1)] = crate::convert::<_, N>(2.0) / (top - bottom);
         self.matrix[(1, 3)] = -(top + bottom) / (top - bottom);
     }
 
@@ -673,12 +673,12 @@ impl<N: Real> Orthographic3<N> {
             zfar != znear,
             "The near-plane and far-plane must not be superimposed."
         );
-        self.matrix[(2, 2)] = -::convert::<_, N>(2.0) / (zfar - znear);
+        self.matrix[(2, 2)] = -crate::convert::<_, N>(2.0) / (zfar - znear);
         self.matrix[(2, 3)] = -(zfar + znear) / (zfar - znear);
     }
 }
 
-impl<N: Real> Distribution<Orthographic3<N>> for Standard
+impl<N: RealField> Distribution<Orthographic3<N>> for Standard
 where Standard: Distribution<N>
 {
     fn sample<R: Rng + ?Sized>(&self, r: &mut R) -> Orthographic3<N> {
@@ -694,7 +694,7 @@ where Standard: Distribution<N>
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: Real + Arbitrary> Arbitrary for Orthographic3<N>
+impl<N: RealField + Arbitrary> Arbitrary for Orthographic3<N>
 where Matrix4<N>: Send
 {
     fn arbitrary<G: Gen>(g: &mut G) -> Self {
@@ -709,7 +709,7 @@ where Matrix4<N>: Send
     }
 }
 
-impl<N: Real> From<Orthographic3<N>> for Matrix4<N> {
+impl<N: RealField> From<Orthographic3<N>> for Matrix4<N> {
     #[inline]
     fn from(orth: Orthographic3<N>) -> Self {
         orth.into_inner()
diff --git a/src/geometry/perspective.rs b/src/geometry/perspective.rs
index 550469be1..8020c0cf5 100644
--- a/src/geometry/perspective.rs
+++ b/src/geometry/perspective.rs
@@ -8,36 +8,36 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt;
 use std::mem;
 
-use alga::general::Real;
+use alga::general::RealField;
 
-use base::dimension::U3;
-use base::helper;
-use base::storage::Storage;
-use base::{Matrix4, Scalar, Vector, Vector3};
+use crate::base::dimension::U3;
+use crate::base::helper;
+use crate::base::storage::Storage;
+use crate::base::{Matrix4, Scalar, Vector, Vector3};
 
-use geometry::{Point3, Projective3};
+use crate::geometry::{Point3, Projective3};
 
 /// A 3D perspective projection stored as an homogeneous 4x4 matrix.
 pub struct Perspective3<N: Scalar> {
     matrix: Matrix4<N>,
 }
 
-impl<N: Real> Copy for Perspective3<N> {}
+impl<N: RealField> Copy for Perspective3<N> {}
 
-impl<N: Real> Clone for Perspective3<N> {
+impl<N: RealField> Clone for Perspective3<N> {
     #[inline]
     fn clone(&self) -> Self {
         Self::from_matrix_unchecked(self.matrix.clone())
     }
 }
 
-impl<N: Real> fmt::Debug for Perspective3<N> {
+impl<N: RealField> fmt::Debug for Perspective3<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         self.matrix.fmt(f)
     }
 }
 
-impl<N: Real> PartialEq for Perspective3<N> {
+impl<N: RealField> PartialEq for Perspective3<N> {
     #[inline]
     fn eq(&self, right: &Self) -> bool {
         self.matrix == right.matrix
@@ -45,7 +45,7 @@ impl<N: Real> PartialEq for Perspective3<N> {
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: Real + Serialize> Serialize for Perspective3<N> {
+impl<N: RealField + Serialize> Serialize for Perspective3<N> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where S: Serializer {
         self.matrix.serialize(serializer)
@@ -53,7 +53,7 @@ impl<N: Real + Serialize> Serialize for Perspective3<N> {
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: Real + Deserialize<'a>> Deserialize<'a> for Perspective3<N> {
+impl<'a, N: RealField + Deserialize<'a>> Deserialize<'a> for Perspective3<N> {
     fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
     where Des: Deserializer<'a> {
         let matrix = Matrix4::<N>::deserialize(deserializer)?;
@@ -62,7 +62,7 @@ impl<'a, N: Real + Deserialize<'a>> Deserialize<'a> for Perspective3<N> {
     }
 }
 
-impl<N: Real> Perspective3<N> {
+impl<N: RealField> Perspective3<N> {
     /// Creates a new perspective matrix from the aspect ratio, y field of view, and near/far planes.
     pub fn new(aspect: N, fovy: N, znear: N, zfar: N) -> Self {
         assert!(
@@ -162,7 +162,7 @@ impl<N: Real> Perspective3<N> {
     /// Gets the y field of view of the view frustum.
     #[inline]
     pub fn fovy(&self) -> N {
-        (N::one() / self.matrix[(1, 1)]).atan() * ::convert(2.0)
+        (N::one() / self.matrix[(1, 1)]).atan() * crate::convert(2.0)
     }
 
     /// Gets the near plane offset of the view frustum.
@@ -170,7 +170,7 @@ impl<N: Real> Perspective3<N> {
     pub fn znear(&self) -> N {
         let ratio = (-self.matrix[(2, 2)] + N::one()) / (-self.matrix[(2, 2)] - N::one());
 
-        self.matrix[(2, 3)] / (ratio * ::convert(2.0)) - self.matrix[(2, 3)] / ::convert(2.0)
+        self.matrix[(2, 3)] / (ratio * crate::convert(2.0)) - self.matrix[(2, 3)] / crate::convert(2.0)
     }
 
     /// Gets the far plane offset of the view frustum.
@@ -178,7 +178,7 @@ impl<N: Real> Perspective3<N> {
     pub fn zfar(&self) -> N {
         let ratio = (-self.matrix[(2, 2)] + N::one()) / (-self.matrix[(2, 2)] - N::one());
 
-        (self.matrix[(2, 3)] - ratio * self.matrix[(2, 3)]) / ::convert(2.0)
+        (self.matrix[(2, 3)] - ratio * self.matrix[(2, 3)]) / crate::convert(2.0)
     }
 
     // FIXME: add a method to retrieve znear and zfar simultaneously?
@@ -235,7 +235,7 @@ impl<N: Real> Perspective3<N> {
     #[inline]
     pub fn set_fovy(&mut self, fovy: N) {
         let old_m22 = self.matrix[(1, 1)];
-        self.matrix[(1, 1)] = N::one() / (fovy / ::convert(2.0)).tan();
+        self.matrix[(1, 1)] = N::one() / (fovy / crate::convert(2.0)).tan();
         self.matrix[(0, 0)] = self.matrix[(0, 0)] * (self.matrix[(1, 1)] / old_m22);
     }
 
@@ -257,11 +257,11 @@ impl<N: Real> Perspective3<N> {
     #[inline]
     pub fn set_znear_and_zfar(&mut self, znear: N, zfar: N) {
         self.matrix[(2, 2)] = (zfar + znear) / (znear - zfar);
-        self.matrix[(2, 3)] = zfar * znear * ::convert(2.0) / (znear - zfar);
+        self.matrix[(2, 3)] = zfar * znear * crate::convert(2.0) / (znear - zfar);
     }
 }
 
-impl<N: Real> Distribution<Perspective3<N>> for Standard
+impl<N: RealField> Distribution<Perspective3<N>> for Standard
 where Standard: Distribution<N>
 {
     fn sample<'a, R: Rng + ?Sized>(&self, r: &'a mut R) -> Perspective3<N> {
@@ -274,7 +274,7 @@ where Standard: Distribution<N>
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: Real + Arbitrary> Arbitrary for Perspective3<N> {
+impl<N: RealField + Arbitrary> Arbitrary for Perspective3<N> {
     fn arbitrary<G: Gen>(g: &mut G) -> Self {
         let znear = Arbitrary::arbitrary(g);
         let zfar = helper::reject(g, |&x: &N| !(x - znear).is_zero());
@@ -284,7 +284,7 @@ impl<N: Real + Arbitrary> Arbitrary for Perspective3<N> {
     }
 }
 
-impl<N: Real> From<Perspective3<N>> for Matrix4<N> {
+impl<N: RealField> From<Perspective3<N>> for Matrix4<N> {
     #[inline]
     fn from(orth: Perspective3<N>) -> Self {
         orth.into_inner()
diff --git a/src/geometry/point.rs b/src/geometry/point.rs
index 14ce7dc28..04338d2aa 100644
--- a/src/geometry/point.rs
+++ b/src/geometry/point.rs
@@ -12,10 +12,10 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use base::iter::{MatrixIter, MatrixIterMut};
-use base::{DefaultAllocator, Scalar, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::iter::{MatrixIter, MatrixIterMut};
+use crate::base::{DefaultAllocator, Scalar, VectorN};
 
 /// A point in a n-dimensional euclidean space.
 #[repr(C)]
@@ -316,14 +316,14 @@ impl<N: Scalar + fmt::Display, D: DimName> fmt::Display for Point<N, D>
 where DefaultAllocator: Allocator<N, D>
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, "{{"));
+        write!(f, "{{")?;
 
         let mut it = self.coords.iter();
 
-        try!(write!(f, "{}", *it.next().unwrap()));
+        write!(f, "{}", *it.next().unwrap())?;
 
         for comp in it {
-            try!(write!(f, ", {}", *comp));
+            write!(f, ", {}", *comp)?;
         }
 
         write!(f, "}}")
diff --git a/src/geometry/point_alga.rs b/src/geometry/point_alga.rs
index 2f81ceff8..162e6c68b 100644
--- a/src/geometry/point_alga.rs
+++ b/src/geometry/point_alga.rs
@@ -1,11 +1,11 @@
-use alga::general::{Field, JoinSemilattice, Lattice, MeetSemilattice, Real};
+use alga::general::{Field, JoinSemilattice, Lattice, MeetSemilattice, RealField};
 use alga::linear::{AffineSpace, EuclideanSpace};
 
-use base::allocator::Allocator;
-use base::dimension::DimName;
-use base::{DefaultAllocator, Scalar, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::DimName;
+use crate::base::{DefaultAllocator, Scalar, VectorN};
 
-use geometry::Point;
+use crate::geometry::Point;
 
 impl<N: Scalar + Field, D: DimName> AffineSpace for Point<N, D>
 where
@@ -15,11 +15,11 @@ where
     type Translation = VectorN<N, D>;
 }
 
-impl<N: Real, D: DimName> EuclideanSpace for Point<N, D>
+impl<N: RealField, D: DimName> EuclideanSpace for Point<N, D>
 where DefaultAllocator: Allocator<N, D>
 {
     type Coordinates = VectorN<N, D>;
-    type Real = N;
+    type RealField = N;
 
     #[inline]
     fn origin() -> Self {
diff --git a/src/geometry/point_alias.rs b/src/geometry/point_alias.rs
index 42086d043..83f57301b 100644
--- a/src/geometry/point_alias.rs
+++ b/src/geometry/point_alias.rs
@@ -1,6 +1,6 @@
-use base::dimension::{U1, U2, U3, U4, U5, U6};
+use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
 
-use geometry::Point;
+use crate::geometry::Point;
 
 /// A statically sized 1-dimensional column point.
 pub type Point1<N> = Point<N, U1>;
diff --git a/src/geometry/point_construction.rs b/src/geometry/point_construction.rs
index b6c46779f..2fac11d42 100644
--- a/src/geometry/point_construction.rs
+++ b/src/geometry/point_construction.rs
@@ -6,11 +6,11 @@ use rand::distributions::{Distribution, Standard};
 use rand::Rng;
 
 use alga::general::ClosedDiv;
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameAdd, DimNameSum, U1, U2, U3, U4, U5, U6};
-use base::{DefaultAllocator, Scalar, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1, U2, U3, U4, U5, U6};
+use crate::base::{DefaultAllocator, Scalar, VectorN};
 
-use geometry::Point;
+use crate::geometry::Point;
 
 impl<N: Scalar, D: DimName> Point<N, D>
 where DefaultAllocator: Allocator<N, D>
@@ -28,7 +28,7 @@ where DefaultAllocator: Allocator<N, D>
     /// ```
     /// # use nalgebra::{Point2, Point3};
     /// // This works in any dimension.
-    /// // The explicit ::<f32> type annotation may not always be needed,
+    /// // The explicit crate::<f32> type annotation may not always be needed,
     /// // depending on the context of type inference.
     /// let pt = Point2::<f32>::origin();
     /// assert!(pt.x == 0.0 && pt.y == 0.0);
diff --git a/src/geometry/point_conversion.rs b/src/geometry/point_conversion.rs
index 50a3a4d2e..104381650 100644
--- a/src/geometry/point_conversion.rs
+++ b/src/geometry/point_conversion.rs
@@ -1,15 +1,15 @@
 use alga::general::{ClosedDiv, SubsetOf, SupersetOf};
 use num::{One, Zero};
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use base::{DefaultAllocator, Matrix, Scalar, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::{DefaultAllocator, Matrix, Scalar, VectorN};
 
 #[cfg(feature = "mint")]
-use base::dimension::{U2, U3};
+use crate::base::dimension::{U2, U3};
 #[cfg(feature = "mint")]
-use base::storage::{Storage, StorageMut};
-use geometry::Point;
+use crate::base::storage::{Storage, StorageMut};
+use crate::geometry::Point;
 #[cfg(feature = "mint")]
 use mint;
 #[cfg(feature = "mint")]
@@ -67,14 +67,14 @@ where
 
     #[inline]
     fn is_in_subset(v: &VectorN<N2, DimNameSum<D, U1>>) -> bool {
-        ::is_convertible::<_, VectorN<N1, DimNameSum<D, U1>>>(v) && !v[D::dim()].is_zero()
+        crate::is_convertible::<_, VectorN<N1, DimNameSum<D, U1>>>(v) && !v[D::dim()].is_zero()
     }
 
     #[inline]
     unsafe fn from_superset_unchecked(v: &VectorN<N2, DimNameSum<D, U1>>) -> Self {
         let coords = v.fixed_slice::<D, U1>(0, 0) / v[D::dim()];
         Self {
-            coords: ::convert_unchecked(coords)
+            coords: crate::convert_unchecked(coords)
         }
     }
 }
diff --git a/src/geometry/point_coordinates.rs b/src/geometry/point_coordinates.rs
index b24ec052f..b56e120ed 100644
--- a/src/geometry/point_coordinates.rs
+++ b/src/geometry/point_coordinates.rs
@@ -1,12 +1,12 @@
 use std::mem;
 use std::ops::{Deref, DerefMut};
 
-use base::allocator::Allocator;
-use base::coordinates::{X, XY, XYZ, XYZW, XYZWA, XYZWAB};
-use base::dimension::{U1, U2, U3, U4, U5, U6};
-use base::{DefaultAllocator, Scalar};
+use crate::base::allocator::Allocator;
+use crate::base::coordinates::{X, XY, XYZ, XYZW, XYZWA, XYZWAB};
+use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
+use crate::base::{DefaultAllocator, Scalar};
 
-use geometry::Point;
+use crate::geometry::Point;
 
 /*
  *
diff --git a/src/geometry/point_ops.rs b/src/geometry/point_ops.rs
index 0a20bc90c..b49495f8b 100644
--- a/src/geometry/point_ops.rs
+++ b/src/geometry/point_ops.rs
@@ -5,13 +5,13 @@ use std::ops::{
 
 use alga::general::{ClosedAdd, ClosedDiv, ClosedMul, ClosedNeg, ClosedSub};
 
-use base::allocator::{Allocator, SameShapeAllocator};
-use base::constraint::{AreMultipliable, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
-use base::dimension::{Dim, DimName, U1};
-use base::storage::Storage;
-use base::{DefaultAllocator, Matrix, Scalar, Vector, VectorSum};
+use crate::base::allocator::{Allocator, SameShapeAllocator};
+use crate::base::constraint::{AreMultipliable, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
+use crate::base::dimension::{Dim, DimName, U1};
+use crate::base::storage::Storage;
+use crate::base::{DefaultAllocator, Matrix, Scalar, Vector, VectorSum};
 
-use geometry::Point;
+use crate::geometry::Point;
 
 /*
  *
diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs
index d691f48c4..2986dc12c 100755
--- a/src/geometry/quaternion.rs
+++ b/src/geometry/quaternion.rs
@@ -6,32 +6,32 @@ use std::hash;
 use std::io::{Result as IOResult, Write};
 
 #[cfg(feature = "serde-serialize")]
-use base::storage::Owned;
+use crate::base::storage::Owned;
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
-use alga::general::Real;
+use alga::general::RealField;
 
-use base::dimension::{U1, U3, U4};
-use base::storage::{CStride, RStride};
-use base::{Matrix3, Matrix4, MatrixSlice, MatrixSliceMut, Unit, Vector3, Vector4};
+use crate::base::dimension::{U1, U3, U4};
+use crate::base::storage::{CStride, RStride};
+use crate::base::{Matrix3, Matrix4, MatrixSlice, MatrixSliceMut, Unit, Vector3, Vector4};
 
-use geometry::{Point3, Rotation};
+use crate::geometry::{Point3, Rotation};
 
 /// A quaternion. See the type alias `UnitQuaternion = Unit<Quaternion>` for a quaternion
 /// that may be used as a rotation.
 #[repr(C)]
 #[derive(Debug)]
-pub struct Quaternion<N: Real> {
+pub struct Quaternion<N: RealField> {
     /// This quaternion as a 4D vector of coordinates in the `[ x, y, z, w ]` storage order.
     pub coords: Vector4<N>,
 }
 
 #[cfg(feature = "abomonation-serialize")]
-impl<N: Real> Abomonation for Quaternion<N>
+impl<N: RealField> Abomonation for Quaternion<N>
 where Vector4<N>: Abomonation
 {
     unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
@@ -47,9 +47,9 @@ where Vector4<N>: Abomonation
     }
 }
 
-impl<N: Real + Eq> Eq for Quaternion<N> {}
+impl<N: RealField + Eq> Eq for Quaternion<N> {}
 
-impl<N: Real> PartialEq for Quaternion<N> {
+impl<N: RealField> PartialEq for Quaternion<N> {
     fn eq(&self, rhs: &Self) -> bool {
         self.coords == rhs.coords ||
         // Account for the double-covering of S², i.e. q = -q
@@ -57,15 +57,15 @@ impl<N: Real> PartialEq for Quaternion<N> {
     }
 }
 
-impl<N: Real + hash::Hash> hash::Hash for Quaternion<N> {
+impl<N: RealField + hash::Hash> hash::Hash for Quaternion<N> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         self.coords.hash(state)
     }
 }
 
-impl<N: Real> Copy for Quaternion<N> {}
+impl<N: RealField> Copy for Quaternion<N> {}
 
-impl<N: Real> Clone for Quaternion<N> {
+impl<N: RealField> Clone for Quaternion<N> {
     #[inline]
     fn clone(&self) -> Self {
         Self::from(self.coords.clone())
@@ -73,7 +73,7 @@ impl<N: Real> Clone for Quaternion<N> {
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: Real> Serialize for Quaternion<N>
+impl<N: RealField> Serialize for Quaternion<N>
 where Owned<N, U4>: Serialize
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -83,7 +83,7 @@ where Owned<N, U4>: Serialize
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: Real> Deserialize<'a> for Quaternion<N>
+impl<'a, N: RealField> Deserialize<'a> for Quaternion<N>
 where Owned<N, U4>: Deserialize<'a>
 {
     fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
@@ -94,7 +94,7 @@ where Owned<N, U4>: Deserialize<'a>
     }
 }
 
-impl<N: Real> Quaternion<N> {
+impl<N: RealField> Quaternion<N> {
     /// Moves this unit quaternion into one that owns its data.
     #[inline]
     #[deprecated(note = "This method is a no-op and will be removed in a future release.")]
@@ -225,7 +225,7 @@ impl<N: Real> Quaternion<N> {
     /// # use nalgebra::{Vector4, Quaternion};
     /// let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
     /// // Recall that the quaternion is stored internally as (i, j, k, w)
-    /// // while the ::new constructor takes the arguments as (w, i, j, k).
+    /// // while the crate::new constructor takes the arguments as (w, i, j, k).
     /// assert_eq!(*q.as_vector(), Vector4::new(2.0, 3.0, 4.0, 1.0));
     /// ```
     #[inline]
@@ -400,7 +400,7 @@ impl<N: Real> Quaternion<N> {
     pub fn polar_decomposition(&self) -> (N, N, Option<Unit<Vector3<N>>>) {
         if let Some((q, n)) = Unit::try_new_and_get(*self, N::zero()) {
             if let Some(axis) = Unit::try_new(self.vector().clone_owned(), N::zero()) {
-                let angle = q.angle() / ::convert(2.0f64);
+                let angle = q.angle() / crate::convert(2.0f64);
 
                 (n, angle, Some(axis))
             } else {
@@ -591,13 +591,13 @@ impl<N: Real> Quaternion<N> {
     /// Divides quaternion into two.
     #[inline]
     pub fn half(&self) -> Self {
-        self / ::convert(2.0f64)
+        self / crate::convert(2.0f64)
     }
 
     /// Calculates square root.
     #[inline]
     pub fn sqrt(&self) -> Self {
-        self.powf(::convert(0.5))
+        self.powf(crate::convert(0.5))
     }
 
     /// Check if the quaternion is pure.
@@ -851,7 +851,7 @@ impl<N: Real> Quaternion<N> {
     }
 }
 
-impl<N: Real + AbsDiffEq<Epsilon = N>> AbsDiffEq for Quaternion<N> {
+impl<N: RealField + AbsDiffEq<Epsilon = N>> AbsDiffEq for Quaternion<N> {
     type Epsilon = N;
 
     #[inline]
@@ -867,7 +867,7 @@ impl<N: Real + AbsDiffEq<Epsilon = N>> AbsDiffEq for Quaternion<N> {
     }
 }
 
-impl<N: Real + RelativeEq<Epsilon = N>> RelativeEq for Quaternion<N> {
+impl<N: RealField + RelativeEq<Epsilon = N>> RelativeEq for Quaternion<N> {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
         N::default_max_relative()
@@ -887,7 +887,7 @@ impl<N: Real + RelativeEq<Epsilon = N>> RelativeEq for Quaternion<N> {
     }
 }
 
-impl<N: Real + UlpsEq<Epsilon = N>> UlpsEq for Quaternion<N> {
+impl<N: RealField + UlpsEq<Epsilon = N>> UlpsEq for Quaternion<N> {
     #[inline]
     fn default_max_ulps() -> u32 {
         N::default_max_ulps()
@@ -901,7 +901,7 @@ impl<N: Real + UlpsEq<Epsilon = N>> UlpsEq for Quaternion<N> {
     }
 }
 
-impl<N: Real + fmt::Display> fmt::Display for Quaternion<N> {
+impl<N: RealField + fmt::Display> fmt::Display for Quaternion<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
@@ -914,7 +914,7 @@ impl<N: Real + fmt::Display> fmt::Display for Quaternion<N> {
 /// A unit quaternions. May be used to represent a rotation.
 pub type UnitQuaternion<N> = Unit<Quaternion<N>>;
 
-impl<N: Real> UnitQuaternion<N> {
+impl<N: RealField> UnitQuaternion<N> {
     /// Moves this unit quaternion into one that owns its data.
     #[inline]
     #[deprecated(
@@ -950,7 +950,7 @@ impl<N: Real> UnitQuaternion<N> {
         if w >= N::one() {
             N::zero()
         } else {
-            w.acos() * ::convert(2.0f64)
+            w.acos() * crate::convert(2.0f64)
         }
     }
 
@@ -1276,12 +1276,12 @@ impl<N: Real> UnitQuaternion<N> {
         let ii = i * i;
         let jj = j * j;
         let kk = k * k;
-        let ij = i * j * ::convert(2.0f64);
-        let wk = w * k * ::convert(2.0f64);
-        let wj = w * j * ::convert(2.0f64);
-        let ik = i * k * ::convert(2.0f64);
-        let jk = j * k * ::convert(2.0f64);
-        let wi = w * i * ::convert(2.0f64);
+        let ij = i * j * crate::convert(2.0f64);
+        let wk = w * k * crate::convert(2.0f64);
+        let wj = w * j * crate::convert(2.0f64);
+        let ik = i * k * crate::convert(2.0f64);
+        let jk = j * k * crate::convert(2.0f64);
+        let wi = w * i * crate::convert(2.0f64);
 
         Rotation::from_matrix_unchecked(Matrix3::new(
             ww + ii - jj - kk,
@@ -1428,7 +1428,7 @@ impl<N: Real> UnitQuaternion<N> {
     }
 }
 
-impl<N: Real + fmt::Display> fmt::Display for UnitQuaternion<N> {
+impl<N: RealField + fmt::Display> fmt::Display for UnitQuaternion<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(axis) = self.axis() {
             let axis = axis.into_inner();
@@ -1450,7 +1450,7 @@ impl<N: Real + fmt::Display> fmt::Display for UnitQuaternion<N> {
     }
 }
 
-impl<N: Real + AbsDiffEq<Epsilon = N>> AbsDiffEq for UnitQuaternion<N> {
+impl<N: RealField + AbsDiffEq<Epsilon = N>> AbsDiffEq for UnitQuaternion<N> {
     type Epsilon = N;
 
     #[inline]
@@ -1464,7 +1464,7 @@ impl<N: Real + AbsDiffEq<Epsilon = N>> AbsDiffEq for UnitQuaternion<N> {
     }
 }
 
-impl<N: Real + RelativeEq<Epsilon = N>> RelativeEq for UnitQuaternion<N> {
+impl<N: RealField + RelativeEq<Epsilon = N>> RelativeEq for UnitQuaternion<N> {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
         N::default_max_relative()
@@ -1483,7 +1483,7 @@ impl<N: Real + RelativeEq<Epsilon = N>> RelativeEq for UnitQuaternion<N> {
     }
 }
 
-impl<N: Real + UlpsEq<Epsilon = N>> UlpsEq for UnitQuaternion<N> {
+impl<N: RealField + UlpsEq<Epsilon = N>> UlpsEq for UnitQuaternion<N> {
     #[inline]
     fn default_max_ulps() -> u32 {
         N::default_max_ulps()
@@ -1494,4 +1494,3 @@ impl<N: Real + UlpsEq<Epsilon = N>> UlpsEq for UnitQuaternion<N> {
         self.as_ref().ulps_eq(other.as_ref(), epsilon, max_ulps)
     }
 }
-
diff --git a/src/geometry/quaternion_alga.rs b/src/geometry/quaternion_alga.rs
index d931b2068..86eeedb11 100755
--- a/src/geometry/quaternion_alga.rs
+++ b/src/geometry/quaternion_alga.rs
@@ -3,7 +3,7 @@ use num::Zero;
 use alga::general::{
     AbstractGroup, AbstractGroupAbelian, AbstractLoop, AbstractMagma, AbstractModule,
     AbstractMonoid, AbstractQuasigroup, AbstractSemigroup, Additive, Id, Identity, TwoSidedInverse, Module,
-    Multiplicative, Real,
+    Multiplicative, RealField,
 };
 use alga::linear::{
     AffineTransformation, DirectIsometry, FiniteDimVectorSpace, Isometry, NormedSpace,
@@ -11,38 +11,38 @@ use alga::linear::{
     VectorSpace,
 };
 
-use base::{Vector3, Vector4};
-use geometry::{Point3, Quaternion, UnitQuaternion};
+use crate::base::{Vector3, Vector4};
+use crate::geometry::{Point3, Quaternion, UnitQuaternion};
 
-impl<N: Real> Identity<Multiplicative> for Quaternion<N> {
+impl<N: RealField> Identity<Multiplicative> for Quaternion<N> {
     #[inline]
     fn identity() -> Self {
         Self::identity()
     }
 }
 
-impl<N: Real> Identity<Additive> for Quaternion<N> {
+impl<N: RealField> Identity<Additive> for Quaternion<N> {
     #[inline]
     fn identity() -> Self {
         Self::zero()
     }
 }
 
-impl<N: Real> AbstractMagma<Multiplicative> for Quaternion<N> {
+impl<N: RealField> AbstractMagma<Multiplicative> for Quaternion<N> {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
         self * rhs
     }
 }
 
-impl<N: Real> AbstractMagma<Additive> for Quaternion<N> {
+impl<N: RealField> AbstractMagma<Additive> for Quaternion<N> {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
         self + rhs
     }
 }
 
-impl<N: Real> TwoSidedInverse<Additive> for Quaternion<N> {
+impl<N: RealField> TwoSidedInverse<Additive> for Quaternion<N> {
     #[inline]
     fn two_sided_inverse(&self) -> Self {
         -self
@@ -51,7 +51,7 @@ impl<N: Real> TwoSidedInverse<Additive> for Quaternion<N> {
 
 macro_rules! impl_structures(
     ($Quaternion: ident; $($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: Real> $marker<$operator> for $Quaternion<N> { }
+        impl<N: RealField> $marker<$operator> for $Quaternion<N> { }
     )*}
 );
 
@@ -73,7 +73,7 @@ impl_structures!(
  * Vector space.
  *
  */
-impl<N: Real> AbstractModule for Quaternion<N> {
+impl<N: RealField> AbstractModule for Quaternion<N> {
     type AbstractRing = N;
 
     #[inline]
@@ -82,15 +82,15 @@ impl<N: Real> AbstractModule for Quaternion<N> {
     }
 }
 
-impl<N: Real> Module for Quaternion<N> {
+impl<N: RealField> Module for Quaternion<N> {
     type Ring = N;
 }
 
-impl<N: Real> VectorSpace for Quaternion<N> {
+impl<N: RealField> VectorSpace for Quaternion<N> {
     type Field = N;
 }
 
-impl<N: Real> FiniteDimVectorSpace for Quaternion<N> {
+impl<N: RealField> FiniteDimVectorSpace for Quaternion<N> {
     #[inline]
     fn dimension() -> usize {
         4
@@ -117,7 +117,10 @@ impl<N: Real> FiniteDimVectorSpace for Quaternion<N> {
     }
 }
 
-impl<N: Real> NormedSpace for Quaternion<N> {
+impl<N: RealField> NormedSpace for Quaternion<N> {
+    type RealField = N;
+    type ComplexField = N;
+
     #[inline]
     fn norm_squared(&self) -> N {
         self.coords.norm_squared()
@@ -159,21 +162,21 @@ impl<N: Real> NormedSpace for Quaternion<N> {
  * Implementations for UnitQuaternion.
  *
  */
-impl<N: Real> Identity<Multiplicative> for UnitQuaternion<N> {
+impl<N: RealField> Identity<Multiplicative> for UnitQuaternion<N> {
     #[inline]
     fn identity() -> Self {
         Self::identity()
     }
 }
 
-impl<N: Real> AbstractMagma<Multiplicative> for UnitQuaternion<N> {
+impl<N: RealField> AbstractMagma<Multiplicative> for UnitQuaternion<N> {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
         self * rhs
     }
 }
 
-impl<N: Real> TwoSidedInverse<Multiplicative> for UnitQuaternion<N> {
+impl<N: RealField> TwoSidedInverse<Multiplicative> for UnitQuaternion<N> {
     #[inline]
     fn two_sided_inverse(&self) -> Self {
         self.inverse()
@@ -194,7 +197,7 @@ impl_structures!(
     AbstractGroup<Multiplicative>
 );
 
-impl<N: Real> Transformation<Point3<N>> for UnitQuaternion<N> {
+impl<N: RealField> Transformation<Point3<N>> for UnitQuaternion<N> {
     #[inline]
     fn transform_point(&self, pt: &Point3<N>) -> Point3<N> {
         self.transform_point(pt)
@@ -206,7 +209,7 @@ impl<N: Real> Transformation<Point3<N>> for UnitQuaternion<N> {
     }
 }
 
-impl<N: Real> ProjectiveTransformation<Point3<N>> for UnitQuaternion<N> {
+impl<N: RealField> ProjectiveTransformation<Point3<N>> for UnitQuaternion<N> {
     #[inline]
     fn inverse_transform_point(&self, pt: &Point3<N>) -> Point3<N> {
         self.inverse_transform_point(pt)
@@ -218,7 +221,7 @@ impl<N: Real> ProjectiveTransformation<Point3<N>> for UnitQuaternion<N> {
     }
 }
 
-impl<N: Real> AffineTransformation<Point3<N>> for UnitQuaternion<N> {
+impl<N: RealField> AffineTransformation<Point3<N>> for UnitQuaternion<N> {
     type Rotation = Self;
     type NonUniformScaling = Id;
     type Translation = Id;
@@ -259,7 +262,7 @@ impl<N: Real> AffineTransformation<Point3<N>> for UnitQuaternion<N> {
     }
 }
 
-impl<N: Real> Similarity<Point3<N>> for UnitQuaternion<N> {
+impl<N: RealField> Similarity<Point3<N>> for UnitQuaternion<N> {
     type Scaling = Id;
 
     #[inline]
@@ -280,13 +283,13 @@ impl<N: Real> Similarity<Point3<N>> for UnitQuaternion<N> {
 
 macro_rules! marker_impl(
     ($($Trait: ident),*) => {$(
-        impl<N: Real> $Trait<Point3<N>> for UnitQuaternion<N> { }
+        impl<N: RealField> $Trait<Point3<N>> for UnitQuaternion<N> { }
     )*}
 );
 
 marker_impl!(Isometry, DirectIsometry, OrthogonalTransformation);
 
-impl<N: Real> Rotation<Point3<N>> for UnitQuaternion<N> {
+impl<N: RealField> Rotation<Point3<N>> for UnitQuaternion<N> {
     #[inline]
     fn powf(&self, n: N) -> Option<Self> {
         Some(self.powf(n))
diff --git a/src/geometry/quaternion_construction.rs b/src/geometry/quaternion_construction.rs
index 4b7976bdf..7758b4c96 100644
--- a/src/geometry/quaternion_construction.rs
+++ b/src/geometry/quaternion_construction.rs
@@ -1,7 +1,7 @@
 #[cfg(feature = "arbitrary")]
-use base::dimension::U4;
+use crate::base::dimension::U4;
 #[cfg(feature = "arbitrary")]
-use base::storage::Owned;
+use crate::base::storage::Owned;
 #[cfg(feature = "arbitrary")]
 use quickcheck::{Arbitrary, Gen};
 
@@ -9,15 +9,15 @@ use num::{One, Zero};
 use rand::distributions::{Distribution, OpenClosed01, Standard};
 use rand::Rng;
 
-use alga::general::Real;
+use alga::general::RealField;
 
-use base::dimension::U3;
-use base::storage::Storage;
-use base::{Unit, Vector, Vector3, Vector4, Matrix3};
+use crate::base::dimension::U3;
+use crate::base::storage::Storage;
+use crate::base::{Unit, Vector, Vector3, Vector4, Matrix3};
 
-use geometry::{Quaternion, Rotation3, UnitQuaternion};
+use crate::geometry::{Quaternion, Rotation3, UnitQuaternion};
 
-impl<N: Real> Quaternion<N> {
+impl<N: RealField> Quaternion<N> {
     /// Creates a quaternion from a 4D vector. The quaternion scalar part corresponds to the `w`
     /// vector component.
     #[inline]
@@ -83,7 +83,7 @@ impl<N: Real> Quaternion<N> {
     // FIXME: take a reference to `axis`?
     pub fn from_polar_decomposition<SB>(scale: N, theta: N, axis: Unit<Vector<N, U3, SB>>) -> Self
     where SB: Storage<N, U3> {
-        let rot = UnitQuaternion::<N>::from_axis_angle(&axis, theta * ::convert(2.0f64));
+        let rot = UnitQuaternion::<N>::from_axis_angle(&axis, theta * crate::convert(2.0f64));
 
         rot.into_inner() * scale
     }
@@ -105,14 +105,14 @@ impl<N: Real> Quaternion<N> {
     }
 }
 
-impl<N: Real> One for Quaternion<N> {
+impl<N: RealField> One for Quaternion<N> {
     #[inline]
     fn one() -> Self {
         Self::identity()
     }
 }
 
-impl<N: Real> Zero for Quaternion<N> {
+impl<N: RealField> Zero for Quaternion<N> {
     #[inline]
     fn zero() -> Self {
         Self::from(Vector4::zero())
@@ -124,7 +124,7 @@ impl<N: Real> Zero for Quaternion<N> {
     }
 }
 
-impl<N: Real> Distribution<Quaternion<N>> for Standard
+impl<N: RealField> Distribution<Quaternion<N>> for Standard
 where Standard: Distribution<N>
 {
     #[inline]
@@ -134,7 +134,7 @@ where Standard: Distribution<N>
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: Real + Arbitrary> Arbitrary for Quaternion<N>
+impl<N: RealField + Arbitrary> Arbitrary for Quaternion<N>
 where Owned<N, U4>: Send
 {
     #[inline]
@@ -148,7 +148,7 @@ where Owned<N, U4>: Send
     }
 }
 
-impl<N: Real> UnitQuaternion<N> {
+impl<N: RealField> UnitQuaternion<N> {
     /// The rotation identity.
     ///
     /// # Example
@@ -195,7 +195,7 @@ impl<N: Real> UnitQuaternion<N> {
     #[inline]
     pub fn from_axis_angle<SB>(axis: &Unit<Vector<N, U3, SB>>, angle: N) -> Self
     where SB: Storage<N, U3> {
-        let (sang, cang) = (angle / ::convert(2.0f64)).sin_cos();
+        let (sang, cang) = (angle / crate::convert(2.0f64)).sin_cos();
 
         let q = Quaternion::from_parts(cang, axis.as_ref() * sang);
         Self::new_unchecked(q)
@@ -225,9 +225,9 @@ impl<N: Real> UnitQuaternion<N> {
     /// ```
     #[inline]
     pub fn from_euler_angles(roll: N, pitch: N, yaw: N) -> Self {
-        let (sr, cr) = (roll * ::convert(0.5f64)).sin_cos();
-        let (sp, cp) = (pitch * ::convert(0.5f64)).sin_cos();
-        let (sy, cy) = (yaw * ::convert(0.5f64)).sin_cos();
+        let (sr, cr) = (roll * crate::convert(0.5f64)).sin_cos();
+        let (sp, cp) = (pitch * crate::convert(0.5f64)).sin_cos();
+        let (sy, cy) = (yaw * crate::convert(0.5f64)).sin_cos();
 
         let q = Quaternion::new(
             cr * cp * cy + sr * sp * sy,
@@ -260,10 +260,10 @@ impl<N: Real> UnitQuaternion<N> {
         let tr = rotmat[(0, 0)] + rotmat[(1, 1)] + rotmat[(2, 2)];
         let res;
 
-        let _0_25: N = ::convert(0.25);
+        let _0_25: N = crate::convert(0.25);
 
         if tr > N::zero() {
-            let denom = (tr + N::one()).sqrt() * ::convert(2.0);
+            let denom = (tr + N::one()).sqrt() * crate::convert(2.0);
             res = Quaternion::new(
                 _0_25 * denom,
                 (rotmat[(2, 1)] - rotmat[(1, 2)]) / denom,
@@ -272,7 +272,7 @@ impl<N: Real> UnitQuaternion<N> {
             );
         } else if rotmat[(0, 0)] > rotmat[(1, 1)] && rotmat[(0, 0)] > rotmat[(2, 2)] {
             let denom = (N::one() + rotmat[(0, 0)] - rotmat[(1, 1)] - rotmat[(2, 2)]).sqrt()
-                * ::convert(2.0);
+                * crate::convert(2.0);
             res = Quaternion::new(
                 (rotmat[(2, 1)] - rotmat[(1, 2)]) / denom,
                 _0_25 * denom,
@@ -281,7 +281,7 @@ impl<N: Real> UnitQuaternion<N> {
             );
         } else if rotmat[(1, 1)] > rotmat[(2, 2)] {
             let denom = (N::one() + rotmat[(1, 1)] - rotmat[(0, 0)] - rotmat[(2, 2)]).sqrt()
-                * ::convert(2.0);
+                * crate::convert(2.0);
             res = Quaternion::new(
                 (rotmat[(0, 2)] - rotmat[(2, 0)]) / denom,
                 (rotmat[(0, 1)] + rotmat[(1, 0)]) / denom,
@@ -290,7 +290,7 @@ impl<N: Real> UnitQuaternion<N> {
             );
         } else {
             let denom = (N::one() + rotmat[(2, 2)] - rotmat[(0, 0)] - rotmat[(1, 1)]).sqrt()
-                * ::convert(2.0);
+                * crate::convert(2.0);
             res = Quaternion::new(
                 (rotmat[(1, 0)] - rotmat[(0, 1)]) / denom,
                 (rotmat[(0, 2)] + rotmat[(2, 0)]) / denom,
@@ -587,7 +587,7 @@ impl<N: Real> UnitQuaternion<N> {
     #[inline]
     pub fn new<SB>(axisangle: Vector<N, U3, SB>) -> Self
     where SB: Storage<N, U3> {
-        let two: N = ::convert(2.0f64);
+        let two: N = crate::convert(2.0f64);
         let q = Quaternion::<N>::from_imag(axisangle / two).exp();
         Self::new_unchecked(q)
     }
@@ -616,7 +616,7 @@ impl<N: Real> UnitQuaternion<N> {
     #[inline]
     pub fn new_eps<SB>(axisangle: Vector<N, U3, SB>, eps: N) -> Self
     where SB: Storage<N, U3> {
-        let two: N = ::convert(2.0f64);
+        let two: N = crate::convert(2.0f64);
         let q = Quaternion::<N>::from_imag(axisangle / two).exp_eps(eps);
         Self::new_unchecked(q)
     }
@@ -678,14 +678,14 @@ impl<N: Real> UnitQuaternion<N> {
     }
 }
 
-impl<N: Real> One for UnitQuaternion<N> {
+impl<N: RealField> One for UnitQuaternion<N> {
     #[inline]
     fn one() -> Self {
         Self::identity()
     }
 }
 
-impl<N: Real> Distribution<UnitQuaternion<N>> for Standard
+impl<N: RealField> Distribution<UnitQuaternion<N>> for Standard
 where OpenClosed01: Distribution<N>
 {
     /// Generate a uniformly distributed random rotation quaternion.
@@ -710,7 +710,7 @@ where OpenClosed01: Distribution<N>
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: Real + Arbitrary> Arbitrary for UnitQuaternion<N>
+impl<N: RealField + Arbitrary> Arbitrary for UnitQuaternion<N>
 where
     Owned<N, U4>: Send,
     Owned<N, U3>: Send,
diff --git a/src/geometry/quaternion_conversion.rs b/src/geometry/quaternion_conversion.rs
index a0b44390b..4ac8b5a75 100644
--- a/src/geometry/quaternion_conversion.rs
+++ b/src/geometry/quaternion_conversion.rs
@@ -1,14 +1,14 @@
 use num::Zero;
 
-use alga::general::{Real, SubsetOf, SupersetOf};
+use alga::general::{RealField, SubsetOf, SupersetOf};
 use alga::linear::Rotation as AlgaRotation;
 
 #[cfg(feature = "mint")]
 use mint;
 
-use base::dimension::U3;
-use base::{Matrix3, Matrix4, Vector4};
-use geometry::{
+use crate::base::dimension::U3;
+use crate::base::{Matrix3, Matrix4, Vector4};
+use crate::geometry::{
     Isometry, Point3, Quaternion, Rotation, Rotation3, Similarity, SuperTCategoryOf, TAffine,
     Transform, Translation, UnitQuaternion,
 };
@@ -34,8 +34,8 @@ use geometry::{
 
 impl<N1, N2> SubsetOf<Quaternion<N2>> for Quaternion<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
 {
     #[inline]
     fn to_superset(&self) -> Quaternion<N2> {
@@ -44,7 +44,7 @@ where
 
     #[inline]
     fn is_in_subset(q: &Quaternion<N2>) -> bool {
-        ::is_convertible::<_, Vector4<N1>>(&q.coords)
+        crate::is_convertible::<_, Vector4<N1>>(&q.coords)
     }
 
     #[inline]
@@ -57,8 +57,8 @@ where
 
 impl<N1, N2> SubsetOf<UnitQuaternion<N2>> for UnitQuaternion<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
 {
     #[inline]
     fn to_superset(&self) -> UnitQuaternion<N2> {
@@ -67,19 +67,19 @@ where
 
     #[inline]
     fn is_in_subset(uq: &UnitQuaternion<N2>) -> bool {
-        ::is_convertible::<_, Quaternion<N1>>(uq.as_ref())
+        crate::is_convertible::<_, Quaternion<N1>>(uq.as_ref())
     }
 
     #[inline]
     unsafe fn from_superset_unchecked(uq: &UnitQuaternion<N2>) -> Self {
-        Self::new_unchecked(::convert_ref_unchecked(uq.as_ref()))
+        Self::new_unchecked(crate::convert_ref_unchecked(uq.as_ref()))
     }
 }
 
 impl<N1, N2> SubsetOf<Rotation<N2, U3>> for UnitQuaternion<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
 {
     #[inline]
     fn to_superset(&self) -> Rotation3<N2> {
@@ -89,25 +89,25 @@ where
 
     #[inline]
     fn is_in_subset(rot: &Rotation3<N2>) -> bool {
-        ::is_convertible::<_, Rotation3<N1>>(rot)
+        crate::is_convertible::<_, Rotation3<N1>>(rot)
     }
 
     #[inline]
     unsafe fn from_superset_unchecked(rot: &Rotation3<N2>) -> Self {
         let q = UnitQuaternion::<N2>::from_rotation_matrix(rot);
-        ::convert_unchecked(q)
+        crate::convert_unchecked(q)
     }
 }
 
 impl<N1, N2, R> SubsetOf<Isometry<N2, U3, R>> for UnitQuaternion<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R: AlgaRotation<Point3<N2>> + SupersetOf<Self>,
 {
     #[inline]
     fn to_superset(&self) -> Isometry<N2, U3, R> {
-        Isometry::from_parts(Translation::identity(), ::convert_ref(self))
+        Isometry::from_parts(Translation::identity(), crate::convert_ref(self))
     }
 
     #[inline]
@@ -117,19 +117,19 @@ where
 
     #[inline]
     unsafe fn from_superset_unchecked(iso: &Isometry<N2, U3, R>) -> Self {
-        ::convert_ref_unchecked(&iso.rotation)
+        crate::convert_ref_unchecked(&iso.rotation)
     }
 }
 
 impl<N1, N2, R> SubsetOf<Similarity<N2, U3, R>> for UnitQuaternion<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R: AlgaRotation<Point3<N2>> + SupersetOf<Self>,
 {
     #[inline]
     fn to_superset(&self) -> Similarity<N2, U3, R> {
-        Similarity::from_isometry(::convert_ref(self), N2::one())
+        Similarity::from_isometry(crate::convert_ref(self), N2::one())
     }
 
     #[inline]
@@ -139,14 +139,14 @@ where
 
     #[inline]
     unsafe fn from_superset_unchecked(sim: &Similarity<N2, U3, R>) -> Self {
-        ::convert_ref_unchecked(&sim.isometry)
+        crate::convert_ref_unchecked(&sim.isometry)
     }
 }
 
 impl<N1, N2, C> SubsetOf<Transform<N2, U3, C>> for UnitQuaternion<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     C: SuperTCategoryOf<TAffine>,
 {
     #[inline]
@@ -165,7 +165,7 @@ where
     }
 }
 
-impl<N1: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix4<N2>> for UnitQuaternion<N1> {
+impl<N1: RealField, N2: RealField + SupersetOf<N1>> SubsetOf<Matrix4<N2>> for UnitQuaternion<N1> {
     #[inline]
     fn to_superset(&self) -> Matrix4<N2> {
         self.to_homogeneous().to_superset()
@@ -173,25 +173,25 @@ impl<N1: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix4<N2>> for UnitQuaterni
 
     #[inline]
     fn is_in_subset(m: &Matrix4<N2>) -> bool {
-        ::is_convertible::<_, Rotation3<N1>>(m)
+        crate::is_convertible::<_, Rotation3<N1>>(m)
     }
 
     #[inline]
     unsafe fn from_superset_unchecked(m: &Matrix4<N2>) -> Self {
-        let rot: Rotation3<N1> = ::convert_ref_unchecked(m);
+        let rot: Rotation3<N1> = crate::convert_ref_unchecked(m);
         Self::from_rotation_matrix(&rot)
     }
 }
 
 #[cfg(feature = "mint")]
-impl<N: Real> From<mint::Quaternion<N>> for Quaternion<N> {
+impl<N: RealField> From<mint::Quaternion<N>> for Quaternion<N> {
     fn from(q: mint::Quaternion<N>) -> Self {
         Self::new(q.s, q.v.x, q.v.y, q.v.z)
     }
 }
 
 #[cfg(feature = "mint")]
-impl<N: Real> Into<mint::Quaternion<N>> for Quaternion<N> {
+impl<N: RealField> Into<mint::Quaternion<N>> for Quaternion<N> {
     fn into(self) -> mint::Quaternion<N> {
         mint::Quaternion {
             v: mint::Vector3 {
@@ -205,7 +205,7 @@ impl<N: Real> Into<mint::Quaternion<N>> for Quaternion<N> {
 }
 
 #[cfg(feature = "mint")]
-impl<N: Real> Into<mint::Quaternion<N>> for UnitQuaternion<N> {
+impl<N: RealField> Into<mint::Quaternion<N>> for UnitQuaternion<N> {
     fn into(self) -> mint::Quaternion<N> {
         mint::Quaternion {
             v: mint::Vector3 {
@@ -218,35 +218,35 @@ impl<N: Real> Into<mint::Quaternion<N>> for UnitQuaternion<N> {
     }
 }
 
-impl<N: Real> From<UnitQuaternion<N>> for Matrix4<N> {
+impl<N: RealField> From<UnitQuaternion<N>> for Matrix4<N> {
     #[inline]
     fn from(q: UnitQuaternion<N>) -> Self {
         q.to_homogeneous()
     }
 }
 
-impl<N: Real> From<UnitQuaternion<N>> for Rotation3<N> {
+impl<N: RealField> From<UnitQuaternion<N>> for Rotation3<N> {
     #[inline]
     fn from(q: UnitQuaternion<N>) -> Self {
         q.to_rotation_matrix()
     }
 }
 
-impl<N: Real> From<Rotation3<N>> for UnitQuaternion<N> {
+impl<N: RealField> From<Rotation3<N>> for UnitQuaternion<N> {
     #[inline]
     fn from(q: Rotation3<N>) -> Self {
         Self::from_rotation_matrix(&q)
     }
 }
 
-impl<N: Real> From<UnitQuaternion<N>> for Matrix3<N> {
+impl<N: RealField> From<UnitQuaternion<N>> for Matrix3<N> {
     #[inline]
     fn from(q: UnitQuaternion<N>) -> Self {
         q.to_rotation_matrix().into_inner()
     }
 }
 
-impl<N: Real> From<Vector4<N>> for Quaternion<N> {
+impl<N: RealField> From<Vector4<N>> for Quaternion<N> {
     #[inline]
     fn from(coords: Vector4<N>) -> Self {
         Self { coords }
diff --git a/src/geometry/quaternion_coordinates.rs b/src/geometry/quaternion_coordinates.rs
index 228f74bfb..a9399f18b 100644
--- a/src/geometry/quaternion_coordinates.rs
+++ b/src/geometry/quaternion_coordinates.rs
@@ -1,13 +1,13 @@
 use std::mem;
 use std::ops::{Deref, DerefMut};
 
-use alga::general::Real;
+use alga::general::RealField;
 
-use base::coordinates::IJKW;
+use crate::base::coordinates::IJKW;
 
-use geometry::Quaternion;
+use crate::geometry::Quaternion;
 
-impl<N: Real> Deref for Quaternion<N> {
+impl<N: RealField> Deref for Quaternion<N> {
     type Target = IJKW<N>;
 
     #[inline]
@@ -16,7 +16,7 @@ impl<N: Real> Deref for Quaternion<N> {
     }
 }
 
-impl<N: Real> DerefMut for Quaternion<N> {
+impl<N: RealField> DerefMut for Quaternion<N> {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { mem::transmute(self) }
diff --git a/src/geometry/quaternion_ops.rs b/src/geometry/quaternion_ops.rs
index d43f104fe..7f2b274aa 100644
--- a/src/geometry/quaternion_ops.rs
+++ b/src/geometry/quaternion_ops.rs
@@ -54,16 +54,16 @@ use std::ops::{
     Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign,
 };
 
-use alga::general::Real;
+use alga::general::RealField;
 
-use base::allocator::Allocator;
-use base::dimension::{U1, U3, U4};
-use base::storage::Storage;
-use base::{DefaultAllocator, Unit, Vector, Vector3};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{U1, U3, U4};
+use crate::base::storage::Storage;
+use crate::base::{DefaultAllocator, Unit, Vector, Vector3};
 
-use geometry::{Point3, Quaternion, Rotation, UnitQuaternion};
+use crate::geometry::{Point3, Quaternion, Rotation, UnitQuaternion};
 
-impl<N: Real> Index<usize> for Quaternion<N> {
+impl<N: RealField> Index<usize> for Quaternion<N> {
     type Output = N;
 
     #[inline]
@@ -72,7 +72,7 @@ impl<N: Real> Index<usize> for Quaternion<N> {
     }
 }
 
-impl<N: Real> IndexMut<usize> for Quaternion<N> {
+impl<N: RealField> IndexMut<usize> for Quaternion<N> {
     #[inline]
     fn index_mut(&mut self, i: usize) -> &mut N {
         &mut self.coords[i]
@@ -85,7 +85,7 @@ macro_rules! quaternion_op_impl(
      $(for $Storage: ident: $StoragesBound: ident $(<$($BoundParam: ty),*>)*),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Result: ty $(=> $VDimA: ty, $VDimB: ty)*;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: Real $(, $Storage: $StoragesBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
+        impl<$($lives ,)* N: RealField $(, $Storage: $StoragesBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
             where DefaultAllocator: Allocator<N, $LhsRDim, $LhsCDim> +
                                     Allocator<N, $RhsRDim, $RhsCDim> {
             type Output = $Result;
@@ -390,7 +390,7 @@ quaternion_op_impl!(
     self: &'a UnitQuaternion<N>, rhs: &'b Vector<N, U3, SB>,
     Output = Vector3<N> => U3, U4;
     {
-        let two: N = ::convert(2.0f64);
+        let two: N = crate::convert(2.0f64);
         let t = self.as_ref().vector().cross(rhs) * two;
         let cross = self.as_ref().vector().cross(&t);
 
@@ -490,7 +490,7 @@ quaternion_op_impl!(
 
 macro_rules! scalar_op_impl(
     ($($Op: ident, $op: ident, $OpAssign: ident, $op_assign: ident);* $(;)*) => {$(
-        impl<N: Real> $Op<N> for Quaternion<N> {
+        impl<N: RealField> $Op<N> for Quaternion<N> {
             type Output = Quaternion<N>;
 
             #[inline]
@@ -499,7 +499,7 @@ macro_rules! scalar_op_impl(
             }
         }
 
-        impl<'a, N: Real> $Op<N> for &'a Quaternion<N> {
+        impl<'a, N: RealField> $Op<N> for &'a Quaternion<N> {
             type Output = Quaternion<N>;
 
             #[inline]
@@ -508,7 +508,7 @@ macro_rules! scalar_op_impl(
             }
         }
 
-        impl<N: Real> $OpAssign<N> for Quaternion<N> {
+        impl<N: RealField> $OpAssign<N> for Quaternion<N> {
 
             #[inline]
             fn $op_assign(&mut self, n: N) {
@@ -547,7 +547,7 @@ macro_rules! left_scalar_mul_impl(
 
 left_scalar_mul_impl!(f32, f64);
 
-impl<N: Real> Neg for Quaternion<N> {
+impl<N: RealField> Neg for Quaternion<N> {
     type Output = Quaternion<N>;
 
     #[inline]
@@ -556,7 +556,7 @@ impl<N: Real> Neg for Quaternion<N> {
     }
 }
 
-impl<'a, N: Real> Neg for &'a Quaternion<N> {
+impl<'a, N: RealField> Neg for &'a Quaternion<N> {
     type Output = Quaternion<N>;
 
     #[inline]
@@ -570,7 +570,7 @@ macro_rules! quaternion_op_impl(
      ($LhsRDim: ident, $LhsCDim: ident), ($RhsRDim: ident, $RhsCDim: ident);
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty $(=> $VDimA: ty, $VDimB: ty)*;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: Real> $OpAssign<$Rhs> for $Lhs
+        impl<$($lives ,)* N: RealField> $OpAssign<$Rhs> for $Lhs
             where DefaultAllocator: Allocator<N, $LhsRDim, $LhsCDim> +
                                     Allocator<N, $RhsRDim, $RhsCDim> {
 
diff --git a/src/geometry/reflection.rs b/src/geometry/reflection.rs
index 6b668c6f9..b4658a11f 100644
--- a/src/geometry/reflection.rs
+++ b/src/geometry/reflection.rs
@@ -1,11 +1,11 @@
-use alga::general::Real;
-use base::allocator::Allocator;
-use base::constraint::{AreMultipliable, DimEq, SameNumberOfRows, ShapeConstraint};
-use base::{DefaultAllocator, Matrix, Scalar, Unit, Vector};
-use dimension::{Dim, DimName, U1};
-use storage::{Storage, StorageMut};
+use alga::general::ComplexField;
+use crate::base::allocator::Allocator;
+use crate::base::constraint::{AreMultipliable, DimEq, SameNumberOfRows, ShapeConstraint};
+use crate::base::{DefaultAllocator, Matrix, Scalar, Unit, Vector};
+use crate::dimension::{Dim, DimName, U1};
+use crate::storage::{Storage, StorageMut};
 
-use geometry::Point;
+use crate::geometry::Point;
 
 /// A reflection wrt. a plane.
 pub struct Reflection<N: Scalar, D: Dim, S: Storage<N, D>> {
@@ -13,7 +13,7 @@ pub struct Reflection<N: Scalar, D: Dim, S: Storage<N, D>> {
     bias: N,
 }
 
-impl<N: Real, D: Dim, S: Storage<N, D>> Reflection<N, D, S> {
+impl<N: ComplexField, D: Dim, S: Storage<N, D>> Reflection<N, D, S> {
     /// Creates a new reflection wrt the plane orthogonal to the given axis and bias.
     ///
     /// The bias is the position of the plane on the axis. In particular, a bias equal to zero
@@ -21,7 +21,7 @@ impl<N: Real, D: Dim, S: Storage<N, D>> Reflection<N, D, S> {
     pub fn new(axis: Unit<Vector<N, D, S>>, bias: N) -> Self {
         Self {
             axis: axis.into_inner(),
-            bias: bias,
+            bias,
         }
     }
 
@@ -35,7 +35,7 @@ impl<N: Real, D: Dim, S: Storage<N, D>> Reflection<N, D, S> {
         D: DimName,
         DefaultAllocator: Allocator<N, D>,
     {
-        let bias = pt.coords.dot(axis.as_ref());
+        let bias = axis.dotc(&pt.coords);
         Self::new(axis, bias)
     }
 
@@ -55,29 +55,67 @@ impl<N: Real, D: Dim, S: Storage<N, D>> Reflection<N, D, S> {
             // NOTE: we borrow the column twice here. First it is borrowed immutably for the
             // dot product, and then mutably. Somehow, this allows significantly
             // better optimizations of the dot product from the compiler.
-            let m_two: N = ::convert(-2.0f64);
-            let factor = (rhs.column(i).dot(&self.axis) - self.bias) * m_two;
+            let m_two: N = crate::convert(-2.0f64);
+            let factor = (self.axis.dotc(&rhs.column(i)) - self.bias) * m_two;
             rhs.column_mut(i).axpy(factor, &self.axis, N::one());
         }
     }
 
-    /// Applies the reflection to the rows of `rhs`.
+    // FIXME: naming convention: reflect_to, reflect_assign ?
+    /// Applies the reflection to the columns of `rhs`.
+    pub fn reflect_with_sign<R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<N, R2, C2, S2>, sign: N)
+        where
+            S2: StorageMut<N, R2, C2>,
+            ShapeConstraint: SameNumberOfRows<R2, D>,
+    {
+        for i in 0..rhs.ncols() {
+            // NOTE: we borrow the column twice here. First it is borrowed immutably for the
+            // dot product, and then mutably. Somehow, this allows significantly
+            // better optimizations of the dot product from the compiler.
+            let m_two = sign.scale(crate::convert(-2.0f64));
+            let factor = (self.axis.dotc(&rhs.column(i)) - self.bias) * m_two;
+            rhs.column_mut(i).axpy(factor, &self.axis, sign);
+        }
+    }
+
+    /// Applies the reflection to the rows of `lhs`.
     pub fn reflect_rows<R2: Dim, C2: Dim, S2, S3>(
         &self,
-        rhs: &mut Matrix<N, R2, C2, S2>,
+        lhs: &mut Matrix<N, R2, C2, S2>,
+        work: &mut Vector<N, R2, S3>,
+    ) where
+        S2: StorageMut<N, R2, C2>,
+        S3: StorageMut<N, R2>,
+        ShapeConstraint: DimEq<C2, D> + AreMultipliable<R2, C2, D, U1>,
+    {
+        lhs.mul_to(&self.axis, work);
+
+        if !self.bias.is_zero() {
+            work.add_scalar_mut(-self.bias);
+        }
+
+        let m_two: N = crate::convert(-2.0f64);
+        lhs.gerc(m_two, &work, &self.axis, N::one());
+    }
+
+    /// Applies the reflection to the rows of `lhs`.
+    pub fn reflect_rows_with_sign<R2: Dim, C2: Dim, S2, S3>(
+        &self,
+        lhs: &mut Matrix<N, R2, C2, S2>,
         work: &mut Vector<N, R2, S3>,
+        sign: N,
     ) where
         S2: StorageMut<N, R2, C2>,
         S3: StorageMut<N, R2>,
         ShapeConstraint: DimEq<C2, D> + AreMultipliable<R2, C2, D, U1>,
     {
-        rhs.mul_to(&self.axis, work);
+        lhs.mul_to(&self.axis, work);
 
         if !self.bias.is_zero() {
             work.add_scalar_mut(-self.bias);
         }
 
-        let m_two: N = ::convert(-2.0f64);
-        rhs.ger(m_two, &work, &self.axis, N::one());
+        let m_two = sign.scale(crate::convert(-2.0f64));
+        lhs.gerc(m_two, &work, &self.axis, sign);
     }
 }
diff --git a/src/geometry/rotation.rs b/src/geometry/rotation.rs
index 426e9d251..ec9c8150b 100755
--- a/src/geometry/rotation.rs
+++ b/src/geometry/rotation.rs
@@ -9,18 +9,17 @@ use std::io::{Result as IOResult, Write};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[cfg(feature = "serde-serialize")]
-use base::storage::Owned;
+use crate::base::storage::Owned;
 
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
-use alga::general::Real;
+use alga::general::RealField;
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use base::{DefaultAllocator, MatrixN, Scalar, VectorN};
-
-use geometry::Point;
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::{DefaultAllocator, MatrixN, Scalar, VectorN};
+use crate::geometry::Point;
 
 /// A rotation matrix.
 #[repr(C)]
@@ -353,7 +352,7 @@ where DefaultAllocator: Allocator<N, D, D>
     }
 }
 
-impl<N: Real, D: DimName> Rotation<N, D>
+impl<N: RealField, D: DimName> Rotation<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     /// Rotate the given point.
@@ -511,14 +510,14 @@ where
  */
 impl<N, D: DimName> fmt::Display for Rotation<N, D>
 where
-    N: Real + fmt::Display,
+    N: RealField + fmt::Display,
     DefaultAllocator: Allocator<N, D, D> + Allocator<usize, D, D>,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let precision = f.precision().unwrap_or(3);
 
-        try!(writeln!(f, "Rotation matrix {{"));
-        try!(write!(f, "{:.*}", precision, self.matrix));
+        writeln!(f, "Rotation matrix {{")?;
+        write!(f, "{:.*}", precision, self.matrix)?;
         writeln!(f, "}}")
     }
 }
diff --git a/src/geometry/rotation_alga.rs b/src/geometry/rotation_alga.rs
index cd411c8ca..e8cf74e74 100755
--- a/src/geometry/rotation_alga.rs
+++ b/src/geometry/rotation_alga.rs
@@ -1,24 +1,24 @@
 use alga::general::{
     AbstractGroup, AbstractLoop, AbstractMagma, AbstractMonoid, AbstractQuasigroup,
-    AbstractSemigroup, Id, Identity, TwoSidedInverse, Multiplicative, Real,
+    AbstractSemigroup, Id, Identity, TwoSidedInverse, Multiplicative, RealField,
 };
 use alga::linear::{
     self, AffineTransformation, DirectIsometry, Isometry, OrthogonalTransformation,
     ProjectiveTransformation, Similarity, Transformation,
 };
 
-use base::allocator::Allocator;
-use base::dimension::DimName;
-use base::{DefaultAllocator, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::DimName;
+use crate::base::{DefaultAllocator, VectorN};
 
-use geometry::{Point, Rotation};
+use crate::geometry::{Point, Rotation};
 
 /*
  *
  * Algebraic structures.
  *
  */
-impl<N: Real, D: DimName> Identity<Multiplicative> for Rotation<N, D>
+impl<N: RealField, D: DimName> Identity<Multiplicative> for Rotation<N, D>
 where DefaultAllocator: Allocator<N, D, D>
 {
     #[inline]
@@ -27,7 +27,7 @@ where DefaultAllocator: Allocator<N, D, D>
     }
 }
 
-impl<N: Real, D: DimName> TwoSidedInverse<Multiplicative> for Rotation<N, D>
+impl<N: RealField, D: DimName> TwoSidedInverse<Multiplicative> for Rotation<N, D>
 where DefaultAllocator: Allocator<N, D, D>
 {
     #[inline]
@@ -41,7 +41,7 @@ where DefaultAllocator: Allocator<N, D, D>
     }
 }
 
-impl<N: Real, D: DimName> AbstractMagma<Multiplicative> for Rotation<N, D>
+impl<N: RealField, D: DimName> AbstractMagma<Multiplicative> for Rotation<N, D>
 where DefaultAllocator: Allocator<N, D, D>
 {
     #[inline]
@@ -52,7 +52,7 @@ where DefaultAllocator: Allocator<N, D, D>
 
 macro_rules! impl_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: Real, D: DimName> $marker<$operator> for Rotation<N, D>
+        impl<N: RealField, D: DimName> $marker<$operator> for Rotation<N, D>
             where DefaultAllocator: Allocator<N, D, D> { }
     )*}
 );
@@ -70,7 +70,7 @@ impl_multiplicative_structures!(
  * Transformation groups.
  *
  */
-impl<N: Real, D: DimName> Transformation<Point<N, D>> for Rotation<N, D>
+impl<N: RealField, D: DimName> Transformation<Point<N, D>> for Rotation<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     #[inline]
@@ -84,7 +84,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName> ProjectiveTransformation<Point<N, D>> for Rotation<N, D>
+impl<N: RealField, D: DimName> ProjectiveTransformation<Point<N, D>> for Rotation<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     #[inline]
@@ -98,7 +98,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName> AffineTransformation<Point<N, D>> for Rotation<N, D>
+impl<N: RealField, D: DimName> AffineTransformation<Point<N, D>> for Rotation<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     type Rotation = Self;
@@ -141,7 +141,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName> Similarity<Point<N, D>> for Rotation<N, D>
+impl<N: RealField, D: DimName> Similarity<Point<N, D>> for Rotation<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     type Scaling = Id;
@@ -164,7 +164,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 
 macro_rules! marker_impl(
     ($($Trait: ident),*) => {$(
-        impl<N: Real, D: DimName> $Trait<Point<N, D>> for Rotation<N, D>
+        impl<N: RealField, D: DimName> $Trait<Point<N, D>> for Rotation<N, D>
         where DefaultAllocator: Allocator<N, D, D> +
                                 Allocator<N, D> { }
     )*}
@@ -173,7 +173,7 @@ macro_rules! marker_impl(
 marker_impl!(Isometry, DirectIsometry, OrthogonalTransformation);
 
 /// Subgroups of the n-dimensional rotation group `SO(n)`.
-impl<N: Real, D: DimName> linear::Rotation<Point<N, D>> for Rotation<N, D>
+impl<N: RealField, D: DimName> linear::Rotation<Point<N, D>> for Rotation<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     #[inline]
@@ -199,7 +199,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 }
 
 /*
-impl<N: Real> Matrix for Rotation<N> {
+impl<N: RealField> Matrix for Rotation<N> {
     type Field     = N;
     type Row       = Matrix<N>;
     type Column    = Matrix<N>;
@@ -241,7 +241,7 @@ impl<N: Real> Matrix for Rotation<N> {
     }
 }
 
-impl<N: Real> SquareMatrix for Rotation<N> {
+impl<N: RealField> SquareMatrix for Rotation<N> {
     type Vector = Matrix<N>;
 
     #[inline]
@@ -251,7 +251,7 @@ impl<N: Real> SquareMatrix for Rotation<N> {
 
     #[inline]
     fn determinant(&self) -> Self::Field {
-        ::one()
+        crate::one()
     }
 
     #[inline]
@@ -271,5 +271,5 @@ impl<N: Real> SquareMatrix for Rotation<N> {
     }
 }
 
-impl<N: Real> InversibleSquareMatrix for Rotation<N> { }
+impl<N: RealField> InversibleSquareMatrix for Rotation<N> { }
 */
diff --git a/src/geometry/rotation_alias.rs b/src/geometry/rotation_alias.rs
index a11bba99e..9fa5c2d05 100644
--- a/src/geometry/rotation_alias.rs
+++ b/src/geometry/rotation_alias.rs
@@ -1,6 +1,6 @@
-use base::dimension::{U2, U3};
+use crate::base::dimension::{U2, U3};
 
-use geometry::Rotation;
+use crate::geometry::Rotation;
 
 /// A 2-dimensional rotation matrix.
 pub type Rotation2<N> = Rotation<N, U2>;
diff --git a/src/geometry/rotation_construction.rs b/src/geometry/rotation_construction.rs
index 0da2cb29c..a7779cc6d 100644
--- a/src/geometry/rotation_construction.rs
+++ b/src/geometry/rotation_construction.rs
@@ -2,11 +2,11 @@ use num::{One, Zero};
 
 use alga::general::{ClosedAdd, ClosedMul};
 
-use base::allocator::Allocator;
-use base::dimension::DimName;
-use base::{DefaultAllocator, MatrixN, Scalar};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::DimName;
+use crate::base::{DefaultAllocator, MatrixN, Scalar};
 
-use geometry::Rotation;
+use crate::geometry::Rotation;
 
 impl<N, D: DimName> Rotation<N, D>
 where
diff --git a/src/geometry/rotation_conversion.rs b/src/geometry/rotation_conversion.rs
index 044d85af7..ac3142211 100644
--- a/src/geometry/rotation_conversion.rs
+++ b/src/geometry/rotation_conversion.rs
@@ -1,16 +1,16 @@
 use num::Zero;
 
-use alga::general::{Real, SubsetOf, SupersetOf};
+use alga::general::{RealField, SubsetOf, SupersetOf};
 use alga::linear::Rotation as AlgaRotation;
 
 #[cfg(feature = "mint")]
 use mint;
 
-use base::allocator::Allocator;
-use base::dimension::{DimMin, DimName, DimNameAdd, DimNameSum, U1};
-use base::{DefaultAllocator, Matrix2, Matrix3, Matrix4, MatrixN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimMin, DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::{DefaultAllocator, Matrix2, Matrix3, Matrix4, MatrixN};
 
-use geometry::{
+use crate::geometry::{
     Isometry, Point, Rotation, Rotation2, Rotation3, Similarity, SuperTCategoryOf, TAffine,
     Transform, Translation, UnitComplex, UnitQuaternion,
 };
@@ -32,8 +32,8 @@ use geometry::{
 
 impl<N1, N2, D: DimName> SubsetOf<Rotation<N2, D>> for Rotation<N1, D>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D, D>,
 {
     #[inline]
@@ -43,7 +43,7 @@ where
 
     #[inline]
     fn is_in_subset(rot: &Rotation<N2, D>) -> bool {
-        ::is_convertible::<_, MatrixN<N1, D>>(rot.matrix())
+        crate::is_convertible::<_, MatrixN<N1, D>>(rot.matrix())
     }
 
     #[inline]
@@ -54,8 +54,8 @@ where
 
 impl<N1, N2> SubsetOf<UnitQuaternion<N2>> for Rotation3<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
 {
     #[inline]
     fn to_superset(&self) -> UnitQuaternion<N2> {
@@ -65,20 +65,20 @@ where
 
     #[inline]
     fn is_in_subset(q: &UnitQuaternion<N2>) -> bool {
-        ::is_convertible::<_, UnitQuaternion<N1>>(q)
+        crate::is_convertible::<_, UnitQuaternion<N1>>(q)
     }
 
     #[inline]
     unsafe fn from_superset_unchecked(q: &UnitQuaternion<N2>) -> Self {
-        let q: UnitQuaternion<N1> = ::convert_ref_unchecked(q);
+        let q: UnitQuaternion<N1> = crate::convert_ref_unchecked(q);
         q.to_rotation_matrix()
     }
 }
 
 impl<N1, N2> SubsetOf<UnitComplex<N2>> for Rotation2<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
 {
     #[inline]
     fn to_superset(&self) -> UnitComplex<N2> {
@@ -88,26 +88,26 @@ where
 
     #[inline]
     fn is_in_subset(q: &UnitComplex<N2>) -> bool {
-        ::is_convertible::<_, UnitComplex<N1>>(q)
+        crate::is_convertible::<_, UnitComplex<N1>>(q)
     }
 
     #[inline]
     unsafe fn from_superset_unchecked(q: &UnitComplex<N2>) -> Self {
-        let q: UnitComplex<N1> = ::convert_ref_unchecked(q);
+        let q: UnitComplex<N1> = crate::convert_ref_unchecked(q);
         q.to_rotation_matrix()
     }
 }
 
 impl<N1, N2, D: DimName, R> SubsetOf<Isometry<N2, D, R>> for Rotation<N1, D>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R: AlgaRotation<Point<N2, D>> + SupersetOf<Self>,
     DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D>,
 {
     #[inline]
     fn to_superset(&self) -> Isometry<N2, D, R> {
-        Isometry::from_parts(Translation::identity(), ::convert_ref(self))
+        Isometry::from_parts(Translation::identity(), crate::convert_ref(self))
     }
 
     #[inline]
@@ -117,20 +117,20 @@ where
 
     #[inline]
     unsafe fn from_superset_unchecked(iso: &Isometry<N2, D, R>) -> Self {
-        ::convert_ref_unchecked(&iso.rotation)
+        crate::convert_ref_unchecked(&iso.rotation)
     }
 }
 
 impl<N1, N2, D: DimName, R> SubsetOf<Similarity<N2, D, R>> for Rotation<N1, D>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R: AlgaRotation<Point<N2, D>> + SupersetOf<Self>,
     DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D>,
 {
     #[inline]
     fn to_superset(&self) -> Similarity<N2, D, R> {
-        Similarity::from_parts(Translation::identity(), ::convert_ref(self), N2::one())
+        Similarity::from_parts(Translation::identity(), crate::convert_ref(self), N2::one())
     }
 
     #[inline]
@@ -140,14 +140,14 @@ where
 
     #[inline]
     unsafe fn from_superset_unchecked(sim: &Similarity<N2, D, R>) -> Self {
-        ::convert_ref_unchecked(&sim.isometry.rotation)
+        crate::convert_ref_unchecked(&sim.isometry.rotation)
     }
 }
 
 impl<N1, N2, D, C> SubsetOf<Transform<N2, D, C>> for Rotation<N1, D>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     C: SuperTCategoryOf<TAffine>,
     D: DimNameAdd<U1> + DimMin<D, Output = D>, // needed by .is_special_orthogonal()
     DefaultAllocator: Allocator<N1, D, D>
@@ -175,8 +175,8 @@ where
 
 impl<N1, N2, D> SubsetOf<MatrixN<N2, DimNameSum<D, U1>>> for Rotation<N1, D>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     D: DimNameAdd<U1> + DimMin<D, Output = D>, // needed by .is_special_orthogonal()
     DefaultAllocator: Allocator<N1, D, D>
         + Allocator<N2, D, D>
@@ -198,7 +198,7 @@ where
         // Scalar types agree.
         m.iter().all(|e| SupersetOf::<N1>::is_in_subset(e)) &&
         // The block part is a rotation.
-        rot.is_special_orthogonal(N2::default_epsilon() * ::convert(100.0)) &&
+        rot.is_special_orthogonal(N2::default_epsilon() * crate::convert(100.0)) &&
         // The bottom row is (0, 0, ..., 1)
         bottom.iter().all(|e| e.is_zero()) && m[(D::dim(), D::dim())] == N2::one()
     }
@@ -206,39 +206,39 @@ where
     #[inline]
     unsafe fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self {
         let r = m.fixed_slice::<D, D>(0, 0);
-        Self::from_matrix_unchecked(::convert_unchecked(r.into_owned()))
+        Self::from_matrix_unchecked(crate::convert_unchecked(r.into_owned()))
     }
 }
 
 #[cfg(feature = "mint")]
-impl<N: Real> From<mint::EulerAngles<N, mint::IntraXYZ>> for Rotation3<N> {
+impl<N: RealField> From<mint::EulerAngles<N, mint::IntraXYZ>> for Rotation3<N> {
     fn from(euler: mint::EulerAngles<N, mint::IntraXYZ>) -> Self {
         Self::from_euler_angles(euler.a, euler.b, euler.c)
     }
 }
 
-impl<N: Real> From<Rotation2<N>> for Matrix3<N> {
+impl<N: RealField> From<Rotation2<N>> for Matrix3<N> {
     #[inline]
     fn from(q: Rotation2<N>) ->Self {
         q.to_homogeneous()
     }
 }
 
-impl<N: Real> From<Rotation2<N>> for Matrix2<N> {
+impl<N: RealField> From<Rotation2<N>> for Matrix2<N> {
     #[inline]
     fn from(q: Rotation2<N>) -> Self {
         q.into_inner()
     }
 }
 
-impl<N: Real> From<Rotation3<N>> for Matrix4<N> {
+impl<N: RealField> From<Rotation3<N>> for Matrix4<N> {
     #[inline]
     fn from(q: Rotation3<N>) -> Self {
         q.to_homogeneous()
     }
 }
 
-impl<N: Real> From<Rotation3<N>> for Matrix3<N> {
+impl<N: RealField> From<Rotation3<N>> for Matrix3<N> {
     #[inline]
     fn from(q: Rotation3<N>) -> Self {
         q.into_inner()
diff --git a/src/geometry/rotation_ops.rs b/src/geometry/rotation_ops.rs
index fae709210..ed555b6b4 100644
--- a/src/geometry/rotation_ops.rs
+++ b/src/geometry/rotation_ops.rs
@@ -22,13 +22,13 @@ use std::ops::{Div, DivAssign, Index, Mul, MulAssign};
 
 use alga::general::{ClosedAdd, ClosedMul};
 
-use base::allocator::Allocator;
-use base::constraint::{AreMultipliable, ShapeConstraint};
-use base::dimension::{Dim, DimName, U1};
-use base::storage::Storage;
-use base::{DefaultAllocator, Matrix, MatrixMN, Scalar, Unit, Vector, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::constraint::{AreMultipliable, ShapeConstraint};
+use crate::base::dimension::{Dim, DimName, U1};
+use crate::base::storage::Storage;
+use crate::base::{DefaultAllocator, Matrix, MatrixMN, Scalar, Unit, Vector, VectorN};
 
-use geometry::{Point, Rotation};
+use crate::geometry::{Point, Rotation};
 
 impl<N: Scalar, D: DimName> Index<(usize, usize)> for Rotation<N, D>
 where DefaultAllocator: Allocator<N, D, D>
diff --git a/src/geometry/rotation_specialization.rs b/src/geometry/rotation_specialization.rs
index 0aeb3041e..973190a6d 100644
--- a/src/geometry/rotation_specialization.rs
+++ b/src/geometry/rotation_specialization.rs
@@ -1,26 +1,26 @@
 #[cfg(feature = "arbitrary")]
-use base::storage::Owned;
+use crate::base::storage::Owned;
 #[cfg(feature = "arbitrary")]
 use quickcheck::{Arbitrary, Gen};
 
-use alga::general::Real;
+use alga::general::RealField;
 use num::Zero;
 use rand::distributions::{Distribution, OpenClosed01, Standard};
 use rand::Rng;
 use std::ops::Neg;
 
-use base::dimension::{U1, U2, U3};
-use base::storage::Storage;
-use base::{Matrix2, Matrix3, MatrixN, Unit, Vector, Vector1, Vector3, VectorN};
+use crate::base::dimension::{U1, U2, U3};
+use crate::base::storage::Storage;
+use crate::base::{Matrix2, Matrix3, MatrixN, Unit, Vector, Vector1, Vector3, VectorN};
 
-use geometry::{Rotation2, Rotation3, UnitComplex, UnitQuaternion};
+use crate::geometry::{Rotation2, Rotation3, UnitComplex, UnitQuaternion};
 
 /*
  *
  * 2D Rotation matrix.
  *
  */
-impl<N: Real> Rotation2<N> {
+impl<N: RealField> Rotation2<N> {
     /// Builds a 2 dimensional rotation matrix from an angle in radian.
     ///
     /// # Example
@@ -113,7 +113,7 @@ impl<N: Real> Rotation2<N> {
         SB: Storage<N, U2>,
         SC: Storage<N, U2>,
     {
-        ::convert(UnitComplex::rotation_between(a, b).to_rotation_matrix())
+        crate::convert(UnitComplex::rotation_between(a, b).to_rotation_matrix())
     }
 
     /// The smallest rotation needed to make `a` and `b` collinear and point toward the same
@@ -140,7 +140,7 @@ impl<N: Real> Rotation2<N> {
         SB: Storage<N, U2>,
         SC: Storage<N, U2>,
     {
-        ::convert(UnitComplex::scaled_rotation_between(a, b, s).to_rotation_matrix())
+        crate::convert(UnitComplex::scaled_rotation_between(a, b, s).to_rotation_matrix())
     }
 
     /// The rotation angle.
@@ -193,7 +193,6 @@ impl<N: Real> Rotation2<N> {
     }
 
 
-    /* FIXME: requires alga v0.9 to be released so that Complex implements VectorSpace.
     /// Ensure this rotation is an orthonormal rotation matrix. This is useful when repeated
     /// computations might cause the matrix from progressively not being orthonormal anymore.
     #[inline]
@@ -203,7 +202,6 @@ impl<N: Real> Rotation2<N> {
 
         *self = Self::from_matrix_eps(self.matrix(), N::default_epsilon(), 0, c.into())
     }
-    */
 
 
     /// Raise the quaternion to a given floating power, i.e., returns the rotation with the angle
@@ -232,7 +230,7 @@ impl<N: Real> Rotation2<N> {
     }
 }
 
-impl<N: Real> Distribution<Rotation2<N>> for Standard
+impl<N: RealField> Distribution<Rotation2<N>> for Standard
 where OpenClosed01: Distribution<N>
 {
     /// Generate a uniformly distributed random rotation.
@@ -243,7 +241,7 @@ where OpenClosed01: Distribution<N>
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: Real + Arbitrary> Arbitrary for Rotation2<N>
+impl<N: RealField + Arbitrary> Arbitrary for Rotation2<N>
 where Owned<N, U2, U2>: Send
 {
     #[inline]
@@ -257,7 +255,7 @@ where Owned<N, U2, U2>: Send
  * 3D Rotation matrix.
  *
  */
-impl<N: Real> Rotation3<N> {
+impl<N: RealField> Rotation3<N> {
     /// Builds a 3 dimensional rotation matrix from an axis and an angle.
     ///
     /// # Arguments
@@ -682,7 +680,7 @@ impl<N: Real> Rotation3<N> {
     #[inline]
     pub fn angle(&self) -> N {
         ((self.matrix()[(0, 0)] + self.matrix()[(1, 1)] + self.matrix()[(2, 2)] - N::one())
-            / ::convert(2.0))
+            / crate::convert(2.0))
         .acos()
     }
 
@@ -819,7 +817,7 @@ impl<N: Real> Rotation3<N> {
     }
 }
 
-impl<N: Real> Distribution<Rotation3<N>> for Standard
+impl<N: RealField> Distribution<Rotation3<N>> for Standard
 where OpenClosed01: Distribution<N>
 {
     /// Generate a uniformly distributed random rotation.
@@ -859,7 +857,7 @@ where OpenClosed01: Distribution<N>
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: Real + Arbitrary> Arbitrary for Rotation3<N>
+impl<N: RealField + Arbitrary> Arbitrary for Rotation3<N>
 where
     Owned<N, U3, U3>: Send,
     Owned<N, U3>: Send,
diff --git a/src/geometry/similarity.rs b/src/geometry/similarity.rs
index 4cce91a6d..fed047258 100755
--- a/src/geometry/similarity.rs
+++ b/src/geometry/similarity.rs
@@ -10,14 +10,14 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
-use alga::general::{Real, SubsetOf};
+use alga::general::{RealField, SubsetOf};
 use alga::linear::Rotation;
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use base::storage::Owned;
-use base::{DefaultAllocator, MatrixN, VectorN};
-use geometry::{Isometry, Point, Translation};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::storage::Owned;
+use crate::base::{DefaultAllocator, MatrixN, VectorN};
+use crate::geometry::{Isometry, Point, Translation};
 
 /// A similarity, i.e., an uniform scaling, followed by a rotation, followed by a translation.
 #[repr(C)]
@@ -41,7 +41,7 @@ use geometry::{Isometry, Point, Translation};
                        Owned<N, D>: Deserialize<'de>"
     ))
 )]
-pub struct Similarity<N: Real, D: DimName, R>
+pub struct Similarity<N: RealField, D: DimName, R>
 where DefaultAllocator: Allocator<N, D>
 {
     /// The part of this similarity that does not include the scaling factor.
@@ -50,7 +50,7 @@ where DefaultAllocator: Allocator<N, D>
 }
 
 #[cfg(feature = "abomonation-serialize")]
-impl<N: Real, D: DimName, R> Abomonation for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> Abomonation for Similarity<N, D, R>
 where
     Isometry<N, D, R>: Abomonation,
     DefaultAllocator: Allocator<N, D>,
@@ -68,7 +68,7 @@ where
     }
 }
 
-impl<N: Real + hash::Hash, D: DimName + hash::Hash, R: hash::Hash> hash::Hash
+impl<N: RealField + hash::Hash, D: DimName + hash::Hash, R: hash::Hash> hash::Hash
     for Similarity<N, D, R>
 where
     DefaultAllocator: Allocator<N, D>,
@@ -80,13 +80,13 @@ where
     }
 }
 
-impl<N: Real, D: DimName + Copy, R: Rotation<Point<N, D>> + Copy> Copy for Similarity<N, D, R>
+impl<N: RealField, D: DimName + Copy, R: Rotation<Point<N, D>> + Copy> Copy for Similarity<N, D, R>
 where
     DefaultAllocator: Allocator<N, D>,
     Owned<N, D>: Copy,
 {}
 
-impl<N: Real, D: DimName, R: Rotation<Point<N, D>> + Clone> Clone for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R: Rotation<Point<N, D>> + Clone> Clone for Similarity<N, D, R>
 where DefaultAllocator: Allocator<N, D>
 {
     #[inline]
@@ -95,7 +95,7 @@ where DefaultAllocator: Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName, R> Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -325,7 +325,7 @@ where
 // and makes it harder to use it, e.g., for Transform × Isometry implementation.
 // This is OK since all constructors of the isometry enforce the Rotation bound already (and
 // explicit struct construction is prevented by the private scaling factor).
-impl<N: Real, D: DimName, R> Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> Similarity<N, D, R>
 where DefaultAllocator: Allocator<N, D>
 {
     /// Converts this similarity into its equivalent homogeneous transformation matrix.
@@ -346,13 +346,13 @@ where DefaultAllocator: Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName, R> Eq for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> Eq for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>> + Eq,
     DefaultAllocator: Allocator<N, D>,
 {}
 
-impl<N: Real, D: DimName, R> PartialEq for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> PartialEq for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>> + PartialEq,
     DefaultAllocator: Allocator<N, D>,
@@ -363,7 +363,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> AbsDiffEq for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> AbsDiffEq for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>> + AbsDiffEq<Epsilon = N::Epsilon>,
     DefaultAllocator: Allocator<N, D>,
@@ -383,7 +383,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> RelativeEq for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> RelativeEq for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>> + RelativeEq<Epsilon = N::Epsilon>,
     DefaultAllocator: Allocator<N, D>,
@@ -410,7 +410,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> UlpsEq for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> UlpsEq for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>> + UlpsEq<Epsilon = N::Epsilon>,
     DefaultAllocator: Allocator<N, D>,
@@ -435,16 +435,16 @@ where
  */
 impl<N, D: DimName, R> fmt::Display for Similarity<N, D, R>
 where
-    N: Real + fmt::Display,
+    N: RealField + fmt::Display,
     R: Rotation<Point<N, D>> + fmt::Display,
     DefaultAllocator: Allocator<N, D> + Allocator<usize, D>,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let precision = f.precision().unwrap_or(3);
 
-        try!(writeln!(f, "Similarity {{"));
-        try!(write!(f, "{:.*}", precision, self.isometry));
-        try!(write!(f, "Scaling: {:.*}", precision, self.scaling));
+        writeln!(f, "Similarity {{")?;
+        write!(f, "{:.*}", precision, self.isometry)?;
+        write!(f, "Scaling: {:.*}", precision, self.scaling)?;
         writeln!(f, "}}")
     }
 }
diff --git a/src/geometry/similarity_alga.rs b/src/geometry/similarity_alga.rs
index 9b7230294..448fb1335 100755
--- a/src/geometry/similarity_alga.rs
+++ b/src/geometry/similarity_alga.rs
@@ -1,22 +1,22 @@
 use alga::general::{
     AbstractGroup, AbstractLoop, AbstractMagma, AbstractMonoid, AbstractQuasigroup,
-    AbstractSemigroup, Identity, TwoSidedInverse, Multiplicative, Real,
+    AbstractSemigroup, Identity, TwoSidedInverse, Multiplicative, RealField,
 };
 use alga::linear::Similarity as AlgaSimilarity;
 use alga::linear::{AffineTransformation, ProjectiveTransformation, Rotation, Transformation};
 
-use base::allocator::Allocator;
-use base::dimension::DimName;
-use base::{DefaultAllocator, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::DimName;
+use crate::base::{DefaultAllocator, VectorN};
 
-use geometry::{Point, Similarity, Translation};
+use crate::geometry::{Point, Similarity, Translation};
 
 /*
  *
  * Algebraic structures.
  *
  */
-impl<N: Real, D: DimName, R> Identity<Multiplicative> for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> Identity<Multiplicative> for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -27,7 +27,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> TwoSidedInverse<Multiplicative> for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> TwoSidedInverse<Multiplicative> for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -43,7 +43,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> AbstractMagma<Multiplicative> for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> AbstractMagma<Multiplicative> for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -56,7 +56,7 @@ where
 
 macro_rules! impl_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: Real, D: DimName, R> $marker<$operator> for Similarity<N, D, R>
+        impl<N: RealField, D: DimName, R> $marker<$operator> for Similarity<N, D, R>
             where R: Rotation<Point<N, D>>,
                   DefaultAllocator: Allocator<N, D> { }
     )*}
@@ -75,7 +75,7 @@ impl_multiplicative_structures!(
  * Transformation groups.
  *
  */
-impl<N: Real, D: DimName, R> Transformation<Point<N, D>> for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> Transformation<Point<N, D>> for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -91,7 +91,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> ProjectiveTransformation<Point<N, D>> for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> ProjectiveTransformation<Point<N, D>> for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -107,7 +107,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> AffineTransformation<Point<N, D>> for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> AffineTransformation<Point<N, D>> for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -164,7 +164,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> AlgaSimilarity<Point<N, D>> for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> AlgaSimilarity<Point<N, D>> for Similarity<N, D, R>
 where
     R: Rotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
diff --git a/src/geometry/similarity_alias.rs b/src/geometry/similarity_alias.rs
index 9d3a2f45b..c2c887ac0 100644
--- a/src/geometry/similarity_alias.rs
+++ b/src/geometry/similarity_alias.rs
@@ -1,6 +1,6 @@
-use base::dimension::{U2, U3};
+use crate::base::dimension::{U2, U3};
 
-use geometry::{Rotation2, Rotation3, Similarity, UnitComplex, UnitQuaternion};
+use crate::geometry::{Rotation2, Rotation3, Similarity, UnitComplex, UnitQuaternion};
 
 /// A 2-dimensional similarity.
 pub type Similarity2<N> = Similarity<N, U2, UnitComplex<N>>;
diff --git a/src/geometry/similarity_construction.rs b/src/geometry/similarity_construction.rs
index 47bb46c75..a3722ba95 100644
--- a/src/geometry/similarity_construction.rs
+++ b/src/geometry/similarity_construction.rs
@@ -1,5 +1,5 @@
 #[cfg(feature = "arbitrary")]
-use base::storage::Owned;
+use crate::base::storage::Owned;
 #[cfg(feature = "arbitrary")]
 use quickcheck::{Arbitrary, Gen};
 
@@ -7,19 +7,19 @@ use num::One;
 use rand::distributions::{Distribution, Standard};
 use rand::Rng;
 
-use alga::general::Real;
+use alga::general::RealField;
 use alga::linear::Rotation as AlgaRotation;
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, U2, U3};
-use base::{DefaultAllocator, Vector2, Vector3};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, U2, U3};
+use crate::base::{DefaultAllocator, Vector2, Vector3};
 
-use geometry::{
+use crate::geometry::{
     Isometry, Point, Point3, Rotation2, Rotation3, Similarity, Translation, UnitComplex,
     UnitQuaternion,
 };
 
-impl<N: Real, D: DimName, R> Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> Similarity<N, D, R>
 where
     R: AlgaRotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -45,7 +45,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> One for Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> One for Similarity<N, D, R>
 where
     R: AlgaRotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -57,7 +57,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> Distribution<Similarity<N, D, R>> for Standard
+impl<N: RealField, D: DimName, R> Distribution<Similarity<N, D, R>> for Standard
 where
     R: AlgaRotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -74,7 +74,7 @@ where
     }
 }
 
-impl<N: Real, D: DimName, R> Similarity<N, D, R>
+impl<N: RealField, D: DimName, R> Similarity<N, D, R>
 where
     R: AlgaRotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
@@ -104,7 +104,7 @@ where
 #[cfg(feature = "arbitrary")]
 impl<N, D: DimName, R> Arbitrary for Similarity<N, D, R>
 where
-    N: Real + Arbitrary + Send,
+    N: RealField + Arbitrary + Send,
     R: AlgaRotation<Point<N, D>> + Arbitrary + Send,
     DefaultAllocator: Allocator<N, D>,
     Owned<N, D>: Send,
@@ -127,7 +127,7 @@ where
  */
 
 // 2D rotation.
-impl<N: Real> Similarity<N, U2, Rotation2<N>> {
+impl<N: RealField> Similarity<N, U2, Rotation2<N>> {
     /// Creates a new similarity from a translation, a rotation, and an uniform scaling factor.
     ///
     /// # Example
@@ -150,7 +150,7 @@ impl<N: Real> Similarity<N, U2, Rotation2<N>> {
     }
 }
 
-impl<N: Real> Similarity<N, U2, UnitComplex<N>> {
+impl<N: RealField> Similarity<N, U2, UnitComplex<N>> {
     /// Creates a new similarity from a translation and a rotation angle.
     ///
     /// # Example
@@ -176,7 +176,7 @@ impl<N: Real> Similarity<N, U2, UnitComplex<N>> {
 // 3D rotation.
 macro_rules! similarity_construction_impl(
     ($Rot: ty) => {
-        impl<N: Real> Similarity<N, U3, $Rot> {
+        impl<N: RealField> Similarity<N, U3, $Rot> {
             /// Creates a new similarity from a translation, rotation axis-angle, and scaling
             /// factor.
             ///
diff --git a/src/geometry/similarity_conversion.rs b/src/geometry/similarity_conversion.rs
index 34943fee8..a0d207e4e 100644
--- a/src/geometry/similarity_conversion.rs
+++ b/src/geometry/similarity_conversion.rs
@@ -1,11 +1,11 @@
-use alga::general::{Real, SubsetOf, SupersetOf};
+use alga::general::{RealField, SubsetOf, SupersetOf};
 use alga::linear::Rotation;
 
-use base::allocator::Allocator;
-use base::dimension::{DimMin, DimName, DimNameAdd, DimNameSum, U1};
-use base::{DefaultAllocator, MatrixN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimMin, DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::{DefaultAllocator, MatrixN};
 
-use geometry::{Isometry, Point, Similarity, SuperTCategoryOf, TAffine, Transform, Translation};
+use crate::geometry::{Isometry, Point, Similarity, SuperTCategoryOf, TAffine, Transform, Translation};
 
 /*
  * This file provides the following conversions:
@@ -18,8 +18,8 @@ use geometry::{Isometry, Point, Similarity, SuperTCategoryOf, TAffine, Transform
 
 impl<N1, N2, D: DimName, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Similarity<N1, D, R1>
 where
-    N1: Real + SubsetOf<N2>,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField + SubsetOf<N2>,
+    N2: RealField + SupersetOf<N1>,
     R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
     R2: Rotation<Point<N2, D>>,
     DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
@@ -31,8 +31,8 @@ where
 
     #[inline]
     fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool {
-        ::is_convertible::<_, Isometry<N1, D, R1>>(&sim.isometry)
-            && ::is_convertible::<_, N1>(&sim.scaling())
+        crate::is_convertible::<_, Isometry<N1, D, R1>>(&sim.isometry)
+            && crate::is_convertible::<_, N1>(&sim.scaling())
     }
 
     #[inline]
@@ -46,8 +46,8 @@ where
 
 impl<N1, N2, D, R, C> SubsetOf<Transform<N2, D, C>> for Similarity<N1, D, R>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     C: SuperTCategoryOf<TAffine>,
     R: Rotation<Point<N1, D>>
         + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>>
@@ -80,8 +80,8 @@ where
 
 impl<N1, N2, D, R> SubsetOf<MatrixN<N2, DimNameSum<D, U1>>> for Similarity<N1, D, R>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R: Rotation<Point<N1, D>>
         + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>>
         + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
@@ -143,7 +143,7 @@ where
         let nb = mm.fixed_slice_mut::<D, U1>(0, 1).normalize_mut();
         let nc = mm.fixed_slice_mut::<D, U1>(0, 2).normalize_mut();
 
-        let mut scale = (na + nb + nc) / ::convert(3.0); // We take the mean, for robustness.
+        let mut scale = (na + nb + nc) / crate::convert(3.0); // We take the mean, for robustness.
 
         // FIXME: could we avoid the explicit computation of the determinant?
         // (its sign is needed to see if the scaling factor is negative).
@@ -156,14 +156,14 @@ where
 
         let t = m.fixed_slice::<D, U1>(0, D::dim()).into_owned();
         let t = Translation {
-            vector: ::convert_unchecked(t),
+            vector: crate::convert_unchecked(t),
         };
 
-        Self::from_parts(t, ::convert_unchecked(mm), ::convert_unchecked(scale))
+        Self::from_parts(t, crate::convert_unchecked(mm), crate::convert_unchecked(scale))
     }
 }
 
-impl<N: Real, D: DimName, R> From<Similarity<N, D, R>> for MatrixN<N, DimNameSum<D, U1>>
+impl<N: RealField, D: DimName, R> From<Similarity<N, D, R>> for MatrixN<N, DimNameSum<D, U1>>
 where
     D: DimNameAdd<U1>,
     R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
diff --git a/src/geometry/similarity_ops.rs b/src/geometry/similarity_ops.rs
index 081e51330..80d84b86e 100644
--- a/src/geometry/similarity_ops.rs
+++ b/src/geometry/similarity_ops.rs
@@ -1,13 +1,13 @@
 use std::ops::{Div, DivAssign, Mul, MulAssign};
 
-use alga::general::Real;
+use alga::general::RealField;
 use alga::linear::Rotation as AlgaRotation;
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, U1, U3, U4};
-use base::{DefaultAllocator, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, U1, U3, U4};
+use crate::base::{DefaultAllocator, VectorN};
 
-use geometry::{Isometry, Point, Rotation, Similarity, Translation, UnitQuaternion};
+use crate::geometry::{Isometry, Point, Rotation, Similarity, Translation, UnitQuaternion};
 
 // FIXME: there are several cloning of rotations that we could probably get rid of (but we didn't
 // yet because that would require to add a bound like `where for<'a, 'b> &'a R: Mul<&'b R, Output = R>`
@@ -66,7 +66,7 @@ macro_rules! similarity_binop_impl(
     ($Op: ident, $op: ident;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: Real, D: DimName, R> $Op<$Rhs> for $Lhs
+        impl<$($lives ,)* N: RealField, D: DimName, R> $Op<$Rhs> for $Lhs
             where R: AlgaRotation<Point<N, D>>,
                   DefaultAllocator: Allocator<N, D> {
             type Output = $Output;
@@ -113,7 +113,7 @@ macro_rules! similarity_binop_assign_impl_all(
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty;
      [val] => $action_val: expr;
      [ref] => $action_ref: expr;) => {
-        impl<N: Real, D: DimName, R> $OpAssign<$Rhs> for $Lhs
+        impl<N: RealField, D: DimName, R> $OpAssign<$Rhs> for $Lhs
             where R: AlgaRotation<Point<N, D>>,
                   DefaultAllocator: Allocator<N, D> {
             #[inline]
@@ -122,7 +122,7 @@ macro_rules! similarity_binop_assign_impl_all(
             }
         }
 
-        impl<'b, N: Real, D: DimName, R> $OpAssign<&'b $Rhs> for $Lhs
+        impl<'b, N: RealField, D: DimName, R> $OpAssign<&'b $Rhs> for $Lhs
             where R: AlgaRotation<Point<N, D>>,
                   DefaultAllocator: Allocator<N, D> {
             #[inline]
@@ -379,7 +379,7 @@ macro_rules! similarity_from_composition_impl(
      ($R1: ty, $C1: ty),($R2: ty, $C2: ty) $(for $Dims: ident: $DimsBound: ident),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Output: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: Real $(, $Dims: $DimsBound)*> $Op<$Rhs> for $Lhs
+        impl<$($lives ,)* N: RealField $(, $Dims: $DimsBound)*> $Op<$Rhs> for $Lhs
             where DefaultAllocator: Allocator<N, $R1, $C1> +
                                     Allocator<N, $R2, $C2> {
             type Output = $Output;
diff --git a/src/geometry/swizzle.rs b/src/geometry/swizzle.rs
index 20c8dffd1..d57400160 100644
--- a/src/geometry/swizzle.rs
+++ b/src/geometry/swizzle.rs
@@ -1,6 +1,6 @@
-use base::allocator::Allocator;
-use base::{DefaultAllocator, DimName, Scalar};
-use geometry::{Point, Point2, Point3};
+use crate::base::allocator::Allocator;
+use crate::base::{DefaultAllocator, DimName, Scalar};
+use crate::geometry::{Point, Point2, Point3};
 use typenum::{self, Cmp, Greater};
 
 macro_rules! impl_swizzle {
diff --git a/src/geometry/transform.rs b/src/geometry/transform.rs
index e0eb1bb92..baf3308bc 100755
--- a/src/geometry/transform.rs
+++ b/src/geometry/transform.rs
@@ -6,14 +6,14 @@ use std::marker::PhantomData;
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-use alga::general::{Real, TwoSidedInverse};
+use alga::general::{RealField, TwoSidedInverse};
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use base::storage::Owned;
-use base::{DefaultAllocator, MatrixN, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::storage::Owned;
+use crate::base::{DefaultAllocator, MatrixN, VectorN};
 
-use geometry::Point;
+use crate::geometry::Point;
 
 /// Trait implemented by phantom types identifying the projective transformation type.
 ///
@@ -28,7 +28,7 @@ pub trait TCategory: Any + Debug + Copy + PartialEq + Send {
 
     /// Checks that the given matrix is a valid homogeneous representation of an element of the
     /// category `Self`.
-    fn check_homogeneous_invariants<N: Real, D: DimName>(mat: &MatrixN<N, D>) -> bool
+    fn check_homogeneous_invariants<N: RealField, D: DimName>(mat: &MatrixN<N, D>) -> bool
     where
         N::Epsilon: Copy,
         DefaultAllocator: Allocator<N, D, D>;
@@ -71,7 +71,7 @@ pub enum TAffine {}
 
 impl TCategory for TGeneral {
     #[inline]
-    fn check_homogeneous_invariants<N: Real, D: DimName>(_: &MatrixN<N, D>) -> bool
+    fn check_homogeneous_invariants<N: RealField, D: DimName>(_: &MatrixN<N, D>) -> bool
     where
         N::Epsilon: Copy,
         DefaultAllocator: Allocator<N, D, D>,
@@ -82,7 +82,7 @@ impl TCategory for TGeneral {
 
 impl TCategory for TProjective {
     #[inline]
-    fn check_homogeneous_invariants<N: Real, D: DimName>(mat: &MatrixN<N, D>) -> bool
+    fn check_homogeneous_invariants<N: RealField, D: DimName>(mat: &MatrixN<N, D>) -> bool
     where
         N::Epsilon: Copy,
         DefaultAllocator: Allocator<N, D, D>,
@@ -98,7 +98,7 @@ impl TCategory for TAffine {
     }
 
     #[inline]
-    fn check_homogeneous_invariants<N: Real, D: DimName>(mat: &MatrixN<N, D>) -> bool
+    fn check_homogeneous_invariants<N: RealField, D: DimName>(mat: &MatrixN<N, D>) -> bool
     where
         N::Epsilon: Copy,
         DefaultAllocator: Allocator<N, D, D>,
@@ -157,7 +157,7 @@ super_tcategory_impl!(
 /// 3D transformation.
 #[repr(C)]
 #[derive(Debug)]
-pub struct Transform<N: Real, D: DimNameAdd<U1>, C: TCategory>
+pub struct Transform<N: RealField, D: DimNameAdd<U1>, C: TCategory>
 where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 {
     matrix: MatrixN<N, DimNameSum<D, U1>>,
@@ -165,7 +165,7 @@ where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 }
 
 // FIXME
-// impl<N: Real + hash::Hash, D: DimNameAdd<U1> + hash::Hash, C: TCategory> hash::Hash for Transform<N, D, C>
+// impl<N: RealField + hash::Hash, D: DimNameAdd<U1> + hash::Hash, C: TCategory> hash::Hash for Transform<N, D, C>
 //     where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
 //           Owned<N, DimNameSum<D, U1>, DimNameSum<D, U1>>: hash::Hash {
 //     fn hash<H: hash::Hasher>(&self, state: &mut H) {
@@ -173,14 +173,14 @@ where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 //     }
 // }
 
-impl<N: Real, D: DimNameAdd<U1> + Copy, C: TCategory> Copy for Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1> + Copy, C: TCategory> Copy for Transform<N, D, C>
 where
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
     Owned<N, DimNameSum<D, U1>, DimNameSum<D, U1>>: Copy,
 {
 }
 
-impl<N: Real, D: DimNameAdd<U1>, C: TCategory> Clone for Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> Clone for Transform<N, D, C>
 where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 {
     #[inline]
@@ -190,7 +190,7 @@ where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<N: Real, D: DimNameAdd<U1>, C: TCategory> Serialize for Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> Serialize for Transform<N, D, C>
 where
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
     Owned<N, DimNameSum<D, U1>, DimNameSum<D, U1>>: Serialize,
@@ -202,7 +202,7 @@ where
 }
 
 #[cfg(feature = "serde-serialize")]
-impl<'a, N: Real, D: DimNameAdd<U1>, C: TCategory> Deserialize<'a> for Transform<N, D, C>
+impl<'a, N: RealField, D: DimNameAdd<U1>, C: TCategory> Deserialize<'a> for Transform<N, D, C>
 where
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
     Owned<N, DimNameSum<D, U1>, DimNameSum<D, U1>>: Deserialize<'a>,
@@ -215,10 +215,10 @@ where
     }
 }
 
-impl<N: Real + Eq, D: DimNameAdd<U1>, C: TCategory> Eq for Transform<N, D, C> where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
+impl<N: RealField + Eq, D: DimNameAdd<U1>, C: TCategory> Eq for Transform<N, D, C> where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 {}
 
-impl<N: Real, D: DimNameAdd<U1>, C: TCategory> PartialEq for Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> PartialEq for Transform<N, D, C>
 where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 {
     #[inline]
@@ -227,7 +227,7 @@ where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
     }
 }
 
-impl<N: Real, D: DimNameAdd<U1>, C: TCategory> Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> Transform<N, D, C>
 where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 {
     /// Creates a new transformation from the given homogeneous matrix. The transformation category
@@ -456,7 +456,7 @@ where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 
 impl<N, D: DimNameAdd<U1>, C> Transform<N, D, C>
 where
-    N: Real,
+    N: RealField,
     C: TCategory,
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
         + Allocator<N, DimNameSum<D, U1>>
@@ -481,7 +481,7 @@ where
     }
 }
 
-impl<N: Real, D: DimNameAdd<U1>, C: TCategory> Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> Transform<N, D, C>
 where C: SubTCategoryOf<TProjective>,
       DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
         + Allocator<N, DimNameSum<D, U1>>
@@ -505,7 +505,7 @@ where C: SubTCategoryOf<TProjective>,
     }
 }
 
-impl<N: Real, D: DimNameAdd<U1>> Transform<N, D, TGeneral>
+impl<N: RealField, D: DimNameAdd<U1>> Transform<N, D, TGeneral>
 where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 {
     /// A mutable reference to underlying matrix. Use `.matrix_mut_unchecked` instead if this
@@ -516,7 +516,7 @@ where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
     }
 }
 
-impl<N: Real, D: DimNameAdd<U1>, C: TCategory> AbsDiffEq for Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> AbsDiffEq for Transform<N, D, C>
 where
     N::Epsilon: Copy,
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
@@ -534,7 +534,7 @@ where
     }
 }
 
-impl<N: Real, D: DimNameAdd<U1>, C: TCategory> RelativeEq for Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> RelativeEq for Transform<N, D, C>
 where
     N::Epsilon: Copy,
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
@@ -557,7 +557,7 @@ where
     }
 }
 
-impl<N: Real, D: DimNameAdd<U1>, C: TCategory> UlpsEq for Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> UlpsEq for Transform<N, D, C>
 where
     N::Epsilon: Copy,
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
@@ -576,7 +576,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use base::Matrix4;
+    use crate::base::Matrix4;
 
     #[test]
     fn checks_homogeneous_invariants_of_square_identity_matrix() {
diff --git a/src/geometry/transform_alga.rs b/src/geometry/transform_alga.rs
index d58b1d53b..ec3fd7c69 100755
--- a/src/geometry/transform_alga.rs
+++ b/src/geometry/transform_alga.rs
@@ -1,21 +1,21 @@
 use alga::general::{
     AbstractGroup, AbstractLoop, AbstractMagma, AbstractMonoid, AbstractQuasigroup,
-    AbstractSemigroup, Identity, TwoSidedInverse, Multiplicative, Real,
+    AbstractSemigroup, Identity, TwoSidedInverse, Multiplicative, RealField,
 };
 use alga::linear::{ProjectiveTransformation, Transformation};
 
-use base::allocator::Allocator;
-use base::dimension::{DimNameAdd, DimNameSum, U1};
-use base::{DefaultAllocator, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
+use crate::base::{DefaultAllocator, VectorN};
 
-use geometry::{Point, SubTCategoryOf, TCategory, TProjective, Transform};
+use crate::geometry::{Point, SubTCategoryOf, TCategory, TProjective, Transform};
 
 /*
  *
  * Algebraic structures.
  *
  */
-impl<N: Real, D: DimNameAdd<U1>, C> Identity<Multiplicative> for Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C> Identity<Multiplicative> for Transform<N, D, C>
 where
     C: TCategory,
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
@@ -26,7 +26,7 @@ where
     }
 }
 
-impl<N: Real, D: DimNameAdd<U1>, C> TwoSidedInverse<Multiplicative> for Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C> TwoSidedInverse<Multiplicative> for Transform<N, D, C>
 where
     C: SubTCategoryOf<TProjective>,
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
@@ -42,7 +42,7 @@ where
     }
 }
 
-impl<N: Real, D: DimNameAdd<U1>, C> AbstractMagma<Multiplicative> for Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C> AbstractMagma<Multiplicative> for Transform<N, D, C>
 where
     C: TCategory,
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
@@ -55,7 +55,7 @@ where
 
 macro_rules! impl_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: Real, D: DimNameAdd<U1>, C> $marker<$operator> for Transform<N, D, C>
+        impl<N: RealField, D: DimNameAdd<U1>, C> $marker<$operator> for Transform<N, D, C>
             where C: TCategory,
                   DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> { }
     )*}
@@ -63,7 +63,7 @@ macro_rules! impl_multiplicative_structures(
 
 macro_rules! impl_inversible_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: Real, D: DimNameAdd<U1>, C> $marker<$operator> for Transform<N, D, C>
+        impl<N: RealField, D: DimNameAdd<U1>, C> $marker<$operator> for Transform<N, D, C>
             where C: SubTCategoryOf<TProjective>,
                   DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> { }
     )*}
@@ -87,7 +87,7 @@ impl_inversible_multiplicative_structures!(
  */
 impl<N, D: DimNameAdd<U1>, C> Transformation<Point<N, D>> for Transform<N, D, C>
 where
-    N: Real,
+    N: RealField,
     C: TCategory,
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
         + Allocator<N, DimNameSum<D, U1>>
@@ -107,7 +107,7 @@ where
 
 impl<N, D: DimNameAdd<U1>, C> ProjectiveTransformation<Point<N, D>> for Transform<N, D, C>
 where
-    N: Real,
+    N: RealField,
     C: SubTCategoryOf<TProjective>,
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
         + Allocator<N, DimNameSum<D, U1>>
@@ -128,7 +128,7 @@ where
 // FIXME: we need to implement an SVD for this.
 //
 // impl<N, D: DimNameAdd<U1>, C> AffineTransformation<Point<N, D>> for Transform<N, D, C>
-//     where N:  Real,
+//     where N:  RealField,
 //           C: SubTCategoryOf<TAffine>,
 //           DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> +
 //                             Allocator<N, D, D> +
diff --git a/src/geometry/transform_alias.rs b/src/geometry/transform_alias.rs
index 6f529966f..1ccc5f95e 100644
--- a/src/geometry/transform_alias.rs
+++ b/src/geometry/transform_alias.rs
@@ -1,6 +1,6 @@
-use base::dimension::{U2, U3};
+use crate::base::dimension::{U2, U3};
 
-use geometry::{TAffine, TGeneral, TProjective, Transform};
+use crate::geometry::{TAffine, TGeneral, TProjective, Transform};
 
 /// A 2D general transformation that may not be invertible. Stored as an homogeneous 3x3 matrix.
 pub type Transform2<N> = Transform<N, U2, TGeneral>;
diff --git a/src/geometry/transform_construction.rs b/src/geometry/transform_construction.rs
index 3244ad8a6..1b23dabaa 100644
--- a/src/geometry/transform_construction.rs
+++ b/src/geometry/transform_construction.rs
@@ -1,14 +1,14 @@
 use num::One;
 
-use alga::general::Real;
+use alga::general::RealField;
 
-use base::allocator::Allocator;
-use base::dimension::{DimNameAdd, DimNameSum, U1};
-use base::{DefaultAllocator, MatrixN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
+use crate::base::{DefaultAllocator, MatrixN};
 
-use geometry::{TCategory, Transform};
+use crate::geometry::{TCategory, Transform};
 
-impl<N: Real, D: DimNameAdd<U1>, C: TCategory> Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> Transform<N, D, C>
 where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 {
     /// Creates a new identity transform.
@@ -45,7 +45,7 @@ where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
     }
 }
 
-impl<N: Real, D: DimNameAdd<U1>, C: TCategory> One for Transform<N, D, C>
+impl<N: RealField, D: DimNameAdd<U1>, C: TCategory> One for Transform<N, D, C>
 where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
 {
     /// Creates a new identity transform.
diff --git a/src/geometry/transform_conversion.rs b/src/geometry/transform_conversion.rs
index ab5ad5df7..a0e002916 100644
--- a/src/geometry/transform_conversion.rs
+++ b/src/geometry/transform_conversion.rs
@@ -1,15 +1,15 @@
-use alga::general::{Real, SubsetOf};
+use alga::general::{RealField, SubsetOf};
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use base::{DefaultAllocator, MatrixN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::{DefaultAllocator, MatrixN};
 
-use geometry::{SuperTCategoryOf, TCategory, Transform};
+use crate::geometry::{SuperTCategoryOf, TCategory, Transform};
 
 impl<N1, N2, D: DimName, C1, C2> SubsetOf<Transform<N2, D, C2>> for Transform<N1, D, C1>
 where
-    N1: Real + SubsetOf<N2>,
-    N2: Real,
+    N1: RealField + SubsetOf<N2>,
+    N2: RealField,
     C1: TCategory,
     C2: SuperTCategoryOf<C1>,
     D: DimNameAdd<U1>,
@@ -36,8 +36,8 @@ where
 
 impl<N1, N2, D: DimName, C> SubsetOf<MatrixN<N2, DimNameSum<D, U1>>> for Transform<N1, D, C>
 where
-    N1: Real + SubsetOf<N2>,
-    N2: Real,
+    N1: RealField + SubsetOf<N2>,
+    N2: RealField,
     C: TCategory,
     D: DimNameAdd<U1>,
     DefaultAllocator: Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>
@@ -57,11 +57,11 @@ where
 
     #[inline]
     unsafe fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self {
-        Self::from_matrix_unchecked(::convert_ref_unchecked(m))
+        Self::from_matrix_unchecked(crate::convert_ref_unchecked(m))
     }
 }
 
-impl<N: Real, D: DimName, C> From<Transform<N, D, C>> for MatrixN<N, DimNameSum<D, U1>>
+impl<N: RealField, D: DimName, C> From<Transform<N, D, C>> for MatrixN<N, DimNameSum<D, U1>>
 where
     D: DimNameAdd<U1>,
     C: TCategory,
diff --git a/src/geometry/transform_ops.rs b/src/geometry/transform_ops.rs
index 2ede5c602..4aa943e8f 100644
--- a/src/geometry/transform_ops.rs
+++ b/src/geometry/transform_ops.rs
@@ -1,13 +1,13 @@
 use num::{One, Zero};
 use std::ops::{Div, DivAssign, Index, IndexMut, Mul, MulAssign};
 
-use alga::general::{ClosedAdd, ClosedMul, Real, SubsetOf};
+use alga::general::{ClosedAdd, ClosedMul, RealField, SubsetOf};
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameAdd, DimNameSum, U1, U3, U4};
-use base::{DefaultAllocator, MatrixN, Scalar, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1, U3, U4};
+use crate::base::{DefaultAllocator, MatrixN, Scalar, VectorN};
 
-use geometry::{
+use crate::geometry::{
     Isometry, Point, Rotation, Similarity, SubTCategoryOf, SuperTCategoryOf, TAffine, TCategory,
     TCategoryMul, TGeneral, TProjective, Transform, Translation, UnitQuaternion,
 };
@@ -79,7 +79,7 @@ use geometry::{
  * Indexing.
  *
  */
-impl<N: Real, D, C: TCategory> Index<(usize, usize)> for Transform<N, D, C>
+impl<N: RealField, D, C: TCategory> Index<(usize, usize)> for Transform<N, D, C>
 where
     D: DimName + DimNameAdd<U1>,
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
@@ -93,7 +93,7 @@ where
 }
 
 // Only general transformations are mutably indexable.
-impl<N: Real, D> IndexMut<(usize, usize)> for Transform<N, D, TGeneral>
+impl<N: RealField, D> IndexMut<(usize, usize)> for Transform<N, D, TGeneral>
 where
     D: DimName + DimNameAdd<U1>,
     DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
@@ -106,7 +106,7 @@ where
 
 // Transform × Vector
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategory;
     self: Transform<N, D, C>, rhs: VectorN<N, D>, Output = VectorN<N, D>;
     [val val] => &self * &rhs;
@@ -130,7 +130,7 @@ md_impl_all!(
 
 // Transform × Point
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategory
     where DefaultAllocator: Allocator<N, D, D>;
     self: Transform<N, D, C>, rhs: Point<N, D>, Output = Point<N, D>;
@@ -156,7 +156,7 @@ md_impl_all!(
 
 // Transform × Transform
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (DimNameSum<D, U1>, DimNameSum<D, U1>) for D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: TCategory;
     self: Transform<N, D, CA>, rhs: Transform<N, D, CB>, Output = Transform<N, D, CA::Representative>;
     [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.into_inner());
@@ -167,7 +167,7 @@ md_impl_all!(
 
 // Transform × Rotation
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, D) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
     self: Transform<N, D, C>, rhs: Rotation<N, D>, Output = Transform<N, D, C::Representative>;
     [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
@@ -178,7 +178,7 @@ md_impl_all!(
 
 // Rotation × Transform
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (D, D), (DimNameSum<D, U1>, DimNameSum<D, U1>) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
     self: Rotation<N, D>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
     [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
@@ -189,7 +189,7 @@ md_impl_all!(
 
 // Transform × UnitQuaternion
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (U4, U4), (U4, U1) for C: TCategoryMul<TAffine>;
     self: Transform<N, U3, C>, rhs: UnitQuaternion<N>, Output = Transform<N, U3, C::Representative>;
     [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
@@ -200,7 +200,7 @@ md_impl_all!(
 
 // UnitQuaternion × Transform
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (U4, U1), (U4, U4) for C: TCategoryMul<TAffine>;
     self: UnitQuaternion<N>, rhs: Transform<N, U3, C>, Output = Transform<N, U3, C::Representative>;
     [val val] => Self::Output::from_matrix_unchecked(self.to_homogeneous() * rhs.into_inner());
@@ -211,7 +211,7 @@ md_impl_all!(
 
 // Transform × Isometry
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
     for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
     self: Transform<N, D, C>, rhs: Isometry<N, D, R>, Output = Transform<N, D, C::Representative>;
@@ -223,7 +223,7 @@ md_impl_all!(
 
 // Isometry × Transform
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
     for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
     self: Isometry<N, D, R>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
@@ -235,7 +235,7 @@ md_impl_all!(
 
 // Transform × Similarity
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
     for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
     self: Transform<N, D, C>, rhs: Similarity<N, D, R>, Output = Transform<N, D, C::Representative>;
@@ -247,7 +247,7 @@ md_impl_all!(
 
 // Similarity × Transform
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
     for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
     self: Similarity<N, D, R>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
@@ -267,7 +267,7 @@ md_impl_all!(
  */
 // Transform × Translation
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
     self: Transform<N, D, C>, rhs: Translation<N, D>, Output = Transform<N, D, C::Representative>;
     [val val] => Self::Output::from_matrix_unchecked(self.into_inner() * rhs.to_homogeneous());
@@ -278,7 +278,7 @@ md_impl_all!(
 
 // Translation × Transform
 md_impl_all!(
-    Mul, mul where N: Real;
+    Mul, mul where N: RealField;
     (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
     for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
     self: Translation<N, D>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
@@ -290,7 +290,7 @@ md_impl_all!(
 
 // Transform ÷ Transform
 md_impl_all!(
-    Div, div where N: Real;
+    Div, div where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (DimNameSum<D, U1>, DimNameSum<D, U1>) for D: DimNameAdd<U1>, CA: TCategoryMul<CB>, CB: SubTCategoryOf<TProjective>;
     self: Transform<N, D, CA>, rhs: Transform<N, D, CB>, Output = Transform<N, D, CA::Representative>;
     [val val] => self * rhs.inverse();
@@ -301,7 +301,7 @@ md_impl_all!(
 
 // Transform ÷ Rotation
 md_impl_all!(
-    Div, div where N: Real;
+    Div, div where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, D) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
     self: Transform<N, D, C>, rhs: Rotation<N, D>, Output = Transform<N, D, C::Representative>;
     [val val] => self * rhs.inverse();
@@ -312,7 +312,7 @@ md_impl_all!(
 
 // Rotation ÷ Transform
 md_impl_all!(
-    Div, div where N: Real;
+    Div, div where N: RealField;
     (D, D), (DimNameSum<D, U1>, DimNameSum<D, U1>) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
     self: Rotation<N, D>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
     [val val] => self.inverse() * rhs;
@@ -323,7 +323,7 @@ md_impl_all!(
 
 // Transform ÷ UnitQuaternion
 md_impl_all!(
-    Div, div where N: Real;
+    Div, div where N: RealField;
     (U4, U4), (U4, U1) for C: TCategoryMul<TAffine>;
     self: Transform<N, U3, C>, rhs: UnitQuaternion<N>, Output = Transform<N, U3, C::Representative>;
     [val val] => self * rhs.inverse();
@@ -334,7 +334,7 @@ md_impl_all!(
 
 // UnitQuaternion ÷ Transform
 md_impl_all!(
-    Div, div where N: Real;
+    Div, div where N: RealField;
     (U4, U1), (U4, U4) for C: TCategoryMul<TAffine>;
     self: UnitQuaternion<N>, rhs: Transform<N, U3, C>, Output = Transform<N, U3, C::Representative>;
     [val val] => self.inverse() * rhs;
@@ -345,7 +345,7 @@ md_impl_all!(
 
 //      // Transform ÷ Isometry
 //      md_impl_all!(
-//          Div, div where N: Real;
+//          Div, div where N: RealField;
 //          (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
 //          for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >
 //          where SB::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1> >;
@@ -358,7 +358,7 @@ md_impl_all!(
 
 //      // Isometry ÷ Transform
 //      md_impl_all!(
-//          Div, div where N: Real;
+//          Div, div where N: RealField;
 //          (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
 //          for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >
 //          where SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1> >;
@@ -371,7 +371,7 @@ md_impl_all!(
 
 //      // Transform ÷ Similarity
 //      md_impl_all!(
-//          Div, div where N: Real;
+//          Div, div where N: RealField;
 //          (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
 //          for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >
 //          where SB::Alloc: Allocator<N, D, D >
@@ -385,7 +385,7 @@ md_impl_all!(
 
 //      // Similarity ÷ Transform
 //      md_impl_all!(
-//          Div, div where N: Real;
+//          Div, div where N: RealField;
 //          (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
 //          for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >
 //          where SA::Alloc: Allocator<N, D, D >
@@ -399,7 +399,7 @@ md_impl_all!(
 
 // Transform ÷ Translation
 md_impl_all!(
-    Div, div where N: Real;
+    Div, div where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
     self: Transform<N, D, C>, rhs: Translation<N, D>, Output = Transform<N, D, C::Representative>;
     [val val] => self * rhs.inverse();
@@ -410,7 +410,7 @@ md_impl_all!(
 
 // Translation ÷ Transform
 md_impl_all!(
-    Div, div where N: Real;
+    Div, div where N: RealField;
     (D, U1), (DimNameSum<D, U1>, DimNameSum<D, U1>)
     for D: DimNameAdd<U1>, C: TCategoryMul<TAffine>;
     self: Translation<N, D>, rhs: Transform<N, D, C>, Output = Transform<N, D, C::Representative>;
@@ -422,7 +422,7 @@ md_impl_all!(
 
 // Transform ×= Transform
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: Real;
+    MulAssign, mul_assign where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (DimNameSum<D, U1>, DimNameSum<D, U1>) for D: DimNameAdd<U1>, CA: TCategory, CB: SubTCategoryOf<CA>;
     self: Transform<N, D, CA>, rhs: Transform<N, D, CB>;
     [val] => *self.matrix_mut_unchecked() *= rhs.into_inner();
@@ -431,7 +431,7 @@ md_assign_impl_all!(
 
 // Transform ×= Similarity
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: Real;
+    MulAssign, mul_assign where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
     for D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
     self: Transform<N, D, C>, rhs: Similarity<N, D, R>;
@@ -441,7 +441,7 @@ md_assign_impl_all!(
 
 // Transform ×= Isometry
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: Real;
+    MulAssign, mul_assign where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1)
     for D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>> >;
     self: Transform<N, D, C>, rhs: Isometry<N, D, R>;
@@ -459,7 +459,7 @@ md_assign_impl_all!(
  */
 // Transform ×= Translation
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: Real;
+    MulAssign, mul_assign where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategory;
     self: Transform<N, D, C>, rhs: Translation<N, D>;
     [val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
@@ -468,7 +468,7 @@ md_assign_impl_all!(
 
 // Transform ×= Rotation
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: Real;
+    MulAssign, mul_assign where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, D) for D: DimNameAdd<U1>, C: TCategory;
     self: Transform<N, D, C>, rhs: Rotation<N, D>;
     [val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
@@ -477,7 +477,7 @@ md_assign_impl_all!(
 
 // Transform ×= UnitQuaternion
 md_assign_impl_all!(
-    MulAssign, mul_assign where N: Real;
+    MulAssign, mul_assign where N: RealField;
     (U4, U4), (U4, U1) for C: TCategory;
     self: Transform<N, U3, C>, rhs: UnitQuaternion<N>;
     [val] => *self.matrix_mut_unchecked() *= rhs.to_homogeneous();
@@ -486,7 +486,7 @@ md_assign_impl_all!(
 
 // Transform ÷= Transform
 md_assign_impl_all!(
-    DivAssign, div_assign where N: Real;
+    DivAssign, div_assign where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (DimNameSum<D, U1>, DimNameSum<D, U1>)
     for D: DimNameAdd<U1>, CA: SuperTCategoryOf<CB>, CB: SubTCategoryOf<TProjective>;
     self: Transform<N, D, CA>, rhs: Transform<N, D, CB>;
@@ -517,7 +517,7 @@ md_assign_impl_all!(
 
 // Transform ÷= Translation
 md_assign_impl_all!(
-    DivAssign, div_assign where N: Real;
+    DivAssign, div_assign where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, U1) for D: DimNameAdd<U1>, C: TCategory;
     self: Transform<N, D, C>, rhs: Translation<N, D>;
     [val] => *self *= rhs.inverse();
@@ -526,7 +526,7 @@ md_assign_impl_all!(
 
 // Transform ÷= Rotation
 md_assign_impl_all!(
-    DivAssign, div_assign where N: Real;
+    DivAssign, div_assign where N: RealField;
     (DimNameSum<D, U1>, DimNameSum<D, U1>), (D, D) for D: DimNameAdd<U1>, C: TCategory;
     self: Transform<N, D, C>, rhs: Rotation<N, D>;
     [val] => *self *= rhs.inverse();
@@ -535,7 +535,7 @@ md_assign_impl_all!(
 
 // Transform ÷= UnitQuaternion
 md_assign_impl_all!(
-    DivAssign, div_assign where N: Real;
+    DivAssign, div_assign where N: RealField;
     (U4, U4), (U4, U1) for C: TCategory;
     self: Transform<N, U3, C>, rhs: UnitQuaternion<N>;
     [val] => *self *= rhs.inverse();
diff --git a/src/geometry/translation.rs b/src/geometry/translation.rs
index a49b2706f..e64b3d2ea 100755
--- a/src/geometry/translation.rs
+++ b/src/geometry/translation.rs
@@ -11,14 +11,14 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
-use alga::general::{ClosedAdd, ClosedNeg, ClosedSub, Real};
+use alga::general::{ClosedAdd, ClosedNeg, ClosedSub, RealField};
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use base::storage::Owned;
-use base::{DefaultAllocator, MatrixN, Scalar, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::storage::Owned;
+use crate::base::{DefaultAllocator, MatrixN, Scalar, VectorN};
 
-use geometry::Point;
+use crate::geometry::Point;
 
 /// A translation.
 #[repr(C)]
@@ -301,14 +301,14 @@ where
  * Display
  *
  */
-impl<N: Real + fmt::Display, D: DimName> fmt::Display for Translation<N, D>
+impl<N: RealField + fmt::Display, D: DimName> fmt::Display for Translation<N, D>
 where DefaultAllocator: Allocator<N, D> + Allocator<usize, D>
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let precision = f.precision().unwrap_or(3);
 
-        try!(writeln!(f, "Translation {{"));
-        try!(write!(f, "{:.*}", precision, self.vector));
+        writeln!(f, "Translation {{")?;
+        write!(f, "{:.*}", precision, self.vector)?;
         writeln!(f, "}}")
     }
 }
diff --git a/src/geometry/translation_alga.rs b/src/geometry/translation_alga.rs
index c6157a170..134790f68 100755
--- a/src/geometry/translation_alga.rs
+++ b/src/geometry/translation_alga.rs
@@ -1,6 +1,6 @@
 use alga::general::{
     AbstractGroup, AbstractLoop, AbstractMagma, AbstractMonoid, AbstractQuasigroup,
-    AbstractSemigroup, Id, Identity, TwoSidedInverse, Multiplicative, Real,
+    AbstractSemigroup, Id, Identity, TwoSidedInverse, Multiplicative, RealField,
 };
 use alga::linear::Translation as AlgaTranslation;
 use alga::linear::{
@@ -8,18 +8,18 @@ use alga::linear::{
     Transformation,
 };
 
-use base::allocator::Allocator;
-use base::dimension::DimName;
-use base::{DefaultAllocator, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::DimName;
+use crate::base::{DefaultAllocator, VectorN};
 
-use geometry::{Point, Translation};
+use crate::geometry::{Point, Translation};
 
 /*
  *
  * Algebraic structures.
  *
  */
-impl<N: Real, D: DimName> Identity<Multiplicative> for Translation<N, D>
+impl<N: RealField, D: DimName> Identity<Multiplicative> for Translation<N, D>
 where DefaultAllocator: Allocator<N, D>
 {
     #[inline]
@@ -28,7 +28,7 @@ where DefaultAllocator: Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName> TwoSidedInverse<Multiplicative> for Translation<N, D>
+impl<N: RealField, D: DimName> TwoSidedInverse<Multiplicative> for Translation<N, D>
 where DefaultAllocator: Allocator<N, D>
 {
     #[inline]
@@ -42,7 +42,7 @@ where DefaultAllocator: Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName> AbstractMagma<Multiplicative> for Translation<N, D>
+impl<N: RealField, D: DimName> AbstractMagma<Multiplicative> for Translation<N, D>
 where DefaultAllocator: Allocator<N, D>
 {
     #[inline]
@@ -53,7 +53,7 @@ where DefaultAllocator: Allocator<N, D>
 
 macro_rules! impl_multiplicative_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: Real, D: DimName> $marker<$operator> for Translation<N, D>
+        impl<N: RealField, D: DimName> $marker<$operator> for Translation<N, D>
             where DefaultAllocator: Allocator<N, D> { }
     )*}
 );
@@ -71,7 +71,7 @@ impl_multiplicative_structures!(
  * Transformation groups.
  *
  */
-impl<N: Real, D: DimName> Transformation<Point<N, D>> for Translation<N, D>
+impl<N: RealField, D: DimName> Transformation<Point<N, D>> for Translation<N, D>
 where DefaultAllocator: Allocator<N, D>
 {
     #[inline]
@@ -85,7 +85,7 @@ where DefaultAllocator: Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName> ProjectiveTransformation<Point<N, D>> for Translation<N, D>
+impl<N: RealField, D: DimName> ProjectiveTransformation<Point<N, D>> for Translation<N, D>
 where DefaultAllocator: Allocator<N, D>
 {
     #[inline]
@@ -99,7 +99,7 @@ where DefaultAllocator: Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName> AffineTransformation<Point<N, D>> for Translation<N, D>
+impl<N: RealField, D: DimName> AffineTransformation<Point<N, D>> for Translation<N, D>
 where DefaultAllocator: Allocator<N, D>
 {
     type Rotation = Id;
@@ -142,7 +142,7 @@ where DefaultAllocator: Allocator<N, D>
     }
 }
 
-impl<N: Real, D: DimName> Similarity<Point<N, D>> for Translation<N, D>
+impl<N: RealField, D: DimName> Similarity<Point<N, D>> for Translation<N, D>
 where DefaultAllocator: Allocator<N, D>
 {
     type Scaling = Id;
@@ -165,7 +165,7 @@ where DefaultAllocator: Allocator<N, D>
 
 macro_rules! marker_impl(
     ($($Trait: ident),*) => {$(
-        impl<N: Real, D: DimName> $Trait<Point<N, D>> for Translation<N, D>
+        impl<N: RealField, D: DimName> $Trait<Point<N, D>> for Translation<N, D>
             where DefaultAllocator: Allocator<N, D> { }
     )*}
 );
@@ -173,7 +173,7 @@ macro_rules! marker_impl(
 marker_impl!(Isometry, DirectIsometry);
 
 /// Subgroups of the n-dimensional translation group `T(n)`.
-impl<N: Real, D: DimName> AlgaTranslation<Point<N, D>> for Translation<N, D>
+impl<N: RealField, D: DimName> AlgaTranslation<Point<N, D>> for Translation<N, D>
 where DefaultAllocator: Allocator<N, D>
 {
     #[inline]
diff --git a/src/geometry/translation_alias.rs b/src/geometry/translation_alias.rs
index 41885db7e..13db0495a 100644
--- a/src/geometry/translation_alias.rs
+++ b/src/geometry/translation_alias.rs
@@ -1,6 +1,6 @@
-use base::dimension::{U1, U2, U3, U4, U5, U6};
+use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
 
-use geometry::Translation;
+use crate::geometry::Translation;
 
 /// A 1-dimensional translation.
 pub type Translation1<N> = Translation<N, U1>;
diff --git a/src/geometry/translation_construction.rs b/src/geometry/translation_construction.rs
index a973603d9..339bdd2a6 100644
--- a/src/geometry/translation_construction.rs
+++ b/src/geometry/translation_construction.rs
@@ -1,5 +1,5 @@
 #[cfg(feature = "arbitrary")]
-use base::storage::Owned;
+use crate::base::storage::Owned;
 #[cfg(feature = "arbitrary")]
 use quickcheck::{Arbitrary, Gen};
 
@@ -9,11 +9,11 @@ use rand::Rng;
 
 use alga::general::ClosedAdd;
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, U1, U2, U3, U4, U5, U6};
-use base::{DefaultAllocator, Scalar, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, U1, U2, U3, U4, U5, U6};
+use crate::base::{DefaultAllocator, Scalar, VectorN};
 
-use geometry::Translation;
+use crate::geometry::Translation;
 
 impl<N: Scalar + Zero, D: DimName> Translation<N, D>
 where DefaultAllocator: Allocator<N, D>
diff --git a/src/geometry/translation_conversion.rs b/src/geometry/translation_conversion.rs
index d4fd9df2c..b44412e69 100644
--- a/src/geometry/translation_conversion.rs
+++ b/src/geometry/translation_conversion.rs
@@ -1,13 +1,13 @@
 use num::{One, Zero};
 
-use alga::general::{Real, SubsetOf, SupersetOf};
+use alga::general::{RealField, SubsetOf, SupersetOf};
 use alga::linear::Rotation;
 
-use base::allocator::Allocator;
-use base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
-use base::{DefaultAllocator, MatrixN, Scalar, VectorN};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
+use crate::base::{DefaultAllocator, MatrixN, Scalar, VectorN};
 
-use geometry::{Isometry, Point, Similarity, SuperTCategoryOf, TAffine, Transform, Translation};
+use crate::geometry::{Isometry, Point, Similarity, SuperTCategoryOf, TAffine, Transform, Translation};
 
 /*
  * This file provides the following conversions:
@@ -33,7 +33,7 @@ where
 
     #[inline]
     fn is_in_subset(rot: &Translation<N2, D>) -> bool {
-        ::is_convertible::<_, VectorN<N1, D>>(&rot.vector)
+        crate::is_convertible::<_, VectorN<N1, D>>(&rot.vector)
     }
 
     #[inline]
@@ -46,8 +46,8 @@ where
 
 impl<N1, N2, D: DimName, R> SubsetOf<Isometry<N2, D, R>> for Translation<N1, D>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R: Rotation<Point<N2, D>>,
     DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
 {
@@ -69,8 +69,8 @@ where
 
 impl<N1, N2, D: DimName, R> SubsetOf<Similarity<N2, D, R>> for Translation<N1, D>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R: Rotation<Point<N2, D>>,
     DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
 {
@@ -92,8 +92,8 @@ where
 
 impl<N1, N2, D, C> SubsetOf<Transform<N2, D, C>> for Translation<N1, D>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     C: SuperTCategoryOf<TAffine>,
     D: DimNameAdd<U1>,
     DefaultAllocator: Allocator<N1, D>
@@ -119,8 +119,8 @@ where
 
 impl<N1, N2, D> SubsetOf<MatrixN<N2, DimNameSum<D, U1>>> for Translation<N1, D>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     D: DimNameAdd<U1>,
     DefaultAllocator: Allocator<N1, D>
         + Allocator<N2, D>
@@ -148,7 +148,7 @@ where
     unsafe fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self {
         let t = m.fixed_slice::<D, U1>(0, D::dim());
         Self {
-            vector: ::convert_unchecked(t.into_owned()),
+            vector: crate::convert_unchecked(t.into_owned()),
         }
     }
 }
diff --git a/src/geometry/translation_coordinates.rs b/src/geometry/translation_coordinates.rs
index 01207a32e..c422415c5 100644
--- a/src/geometry/translation_coordinates.rs
+++ b/src/geometry/translation_coordinates.rs
@@ -1,12 +1,12 @@
 use std::mem;
 use std::ops::{Deref, DerefMut};
 
-use base::allocator::Allocator;
-use base::coordinates::{X, XY, XYZ, XYZW, XYZWA, XYZWAB};
-use base::dimension::{U1, U2, U3, U4, U5, U6};
-use base::{DefaultAllocator, Scalar};
+use crate::base::allocator::Allocator;
+use crate::base::coordinates::{X, XY, XYZ, XYZW, XYZWA, XYZWAB};
+use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
+use crate::base::{DefaultAllocator, Scalar};
 
-use geometry::Translation;
+use crate::geometry::Translation;
 
 /*
  *
diff --git a/src/geometry/translation_ops.rs b/src/geometry/translation_ops.rs
index 57b8d6d16..55366a057 100644
--- a/src/geometry/translation_ops.rs
+++ b/src/geometry/translation_ops.rs
@@ -2,12 +2,12 @@ use std::ops::{Div, DivAssign, Mul, MulAssign};
 
 use alga::general::{ClosedAdd, ClosedSub};
 
-use base::allocator::{Allocator, SameShapeAllocator};
-use base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
-use base::dimension::{DimName, U1};
-use base::{DefaultAllocator, Scalar};
+use crate::base::allocator::{Allocator, SameShapeAllocator};
+use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
+use crate::base::dimension::{DimName, U1};
+use crate::base::{DefaultAllocator, Scalar};
 
-use geometry::{Point, Translation};
+use crate::geometry::{Point, Translation};
 
 // Translation × Translation
 add_sub_impl!(Mul, mul, ClosedAdd;
diff --git a/src/geometry/unit_complex.rs b/src/geometry/unit_complex.rs
index a54626e0d..7ba7f3740 100755
--- a/src/geometry/unit_complex.rs
+++ b/src/geometry/unit_complex.rs
@@ -2,14 +2,14 @@ use approx::{AbsDiffEq, RelativeEq, UlpsEq};
 use num_complex::Complex;
 use std::fmt;
 
-use alga::general::Real;
-use base::{Matrix2, Matrix3, Unit, Vector1, Vector2};
-use geometry::{Rotation2, Point2};
+use alga::general::RealField;
+use crate::base::{Matrix2, Matrix3, Unit, Vector1, Vector2};
+use crate::geometry::{Rotation2, Point2};
 
 /// A complex number with a norm equal to 1.
 pub type UnitComplex<N> = Unit<Complex<N>>;
 
-impl<N: Real> UnitComplex<N> {
+impl<N: RealField> UnitComplex<N> {
     /// The rotation angle in `]-pi; pi]` of this unit complex number.
     ///
     /// # Example
@@ -323,13 +323,13 @@ impl<N: Real> UnitComplex<N> {
     }
 }
 
-impl<N: Real + fmt::Display> fmt::Display for UnitComplex<N> {
+impl<N: RealField + fmt::Display> fmt::Display for UnitComplex<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "UnitComplex angle: {}", self.angle())
     }
 }
 
-impl<N: Real> AbsDiffEq for UnitComplex<N> {
+impl<N: RealField> AbsDiffEq for UnitComplex<N> {
     type Epsilon = N;
 
     #[inline]
@@ -343,7 +343,7 @@ impl<N: Real> AbsDiffEq for UnitComplex<N> {
     }
 }
 
-impl<N: Real> RelativeEq for UnitComplex<N> {
+impl<N: RealField> RelativeEq for UnitComplex<N> {
     #[inline]
     fn default_max_relative() -> Self::Epsilon {
         N::default_max_relative()
@@ -362,7 +362,7 @@ impl<N: Real> RelativeEq for UnitComplex<N> {
     }
 }
 
-impl<N: Real> UlpsEq for UnitComplex<N> {
+impl<N: RealField> UlpsEq for UnitComplex<N> {
     #[inline]
     fn default_max_ulps() -> u32 {
         N::default_max_ulps()
diff --git a/src/geometry/unit_complex_alga.rs b/src/geometry/unit_complex_alga.rs
index a52ea4e86..24b552339 100755
--- a/src/geometry/unit_complex_alga.rs
+++ b/src/geometry/unit_complex_alga.rs
@@ -1,37 +1,37 @@
 use alga::general::{
     AbstractGroup, AbstractLoop, AbstractMagma, AbstractMonoid, AbstractQuasigroup,
-    AbstractSemigroup, Id, Identity, TwoSidedInverse, Multiplicative, Real,
+    AbstractSemigroup, Id, Identity, TwoSidedInverse, Multiplicative, RealField,
 };
 use alga::linear::{
     AffineTransformation, DirectIsometry, Isometry, OrthogonalTransformation,
     ProjectiveTransformation, Rotation, Similarity, Transformation,
 };
 
-use base::allocator::Allocator;
-use base::dimension::U2;
-use base::{DefaultAllocator, Vector2};
-use geometry::{Point2, UnitComplex};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::U2;
+use crate::base::{DefaultAllocator, Vector2};
+use crate::geometry::{Point2, UnitComplex};
 
 /*
  *
  * Implementations for UnitComplex.
  *
  */
-impl<N: Real> Identity<Multiplicative> for UnitComplex<N> {
+impl<N: RealField> Identity<Multiplicative> for UnitComplex<N> {
     #[inline]
     fn identity() -> Self {
         Self::identity()
     }
 }
 
-impl<N: Real> AbstractMagma<Multiplicative> for UnitComplex<N> {
+impl<N: RealField> AbstractMagma<Multiplicative> for UnitComplex<N> {
     #[inline]
     fn operate(&self, rhs: &Self) -> Self {
         self * rhs
     }
 }
 
-impl<N: Real> TwoSidedInverse<Multiplicative> for UnitComplex<N> {
+impl<N: RealField> TwoSidedInverse<Multiplicative> for UnitComplex<N> {
     #[inline]
     fn two_sided_inverse(&self) -> Self {
         self.inverse()
@@ -45,7 +45,7 @@ impl<N: Real> TwoSidedInverse<Multiplicative> for UnitComplex<N> {
 
 macro_rules! impl_structures(
     ($($marker: ident<$operator: ident>),* $(,)*) => {$(
-        impl<N: Real> $marker<$operator> for UnitComplex<N> {
+        impl<N: RealField> $marker<$operator> for UnitComplex<N> {
         }
     )*}
 );
@@ -58,7 +58,7 @@ impl_structures!(
     AbstractGroup<Multiplicative>
 );
 
-impl<N: Real> Transformation<Point2<N>> for UnitComplex<N>
+impl<N: RealField> Transformation<Point2<N>> for UnitComplex<N>
 where DefaultAllocator: Allocator<N, U2>
 {
     #[inline]
@@ -72,7 +72,7 @@ where DefaultAllocator: Allocator<N, U2>
     }
 }
 
-impl<N: Real> ProjectiveTransformation<Point2<N>> for UnitComplex<N>
+impl<N: RealField> ProjectiveTransformation<Point2<N>> for UnitComplex<N>
 where DefaultAllocator: Allocator<N, U2>
 {
     #[inline]
@@ -86,7 +86,7 @@ where DefaultAllocator: Allocator<N, U2>
     }
 }
 
-impl<N: Real> AffineTransformation<Point2<N>> for UnitComplex<N>
+impl<N: RealField> AffineTransformation<Point2<N>> for UnitComplex<N>
 where DefaultAllocator: Allocator<N, U2>
 {
     type Rotation = Self;
@@ -129,7 +129,7 @@ where DefaultAllocator: Allocator<N, U2>
     }
 }
 
-impl<N: Real> Similarity<Point2<N>> for UnitComplex<N>
+impl<N: RealField> Similarity<Point2<N>> for UnitComplex<N>
 where DefaultAllocator: Allocator<N, U2>
 {
     type Scaling = Id;
@@ -152,14 +152,14 @@ where DefaultAllocator: Allocator<N, U2>
 
 macro_rules! marker_impl(
     ($($Trait: ident),*) => {$(
-        impl<N: Real> $Trait<Point2<N>> for UnitComplex<N>
+        impl<N: RealField> $Trait<Point2<N>> for UnitComplex<N>
         where DefaultAllocator: Allocator<N, U2> { }
     )*}
 );
 
 marker_impl!(Isometry, DirectIsometry, OrthogonalTransformation);
 
-impl<N: Real> Rotation<Point2<N>> for UnitComplex<N>
+impl<N: RealField> Rotation<Point2<N>> for UnitComplex<N>
 where DefaultAllocator: Allocator<N, U2>
 {
     #[inline]
diff --git a/src/geometry/unit_complex_construction.rs b/src/geometry/unit_complex_construction.rs
index ba1d6694b..046142c8a 100644
--- a/src/geometry/unit_complex_construction.rs
+++ b/src/geometry/unit_complex_construction.rs
@@ -6,13 +6,13 @@ use num_complex::Complex;
 use rand::distributions::{Distribution, OpenClosed01, Standard};
 use rand::Rng;
 
-use alga::general::Real;
-use base::dimension::{U1, U2};
-use base::storage::Storage;
-use base::{Unit, Vector, Matrix2};
-use geometry::{Rotation2, UnitComplex};
+use alga::general::RealField;
+use crate::base::dimension::{U1, U2};
+use crate::base::storage::Storage;
+use crate::base::{Unit, Vector, Matrix2};
+use crate::geometry::{Rotation2, UnitComplex};
 
-impl<N: Real> UnitComplex<N> {
+impl<N: RealField> UnitComplex<N> {
     /// The unit complex number multiplicative identity.
     ///
     /// # Example
@@ -268,14 +268,14 @@ impl<N: Real> UnitComplex<N> {
     }
 }
 
-impl<N: Real> One for UnitComplex<N> {
+impl<N: RealField> One for UnitComplex<N> {
     #[inline]
     fn one() -> Self {
         Self::identity()
     }
 }
 
-impl<N: Real> Distribution<UnitComplex<N>> for Standard
+impl<N: RealField> Distribution<UnitComplex<N>> for Standard
 where OpenClosed01: Distribution<N>
 {
     /// Generate a uniformly distributed random `UnitComplex`.
@@ -286,7 +286,7 @@ where OpenClosed01: Distribution<N>
 }
 
 #[cfg(feature = "arbitrary")]
-impl<N: Real + Arbitrary> Arbitrary for UnitComplex<N> {
+impl<N: RealField + Arbitrary> Arbitrary for UnitComplex<N> {
     #[inline]
     fn arbitrary<G: Gen>(g: &mut G) -> Self {
         UnitComplex::from_angle(N::arbitrary(g))
diff --git a/src/geometry/unit_complex_conversion.rs b/src/geometry/unit_complex_conversion.rs
index 1751a67cb..f7fe45321 100644
--- a/src/geometry/unit_complex_conversion.rs
+++ b/src/geometry/unit_complex_conversion.rs
@@ -1,12 +1,12 @@
 use num::Zero;
 use num_complex::Complex;
 
-use alga::general::{Real, SubsetOf, SupersetOf};
+use alga::general::{RealField, SubsetOf, SupersetOf};
 use alga::linear::Rotation as AlgaRotation;
 
-use base::dimension::U2;
-use base::{Matrix2, Matrix3};
-use geometry::{
+use crate::base::dimension::U2;
+use crate::base::{Matrix2, Matrix3};
+use crate::geometry::{
     Isometry, Point2, Rotation2, Similarity, SuperTCategoryOf, TAffine, Transform, Translation,
     UnitComplex
 };
@@ -28,8 +28,8 @@ use geometry::{
 
 impl<N1, N2> SubsetOf<UnitComplex<N2>> for UnitComplex<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
 {
     #[inline]
     fn to_superset(&self) -> UnitComplex<N2> {
@@ -38,19 +38,19 @@ where
 
     #[inline]
     fn is_in_subset(uq: &UnitComplex<N2>) -> bool {
-        ::is_convertible::<_, Complex<N1>>(uq.as_ref())
+        crate::is_convertible::<_, Complex<N1>>(uq.as_ref())
     }
 
     #[inline]
     unsafe fn from_superset_unchecked(uq: &UnitComplex<N2>) -> Self {
-        Self::new_unchecked(::convert_ref_unchecked(uq.as_ref()))
+        Self::new_unchecked(crate::convert_ref_unchecked(uq.as_ref()))
     }
 }
 
 impl<N1, N2> SubsetOf<Rotation2<N2>> for UnitComplex<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
 {
     #[inline]
     fn to_superset(&self) -> Rotation2<N2> {
@@ -60,25 +60,25 @@ where
 
     #[inline]
     fn is_in_subset(rot: &Rotation2<N2>) -> bool {
-        ::is_convertible::<_, Rotation2<N1>>(rot)
+        crate::is_convertible::<_, Rotation2<N1>>(rot)
     }
 
     #[inline]
     unsafe fn from_superset_unchecked(rot: &Rotation2<N2>) -> Self {
         let q = UnitComplex::<N2>::from_rotation_matrix(rot);
-        ::convert_unchecked(q)
+        crate::convert_unchecked(q)
     }
 }
 
 impl<N1, N2, R> SubsetOf<Isometry<N2, U2, R>> for UnitComplex<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R: AlgaRotation<Point2<N2>> + SupersetOf<Self>,
 {
     #[inline]
     fn to_superset(&self) -> Isometry<N2, U2, R> {
-        Isometry::from_parts(Translation::identity(), ::convert_ref(self))
+        Isometry::from_parts(Translation::identity(), crate::convert_ref(self))
     }
 
     #[inline]
@@ -88,19 +88,19 @@ where
 
     #[inline]
     unsafe fn from_superset_unchecked(iso: &Isometry<N2, U2, R>) -> Self {
-        ::convert_ref_unchecked(&iso.rotation)
+        crate::convert_ref_unchecked(&iso.rotation)
     }
 }
 
 impl<N1, N2, R> SubsetOf<Similarity<N2, U2, R>> for UnitComplex<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     R: AlgaRotation<Point2<N2>> + SupersetOf<Self>,
 {
     #[inline]
     fn to_superset(&self) -> Similarity<N2, U2, R> {
-        Similarity::from_isometry(::convert_ref(self), N2::one())
+        Similarity::from_isometry(crate::convert_ref(self), N2::one())
     }
 
     #[inline]
@@ -110,14 +110,14 @@ where
 
     #[inline]
     unsafe fn from_superset_unchecked(sim: &Similarity<N2, U2, R>) -> Self {
-        ::convert_ref_unchecked(&sim.isometry)
+        crate::convert_ref_unchecked(&sim.isometry)
     }
 }
 
 impl<N1, N2, C> SubsetOf<Transform<N2, U2, C>> for UnitComplex<N1>
 where
-    N1: Real,
-    N2: Real + SupersetOf<N1>,
+    N1: RealField,
+    N2: RealField + SupersetOf<N1>,
     C: SuperTCategoryOf<TAffine>,
 {
     #[inline]
@@ -136,7 +136,7 @@ where
     }
 }
 
-impl<N1: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix3<N2>> for UnitComplex<N1> {
+impl<N1: RealField, N2: RealField + SupersetOf<N1>> SubsetOf<Matrix3<N2>> for UnitComplex<N1> {
     #[inline]
     fn to_superset(&self) -> Matrix3<N2> {
         self.to_homogeneous().to_superset()
@@ -144,39 +144,39 @@ impl<N1: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix3<N2>> for UnitComplex<
 
     #[inline]
     fn is_in_subset(m: &Matrix3<N2>) -> bool {
-        ::is_convertible::<_, Rotation2<N1>>(m)
+        crate::is_convertible::<_, Rotation2<N1>>(m)
     }
 
     #[inline]
     unsafe fn from_superset_unchecked(m: &Matrix3<N2>) -> Self {
-        let rot: Rotation2<N1> = ::convert_ref_unchecked(m);
+        let rot: Rotation2<N1> = crate::convert_ref_unchecked(m);
         Self::from_rotation_matrix(&rot)
     }
 }
 
 
-impl<N: Real> From<UnitComplex<N>> for Rotation2<N> {
+impl<N: RealField> From<UnitComplex<N>> for Rotation2<N> {
     #[inline]
     fn from(q: UnitComplex<N>) -> Self {
         q.to_rotation_matrix()
     }
 }
 
-impl<N: Real> From<Rotation2<N>> for UnitComplex<N> {
+impl<N: RealField> From<Rotation2<N>> for UnitComplex<N> {
     #[inline]
     fn from(q: Rotation2<N>) -> Self {
         Self::from_rotation_matrix(&q)
     }
 }
 
-impl<N: Real> From<UnitComplex<N>> for Matrix3<N> {
+impl<N: RealField> From<UnitComplex<N>> for Matrix3<N> {
     #[inline]
     fn from(q: UnitComplex<N>) -> Matrix3<N> {
         q.to_homogeneous()
     }
 }
 
-impl<N: Real> From<UnitComplex<N>> for Matrix2<N> {
+impl<N: RealField> From<UnitComplex<N>> for Matrix2<N> {
     #[inline]
     fn from(q: UnitComplex<N>) -> Self {
         q.to_rotation_matrix().into_inner()
diff --git a/src/geometry/unit_complex_ops.rs b/src/geometry/unit_complex_ops.rs
index 75b45eda0..11ffdc4af 100644
--- a/src/geometry/unit_complex_ops.rs
+++ b/src/geometry/unit_complex_ops.rs
@@ -1,12 +1,11 @@
 use std::ops::{Div, DivAssign, Mul, MulAssign};
 
-use alga::general::Real;
-use base::allocator::Allocator;
-use base::constraint::{DimEq, ShapeConstraint};
-use base::dimension::{Dim, U1, U2};
-use base::storage::{Storage, StorageMut};
-use base::{DefaultAllocator, Matrix, Unit, Vector, Vector2};
-use geometry::{Isometry, Point2, Rotation, Similarity, Translation, UnitComplex};
+use alga::general::RealField;
+use crate::base::allocator::Allocator;
+use crate::base::dimension::{U1, U2};
+use crate::base::storage::Storage;
+use crate::base::{DefaultAllocator, Unit, Vector, Vector2};
+use crate::geometry::{Isometry, Point2, Rotation, Similarity, Translation, UnitComplex};
 
 /*
  * This file provides:
@@ -45,7 +44,7 @@ use geometry::{Isometry, Point2, Rotation, Similarity, Translation, UnitComplex}
  */
 
 // UnitComplex × UnitComplex
-impl<N: Real> Mul<Self> for UnitComplex<N> {
+impl<N: RealField> Mul<Self> for UnitComplex<N> {
     type Output = Self;
 
     #[inline]
@@ -54,7 +53,7 @@ impl<N: Real> Mul<Self> for UnitComplex<N> {
     }
 }
 
-impl<'a, N: Real> Mul<UnitComplex<N>> for &'a UnitComplex<N> {
+impl<'a, N: RealField> Mul<UnitComplex<N>> for &'a UnitComplex<N> {
     type Output = UnitComplex<N>;
 
     #[inline]
@@ -63,7 +62,7 @@ impl<'a, N: Real> Mul<UnitComplex<N>> for &'a UnitComplex<N> {
     }
 }
 
-impl<'b, N: Real> Mul<&'b UnitComplex<N>> for UnitComplex<N> {
+impl<'b, N: RealField> Mul<&'b UnitComplex<N>> for UnitComplex<N> {
     type Output = Self;
 
     #[inline]
@@ -72,7 +71,7 @@ impl<'b, N: Real> Mul<&'b UnitComplex<N>> for UnitComplex<N> {
     }
 }
 
-impl<'a, 'b, N: Real> Mul<&'b UnitComplex<N>> for &'a UnitComplex<N> {
+impl<'a, 'b, N: RealField> Mul<&'b UnitComplex<N>> for &'a UnitComplex<N> {
     type Output = UnitComplex<N>;
 
     #[inline]
@@ -82,7 +81,7 @@ impl<'a, 'b, N: Real> Mul<&'b UnitComplex<N>> for &'a UnitComplex<N> {
 }
 
 // UnitComplex ÷ UnitComplex
-impl<N: Real> Div<Self> for UnitComplex<N> {
+impl<N: RealField> Div<Self> for UnitComplex<N> {
     type Output = Self;
 
     #[inline]
@@ -91,7 +90,7 @@ impl<N: Real> Div<Self> for UnitComplex<N> {
     }
 }
 
-impl<'a, N: Real> Div<UnitComplex<N>> for &'a UnitComplex<N> {
+impl<'a, N: RealField> Div<UnitComplex<N>> for &'a UnitComplex<N> {
     type Output = UnitComplex<N>;
 
     #[inline]
@@ -100,7 +99,7 @@ impl<'a, N: Real> Div<UnitComplex<N>> for &'a UnitComplex<N> {
     }
 }
 
-impl<'b, N: Real> Div<&'b UnitComplex<N>> for UnitComplex<N> {
+impl<'b, N: RealField> Div<&'b UnitComplex<N>> for UnitComplex<N> {
     type Output = Self;
 
     #[inline]
@@ -109,7 +108,7 @@ impl<'b, N: Real> Div<&'b UnitComplex<N>> for UnitComplex<N> {
     }
 }
 
-impl<'a, 'b, N: Real> Div<&'b UnitComplex<N>> for &'a UnitComplex<N> {
+impl<'a, 'b, N: RealField> Div<&'b UnitComplex<N>> for &'a UnitComplex<N> {
     type Output = UnitComplex<N>;
 
     #[inline]
@@ -123,7 +122,7 @@ macro_rules! complex_op_impl(
      ($RDim: ident, $CDim: ident) $(for $Storage: ident: $StoragesBound: ident $(<$($BoundParam: ty),*>)*),*;
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Result: ty;
      $action: expr; $($lives: tt),*) => {
-        impl<$($lives ,)* N: Real $(, $Storage: $StoragesBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
+        impl<$($lives ,)* N: RealField $(, $Storage: $StoragesBound $(<$($BoundParam),*>)*)*> $Op<$Rhs> for $Lhs
             where DefaultAllocator: Allocator<N, $RDim, $CDim> {
             type Output = $Result;
 
@@ -301,14 +300,14 @@ complex_op_impl_all!(
 );
 
 // UnitComplex ×= UnitComplex
-impl<N: Real> MulAssign<UnitComplex<N>> for UnitComplex<N> {
+impl<N: RealField> MulAssign<UnitComplex<N>> for UnitComplex<N> {
     #[inline]
     fn mul_assign(&mut self, rhs: UnitComplex<N>) {
         *self = &*self * rhs
     }
 }
 
-impl<'b, N: Real> MulAssign<&'b UnitComplex<N>> for UnitComplex<N> {
+impl<'b, N: RealField> MulAssign<&'b UnitComplex<N>> for UnitComplex<N> {
     #[inline]
     fn mul_assign(&mut self, rhs: &'b UnitComplex<N>) {
         *self = &*self * rhs
@@ -316,14 +315,14 @@ impl<'b, N: Real> MulAssign<&'b UnitComplex<N>> for UnitComplex<N> {
 }
 
 // UnitComplex /= UnitComplex
-impl<N: Real> DivAssign<UnitComplex<N>> for UnitComplex<N> {
+impl<N: RealField> DivAssign<UnitComplex<N>> for UnitComplex<N> {
     #[inline]
     fn div_assign(&mut self, rhs: UnitComplex<N>) {
         *self = &*self / rhs
     }
 }
 
-impl<'b, N: Real> DivAssign<&'b UnitComplex<N>> for UnitComplex<N> {
+impl<'b, N: RealField> DivAssign<&'b UnitComplex<N>> for UnitComplex<N> {
     #[inline]
     fn div_assign(&mut self, rhs: &'b UnitComplex<N>) {
         *self = &*self / rhs
@@ -331,7 +330,7 @@ impl<'b, N: Real> DivAssign<&'b UnitComplex<N>> for UnitComplex<N> {
 }
 
 // UnitComplex ×= Rotation
-impl<N: Real> MulAssign<Rotation<N, U2>> for UnitComplex<N>
+impl<N: RealField> MulAssign<Rotation<N, U2>> for UnitComplex<N>
 where DefaultAllocator: Allocator<N, U2, U2>
 {
     #[inline]
@@ -340,7 +339,7 @@ where DefaultAllocator: Allocator<N, U2, U2>
     }
 }
 
-impl<'b, N: Real> MulAssign<&'b Rotation<N, U2>> for UnitComplex<N>
+impl<'b, N: RealField> MulAssign<&'b Rotation<N, U2>> for UnitComplex<N>
 where DefaultAllocator: Allocator<N, U2, U2>
 {
     #[inline]
@@ -350,7 +349,7 @@ where DefaultAllocator: Allocator<N, U2, U2>
 }
 
 // UnitComplex ÷= Rotation
-impl<N: Real> DivAssign<Rotation<N, U2>> for UnitComplex<N>
+impl<N: RealField> DivAssign<Rotation<N, U2>> for UnitComplex<N>
 where DefaultAllocator: Allocator<N, U2, U2>
 {
     #[inline]
@@ -359,7 +358,7 @@ where DefaultAllocator: Allocator<N, U2, U2>
     }
 }
 
-impl<'b, N: Real> DivAssign<&'b Rotation<N, U2>> for UnitComplex<N>
+impl<'b, N: RealField> DivAssign<&'b Rotation<N, U2>> for UnitComplex<N>
 where DefaultAllocator: Allocator<N, U2, U2>
 {
     #[inline]
@@ -369,7 +368,7 @@ where DefaultAllocator: Allocator<N, U2, U2>
 }
 
 // Rotation ×= UnitComplex
-impl<N: Real> MulAssign<UnitComplex<N>> for Rotation<N, U2>
+impl<N: RealField> MulAssign<UnitComplex<N>> for Rotation<N, U2>
 where DefaultAllocator: Allocator<N, U2, U2>
 {
     #[inline]
@@ -378,7 +377,7 @@ where DefaultAllocator: Allocator<N, U2, U2>
     }
 }
 
-impl<'b, N: Real> MulAssign<&'b UnitComplex<N>> for Rotation<N, U2>
+impl<'b, N: RealField> MulAssign<&'b UnitComplex<N>> for Rotation<N, U2>
 where DefaultAllocator: Allocator<N, U2, U2>
 {
     #[inline]
@@ -388,7 +387,7 @@ where DefaultAllocator: Allocator<N, U2, U2>
 }
 
 // Rotation ÷= UnitComplex
-impl<N: Real> DivAssign<UnitComplex<N>> for Rotation<N, U2>
+impl<N: RealField> DivAssign<UnitComplex<N>> for Rotation<N, U2>
 where DefaultAllocator: Allocator<N, U2, U2>
 {
     #[inline]
@@ -397,67 +396,11 @@ where DefaultAllocator: Allocator<N, U2, U2>
     }
 }
 
-impl<'b, N: Real> DivAssign<&'b UnitComplex<N>> for Rotation<N, U2>
+impl<'b, N: RealField> DivAssign<&'b UnitComplex<N>> for Rotation<N, U2>
 where DefaultAllocator: Allocator<N, U2, U2>
 {
     #[inline]
     fn div_assign(&mut self, rhs: &'b UnitComplex<N>) {
         self.div_assign(rhs.to_rotation_matrix())
     }
-}
-
-// Matrix = UnitComplex * Matrix
-impl<N: Real> UnitComplex<N> {
-    /// Performs the multiplication `rhs = self * rhs` in-place.
-    pub fn rotate<R2: Dim, C2: Dim, S2: StorageMut<N, R2, C2>>(
-        &self,
-        rhs: &mut Matrix<N, R2, C2, S2>,
-    ) where
-        ShapeConstraint: DimEq<R2, U2>,
-    {
-        assert_eq!(
-            rhs.nrows(),
-            2,
-            "Unit complex rotation: the input matrix must have exactly two rows."
-        );
-        let i = self.as_ref().im;
-        let r = self.as_ref().re;
-
-        for j in 0..rhs.ncols() {
-            unsafe {
-                let a = *rhs.get_unchecked((0, j));
-                let b = *rhs.get_unchecked((1, j));
-
-                *rhs.get_unchecked_mut((0, j)) = r * a - i * b;
-                *rhs.get_unchecked_mut((1, j)) = i * a + r * b;
-            }
-        }
-    }
-
-    /// Performs the multiplication `lhs = lhs * self` in-place.
-    pub fn rotate_rows<R2: Dim, C2: Dim, S2: StorageMut<N, R2, C2>>(
-        &self,
-        lhs: &mut Matrix<N, R2, C2, S2>,
-    ) where
-        ShapeConstraint: DimEq<C2, U2>,
-    {
-        assert_eq!(
-            lhs.ncols(),
-            2,
-            "Unit complex rotation: the input matrix must have exactly two columns."
-        );
-        let i = self.as_ref().im;
-        let r = self.as_ref().re;
-
-        // FIXME: can we optimize that to iterate on one column at a time ?
-        for j in 0..lhs.nrows() {
-            unsafe {
-                let a = *lhs.get_unchecked((j, 0));
-                let b = *lhs.get_unchecked((j, 1));
-
-                *lhs.get_unchecked_mut((j, 0)) = r * a + i * b;
-                *lhs.get_unchecked_mut((j, 1)) = -i * a + r * b;
-            }
-        }
-    }
-}
+}
\ No newline at end of file
diff --git a/src/io/matrix_market.rs b/src/io/matrix_market.rs
index f4919cd44..f0e817a11 100644
--- a/src/io/matrix_market.rs
+++ b/src/io/matrix_market.rs
@@ -2,8 +2,8 @@ use std::fs;
 use std::path::Path;
 
 use pest::Parser;
-use sparse::CsMatrix;
-use Real;
+use crate::sparse::CsMatrix;
+use crate::RealField;
 
 #[derive(Parser)]
 #[grammar = "io/matrix_market.pest"]
@@ -11,14 +11,14 @@ struct MatrixMarketParser;
 
 // FIXME: return an Error instead of an Option.
 /// Parses a Matrix Market file at the given path, and returns the corresponding sparse matrix.
-pub fn cs_matrix_from_matrix_market<N: Real, P: AsRef<Path>>(path: P) -> Option<CsMatrix<N>> {
+pub fn cs_matrix_from_matrix_market<N: RealField, P: AsRef<Path>>(path: P) -> Option<CsMatrix<N>> {
     let file = fs::read_to_string(path).ok()?;
     cs_matrix_from_matrix_market_str(&file)
 }
 
 // FIXME: return an Error instead of an Option.
 /// Parses a Matrix Market file described by the given string, and returns the corresponding sparse matrix.
-pub fn cs_matrix_from_matrix_market_str<N: Real>(data: &str) -> Option<CsMatrix<N>> {
+pub fn cs_matrix_from_matrix_market_str<N: RealField>(data: &str) -> Option<CsMatrix<N>> {
     let file = MatrixMarketParser::parse(Rule::Document, data)
         .unwrap()
         .next()?;
@@ -41,7 +41,7 @@ pub fn cs_matrix_from_matrix_market_str<N: Real>(data: &str) -> Option<CsMatrix<
                 // NOTE: indices are 1-based.
                 rows.push(inner.next()?.as_str().parse::<usize>().ok()? - 1);
                 cols.push(inner.next()?.as_str().parse::<usize>().ok()? - 1);
-                data.push(::convert(inner.next()?.as_str().parse::<f64>().ok()?));
+                data.push(crate::convert(inner.next()?.as_str().parse::<f64>().ok()?));
             }
             _ => return None, // FIXME: return an Err instead.
         }
diff --git a/src/lib.rs b/src/lib.rs
index 80149c7c2..6667ee5a4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,8 +4,8 @@
 **nalgebra** is a linear algebra library written for Rust targeting:
 
 * General-purpose linear algebra (still lacks a lot of features…)
-* Real time computer graphics.
-* Real time computer physics.
+* RealField time computer graphics.
+* RealField time computer physics.
 
 ## Using **nalgebra**
 You will need the last stable build of the [rust compiler](http://www.rust-lang.org)
@@ -51,7 +51,7 @@ an optimized set of tools for computer graphics and physics. Those features incl
   allocated on the heap.
 * Convenient aliases for low-dimensional matrices and vectors: `Vector1` to `Vector6` and
   `Matrix1x1` to `Matrix6x6`, including rectangular matrices like `Matrix2x5`.
-* Points sizes known at compile time, and convenience aliases: `Point1` to `Point6`.
+* Points sizes known at compile time, and convenience aliases:: `Point1` to `Point6`.
 * Translation (seen as a transformation that composes by multiplication): `Translation2`,
   `Translation3`.
 * Rotation matrices: `Rotation2`, `Rotation3`.
@@ -66,7 +66,7 @@ an optimized set of tools for computer graphics and physics. Those features incl
 * General transformations that does not have to be invertible, stored as an homogeneous matrix:
   `Transform2`, `Transform3`.
 * 3D projections for computer graphics: `Perspective3`, `Orthographic3`.
-* Matrix factorizations: `Cholesky`, `QR`, `LU`, `FullPivLU`, `SVD`, `RealSchur`, `Hessenberg`, `SymmetricEigen`.
+* Matrix factorizations: `Cholesky`, `QR`, `LU`, `FullPivLU`, `SVD`, `Schur`, `Hessenberg`, `SymmetricEigen`.
 * Insertion and removal of rows of columns of a matrix.
 * Implements traits from the [alga](https://crates.io/crates/alga) crate for
   generic programming.
@@ -144,11 +144,11 @@ pub mod sparse;
     note = "The 'core' module is being renamed to 'base' to avoid conflicts with the 'core' crate."
 )]
 pub use base as core;
-pub use base::*;
-pub use geometry::*;
-pub use linalg::*;
+pub use crate::base::*;
+pub use crate::geometry::*;
+pub use crate::linalg::*;
 #[cfg(feature = "sparse")]
-pub use sparse::*;
+pub use crate::sparse::*;
 
 use std::cmp::{self, Ordering, PartialOrd};
 
@@ -160,7 +160,10 @@ use alga::linear::SquareMatrix as AlgaSquareMatrix;
 use alga::linear::{EuclideanSpace, FiniteDimVectorSpace, InnerSpace, NormedSpace};
 use num::Signed;
 
-pub use alga::general::{Id, Real};
+pub use alga::general::{Id, RealField, ComplexField};
+#[allow(deprecated)]
+pub use alga::general::Real;
+pub use num_complex::Complex;
 
 /*
  *
@@ -170,6 +173,7 @@ pub use alga::general::{Id, Real};
 /// Gets the ubiquitous multiplicative identity element.
 ///
 /// Same as `Id::new()`.
+#[deprecated(note = "use `Id::new()` instead.")]
 #[inline]
 pub fn id() -> Id {
     Id::new()
@@ -296,8 +300,8 @@ pub fn min<T: Ord>(a: T, b: T) -> T {
 
 /// The absolute value of `a`.
 ///
-/// Deprecated: Use [Matrix::abs] or [Real::abs] instead.
-#[deprecated(note = "use `Matrix::abs` or `Real::abs` instead")]
+/// Deprecated: Use [Matrix::abs] or [RealField::abs] instead.
+#[deprecated(note = "use `Matrix::abs` or `RealField::abs` instead")]
 #[inline]
 pub fn abs<T: Signed>(a: &T) -> T {
     a.abs()
@@ -416,6 +420,7 @@ pub fn partial_sort2<'a, T: PartialOrd>(a: &'a T, b: &'a T) -> Option<(&'a T, &'
 /// # See also:
 ///
 /// * [`inverse`](fn.inverse.html)
+#[deprecated(note = "use the `.try_inverse()` method instead")]
 #[inline]
 pub fn try_inverse<M: AlgaSquareMatrix>(m: &M) -> Option<M> {
     m.try_inverse()
@@ -426,6 +431,7 @@ pub fn try_inverse<M: AlgaSquareMatrix>(m: &M) -> Option<M> {
 /// # See also:
 ///
 /// * [`try_inverse`](fn.try_inverse.html)
+#[deprecated(note = "use the `.inverse()` method instead")]
 #[inline]
 pub fn inverse<M: TwoSidedInverse<Multiplicative>>(m: &M) -> M {
     m.two_sided_inverse()
@@ -457,7 +463,7 @@ pub fn dot<V: FiniteDimVectorSpace>(a: &V, b: &V) -> V::Field {
 /// Or, use [InnerSpace::angle](https://docs.rs/alga/0.7.2/alga/linear/trait.InnerSpace.html#method.angle).
 #[deprecated(note = "use `Matrix::angle` instead")]
 #[inline]
-pub fn angle<V: InnerSpace>(a: &V, b: &V) -> V::Real {
+pub fn angle<V: InnerSpace>(a: &V, b: &V) -> V::RealField {
     a.angle(b)
 }
 
@@ -481,7 +487,7 @@ pub fn angle<V: InnerSpace>(a: &V, b: &V) -> V::Real {
 /// Or, use [NormedSpace::norm](https://docs.rs/alga/0.7.2/alga/linear/trait.NormedSpace.html#tymethod.norm).
 #[deprecated(note = "use `Matrix::norm` or `Quaternion::norm` instead")]
 #[inline]
-pub fn norm<V: NormedSpace>(v: &V) -> V::Field {
+pub fn norm<V: NormedSpace>(v: &V) -> V::RealField {
     v.norm()
 }
 
@@ -501,7 +507,7 @@ pub fn norm<V: NormedSpace>(v: &V) -> V::Field {
 /// Or, use [NormedSpace::norm_squared](https://docs.rs/alga/0.7.2/alga/linear/trait.NormedSpace.html#tymethod.norm_squared).
 #[deprecated(note = "use `Matrix::norm_squared` or `Quaternion::norm_squared` instead")]
 #[inline]
-pub fn norm_squared<V: NormedSpace>(v: &V) -> V::Field {
+pub fn norm_squared<V: NormedSpace>(v: &V) -> V::RealField {
     v.norm_squared()
 }
 
@@ -521,7 +527,7 @@ pub fn norm_squared<V: NormedSpace>(v: &V) -> V::Field {
 /// Or, use [NormedSpace::norm](https://docs.rs/alga/0.7.2/alga/linear/trait.NormedSpace.html#tymethod.norm).
 #[deprecated(note = "use `Matrix::magnitude` or `Quaternion::magnitude` instead")]
 #[inline]
-pub fn magnitude<V: NormedSpace>(v: &V) -> V::Field {
+pub fn magnitude<V: NormedSpace>(v: &V) -> V::RealField {
     v.norm()
 }
 
@@ -542,7 +548,7 @@ pub fn magnitude<V: NormedSpace>(v: &V) -> V::Field {
 /// Or, use [NormedSpace::norm_squared](https://docs.rs/alga/0.7.2/alga/linear/trait.NormedSpace.html#tymethod.norm_squared).
 #[deprecated(note = "use `Matrix::magnitude_squared` or `Quaternion::magnitude_squared` instead")]
 #[inline]
-pub fn magnitude_squared<V: NormedSpace>(v: &V) -> V::Field {
+pub fn magnitude_squared<V: NormedSpace>(v: &V) -> V::RealField {
     v.norm_squared()
 }
 
@@ -570,7 +576,7 @@ pub fn normalize<V: NormedSpace>(v: &V) -> V {
 /// Or, use [NormedSpace::try_normalize](https://docs.rs/alga/0.7.2/alga/linear/trait.NormedSpace.html#tymethod.try_normalize).
 #[deprecated(note = "use `Matrix::try_normalize` or `Quaternion::try_normalize` instead")]
 #[inline]
-pub fn try_normalize<V: NormedSpace>(v: &V, min_norm: V::Field) -> Option<V> {
+pub fn try_normalize<V: NormedSpace>(v: &V, min_norm: V::RealField) -> Option<V> {
     v.try_normalize(min_norm)
 }
 
@@ -597,7 +603,7 @@ pub fn center<P: EuclideanSpace>(p1: &P, p2: &P) -> P {
 /// * [center](fn.center.html)
 /// * [distance_squared](fn.distance_squared.html)
 #[inline]
-pub fn distance<P: EuclideanSpace>(p1: &P, p2: &P) -> P::Real {
+pub fn distance<P: EuclideanSpace>(p1: &P, p2: &P) -> P::RealField {
     (p2.coordinates() - p1.coordinates()).norm()
 }
 
@@ -608,7 +614,7 @@ pub fn distance<P: EuclideanSpace>(p1: &P, p2: &P) -> P::Real {
 /// * [center](fn.center.html)
 /// * [distance](fn.distance.html)
 #[inline]
-pub fn distance_squared<P: EuclideanSpace>(p1: &P, p2: &P) -> P::Real {
+pub fn distance_squared<P: EuclideanSpace>(p1: &P, p2: &P) -> P::RealField {
     (p2.coordinates() - p1.coordinates()).norm_squared()
 }
 
diff --git a/src/linalg/balancing.rs b/src/linalg/balancing.rs
index 5db113bae..e8abbefb2 100644
--- a/src/linalg/balancing.rs
+++ b/src/linalg/balancing.rs
@@ -1,23 +1,23 @@
 //! Functions for balancing a matrix.
 
-use alga::general::Real;
+use alga::general::RealField;
 use std::ops::{DivAssign, MulAssign};
 
-use allocator::Allocator;
-use base::dimension::{Dim, U1};
-use base::storage::Storage;
-use base::{DefaultAllocator, MatrixN, VectorN};
+use crate::allocator::Allocator;
+use crate::base::dimension::{Dim, U1};
+use crate::base::storage::Storage;
+use crate::base::{DefaultAllocator, MatrixN, VectorN};
 
 /// Applies in-place a modified Parlett and Reinsch matrix balancing with 2-norm to the matrix `m` and returns
 /// the corresponding diagonal transformation.
 ///
 /// See https://arxiv.org/pdf/1401.5766.pdf
-pub fn balance_parlett_reinsch<N: Real, D: Dim>(m: &mut MatrixN<N, D>) -> VectorN<N, D>
+pub fn balance_parlett_reinsch<N: RealField, D: Dim>(m: &mut MatrixN<N, D>) -> VectorN<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> {
     assert!(m.is_square(), "Unable to balance a non-square matrix.");
 
     let dim = m.data.shape().0;
-    let radix: N = ::convert(2.0f64);
+    let radix: N = crate::convert(2.0f64);
     let mut d = VectorN::from_element_generic(dim, U1, N::one());
 
     let mut converged = false;
@@ -50,7 +50,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> {
                 f /= radix;
             }
 
-            let eps: N = ::convert(0.95);
+            let eps: N = crate::convert(0.95);
             if c * c + r * r < eps * s {
                 converged = false;
                 d[i] *= f;
@@ -64,7 +64,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> {
 }
 
 /// Computes in-place `D * m * D.inverse()`, where `D` is the matrix with diagonal `d`.
-pub fn unbalance<N: Real, D: Dim>(m: &mut MatrixN<N, D>, d: &VectorN<N, D>)
+pub fn unbalance<N: RealField, D: Dim>(m: &mut MatrixN<N, D>, d: &VectorN<N, D>)
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> {
     assert!(m.is_square(), "Unable to unbalance a non-square matrix.");
     assert_eq!(m.nrows(), d.len(), "Unbalancing: mismatched dimensions.");
diff --git a/src/linalg/bidiagonal.rs b/src/linalg/bidiagonal.rs
index 3e73c40f4..f766c91eb 100644
--- a/src/linalg/bidiagonal.rs
+++ b/src/linalg/bidiagonal.rs
@@ -1,15 +1,14 @@
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Serialize};
 
-use alga::general::Real;
-use allocator::Allocator;
-use base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Unit, VectorN};
-use constraint::{DimEq, ShapeConstraint};
-use dimension::{Dim, DimDiff, DimMin, DimMinimum, DimSub, Dynamic, U1};
-use storage::Storage;
+use alga::general::ComplexField;
+use crate::allocator::Allocator;
+use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Unit, VectorN};
+use crate::dimension::{Dim, DimDiff, DimMin, DimMinimum, DimSub, U1};
+use crate::storage::Storage;
 
-use geometry::Reflection;
-use linalg::householder;
+use crate::geometry::Reflection;
+use crate::linalg::householder;
 
 /// The bidiagonalization of a general matrix.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
@@ -38,7 +37,7 @@ use linalg::householder;
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct Bidiagonal<N: Real, R: DimMin<C>, C: Dim>
+pub struct Bidiagonal<N: ComplexField, R: DimMin<C>, C: Dim>
 where
     DimMinimum<R, C>: DimSub<U1>,
     DefaultAllocator: Allocator<N, R, C>
@@ -49,13 +48,13 @@ where
     // contiguous. This prevents some useless copies.
     uv: MatrixMN<N, R, C>,
     /// The diagonal elements of the decomposed matrix.
-    pub diagonal: VectorN<N, DimMinimum<R, C>>,
+    diagonal: VectorN<N, DimMinimum<R, C>>,
     /// The off-diagonal elements of the decomposed matrix.
-    pub off_diagonal: VectorN<N, DimDiff<DimMinimum<R, C>, U1>>,
+    off_diagonal: VectorN<N, DimDiff<DimMinimum<R, C>, U1>>,
     upper_diagonal: bool,
 }
 
-impl<N: Real, R: DimMin<C>, C: Dim> Copy for Bidiagonal<N, R, C>
+impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for Bidiagonal<N, R, C>
 where
     DimMinimum<R, C>: DimSub<U1>,
     DefaultAllocator: Allocator<N, R, C>
@@ -66,7 +65,7 @@ where
     VectorN<N, DimDiff<DimMinimum<R, C>, U1>>: Copy,
 {}
 
-impl<N: Real, R: DimMin<C>, C: Dim> Bidiagonal<N, R, C>
+impl<N: ComplexField, R: DimMin<C>, C: Dim> Bidiagonal<N, R, C>
 where
     DimMinimum<R, C>: DimSub<U1>,
     DefaultAllocator: Allocator<N, R, C>
@@ -143,9 +142,9 @@ where
 
         Bidiagonal {
             uv: matrix,
-            diagonal: diagonal,
-            off_diagonal: off_diagonal,
-            upper_diagonal: upper_diagonal,
+            diagonal,
+            off_diagonal,
+            upper_diagonal,
         }
     }
 
@@ -179,9 +178,6 @@ where
         DefaultAllocator: Allocator<N, DimMinimum<R, C>, DimMinimum<R, C>>
             + Allocator<N, R, DimMinimum<R, C>>
             + Allocator<N, DimMinimum<R, C>, C>,
-        // FIXME: the following bounds are ugly.
-        DimMinimum<R, C>: DimMin<DimMinimum<R, C>, Output = DimMinimum<R, C>>,
-        ShapeConstraint: DimEq<Dynamic, DimDiff<DimMinimum<R, C>, U1>>,
     {
         // FIXME: optimize by calling a reallocator.
         (self.u(), self.d(), self.v_t())
@@ -192,19 +188,16 @@ where
     pub fn d(&self) -> MatrixN<N, DimMinimum<R, C>>
     where
         DefaultAllocator: Allocator<N, DimMinimum<R, C>, DimMinimum<R, C>>,
-        // FIXME: the following bounds are ugly.
-        DimMinimum<R, C>: DimMin<DimMinimum<R, C>, Output = DimMinimum<R, C>>,
-        ShapeConstraint: DimEq<Dynamic, DimDiff<DimMinimum<R, C>, U1>>,
     {
         let (nrows, ncols) = self.uv.data.shape();
 
         let d = nrows.min(ncols);
         let mut res = MatrixN::identity_generic(d, d);
-        res.set_diagonal(&self.diagonal);
+        res.set_partial_diagonal(self.diagonal.iter().map(|e| N::from_real(e.modulus())));
 
         let start = self.axis_shift();
         res.slice_mut(start, (d.value() - 1, d.value() - 1))
-            .set_diagonal(&self.off_diagonal);
+            .set_partial_diagonal(self.off_diagonal.iter().map(|e| N::from_real(e.modulus())));
         res
     }
 
@@ -225,13 +218,20 @@ where
             let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
 
             let mut res_rows = res.slice_range_mut(i + shift.., i..);
-            refl.reflect(&mut res_rows);
+
+            let sign = if self.upper_diagonal {
+                self.diagonal[i].signum()
+            } else {
+                self.off_diagonal[i].signum()
+            };
+
+            refl.reflect_with_sign(&mut res_rows, sign);
         }
 
         res
     }
 
-    /// Computes the orthogonal matrix `V` of this `U * D * V` decomposition.
+    /// Computes the orthogonal matrix `V_t` of this `U * D * V_t` decomposition.
     pub fn v_t(&self) -> MatrixMN<N, DimMinimum<R, C>, C>
     where DefaultAllocator: Allocator<N, DimMinimum<R, C>, C> {
         let (nrows, ncols) = self.uv.data.shape();
@@ -251,20 +251,29 @@ where
             let refl = Reflection::new(Unit::new_unchecked(axis_packed), N::zero());
 
             let mut res_rows = res.slice_range_mut(i.., i + shift..);
-            refl.reflect_rows(&mut res_rows, &mut work.rows_range_mut(i..));
+
+            let sign = if self.upper_diagonal {
+                self.off_diagonal[i].signum()
+            } else {
+                self.diagonal[i].signum()
+            };
+
+            refl.reflect_rows_with_sign(&mut res_rows, &mut work.rows_range_mut(i..), sign);
         }
 
         res
     }
 
     /// The diagonal part of this decomposed matrix.
-    pub fn diagonal(&self) -> &VectorN<N, DimMinimum<R, C>> {
-        &self.diagonal
+    pub fn diagonal(&self) -> VectorN<N::RealField, DimMinimum<R, C>>
+        where DefaultAllocator: Allocator<N::RealField, DimMinimum<R, C>> {
+        self.diagonal.map(|e| e.modulus())
     }
 
     /// The off-diagonal part of this decomposed matrix.
-    pub fn off_diagonal(&self) -> &VectorN<N, DimDiff<DimMinimum<R, C>, U1>> {
-        &self.off_diagonal
+    pub fn off_diagonal(&self) -> VectorN<N::RealField, DimDiff<DimMinimum<R, C>, U1>>
+        where DefaultAllocator: Allocator<N::RealField, DimDiff<DimMinimum<R, C>, U1>> {
+        self.off_diagonal.map(|e| e.modulus())
     }
 
     #[doc(hidden)]
@@ -273,7 +282,7 @@ where
     }
 }
 
-// impl<N: Real, D: DimMin<D, Output = D> + DimSub<Dynamic>> Bidiagonal<N, D, D>
+// impl<N: ComplexField, D: DimMin<D, Output = D> + DimSub<Dynamic>> Bidiagonal<N, D, D>
 //     where DefaultAllocator: Allocator<N, D, D> +
 //                             Allocator<N, D> {
 //     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
@@ -346,7 +355,7 @@ where
 //     // }
 // }
 
-impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
+impl<N: ComplexField, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
 where
     DimMinimum<R, C>: DimSub<U1>,
     DefaultAllocator: Allocator<N, R, C>
diff --git a/src/linalg/cholesky.rs b/src/linalg/cholesky.rs
index c1fd7b853..0b6e6db59 100644
--- a/src/linalg/cholesky.rs
+++ b/src/linalg/cholesky.rs
@@ -1,13 +1,13 @@
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Serialize};
 
-use alga::general::Real;
+use alga::general::ComplexField;
 
-use allocator::Allocator;
-use base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, SquareMatrix};
-use constraint::{SameNumberOfRows, ShapeConstraint};
-use dimension::{Dim, DimSub, Dynamic};
-use storage::{Storage, StorageMut};
+use crate::allocator::Allocator;
+use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, SquareMatrix};
+use crate::constraint::{SameNumberOfRows, ShapeConstraint};
+use crate::dimension::{Dim, DimSub, Dynamic};
+use crate::storage::{Storage, StorageMut};
 
 /// The Cholesky decomposition of a symmetric-definite-positive matrix.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
@@ -26,19 +26,19 @@ use storage::{Storage, StorageMut};
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct Cholesky<N: Real, D: Dim>
+pub struct Cholesky<N: ComplexField, D: Dim>
 where DefaultAllocator: Allocator<N, D, D>
 {
     chol: MatrixN<N, D>,
 }
 
-impl<N: Real, D: Dim> Copy for Cholesky<N, D>
+impl<N: ComplexField, D: Dim> Copy for Cholesky<N, D>
 where
     DefaultAllocator: Allocator<N, D, D>,
     MatrixN<N, D>: Copy,
 {}
 
-impl<N: Real, D: DimSub<Dynamic>> Cholesky<N, D>
+impl<N: ComplexField, D: DimSub<Dynamic>> Cholesky<N, D>
 where DefaultAllocator: Allocator<N, D, D>
 {
     /// Attempts to compute the Cholesky decomposition of `matrix`.
@@ -58,21 +58,25 @@ where DefaultAllocator: Allocator<N, D, D>
                 let mut col_j = col_j.rows_range_mut(j..);
                 let col_k = col_k.rows_range(j..);
 
-                col_j.axpy(factor, &col_k, N::one());
+                col_j.axpy(factor.conjugate(), &col_k, N::one());
             }
 
             let diag = unsafe { *matrix.get_unchecked((j, j)) };
-            if diag > N::zero() {
-                let denom = diag.sqrt();
-                unsafe {
-                    *matrix.get_unchecked_mut((j, j)) = denom;
+            if !diag.is_zero() {
+                if let Some(denom) = diag.try_sqrt() {
+                    unsafe {
+                        *matrix.get_unchecked_mut((j, j)) = denom;
+                    }
+
+                    let mut col = matrix.slice_range_mut(j + 1.., j);
+                    col /= denom;
+                    continue;
                 }
-
-                let mut col = matrix.slice_range_mut(j + 1.., j);
-                col /= denom;
-            } else {
-                return None;
             }
+
+            // The diagonal element is either zero or its square root could not
+            // be taken (e.g. for negative real numbers).
+            return None;
         }
 
         Some(Cholesky { chol: matrix })
@@ -118,7 +122,7 @@ where DefaultAllocator: Allocator<N, D, D>
         ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let _ = self.chol.solve_lower_triangular_mut(b);
-        let _ = self.chol.tr_solve_lower_triangular_mut(b);
+        let _ = self.chol.ad_solve_lower_triangular_mut(b);
     }
 
     /// Returns the solution of the system `self * x = b` where `self` is the decomposed matrix and
@@ -144,7 +148,7 @@ where DefaultAllocator: Allocator<N, D, D>
     }
 }
 
-impl<N: Real, D: DimSub<Dynamic>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
+impl<N: ComplexField, D: DimSub<Dynamic>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
 where DefaultAllocator: Allocator<N, D, D>
 {
     /// Attempts to compute the Cholesky decomposition of this matrix.
diff --git a/src/linalg/convolution.rs b/src/linalg/convolution.rs
index b121b34ab..3f934eda1 100644
--- a/src/linalg/convolution.rs
+++ b/src/linalg/convolution.rs
@@ -1,11 +1,12 @@
-use base::allocator::Allocator;
-use base::default_allocator::DefaultAllocator;
-use base::dimension::{Dim, DimAdd, DimDiff, DimMax, DimMaximum, DimSub, DimSum};
 use std::cmp;
-use storage::Storage;
-use {zero, Real, Vector, VectorN, U1};
 
-impl<N: Real, D1: Dim, S1: Storage<N, D1>> Vector<N, D1, S1> {
+use crate::base::allocator::Allocator;
+use crate::base::default_allocator::DefaultAllocator;
+use crate::base::dimension::{Dim, DimAdd, DimDiff, DimMax, DimMaximum, DimSub, DimSum};
+use crate::storage::Storage;
+use crate::{zero, RealField, Vector, VectorN, U1};
+
+impl<N: RealField, D1: Dim, S1: Storage<N, D1>> Vector<N, D1, S1> {
     /// Returns the convolution of the target vector and a kernel
     ///
     /// # Arguments
diff --git a/src/linalg/determinant.rs b/src/linalg/determinant.rs
index 6229da0e9..54ec9e5a8 100644
--- a/src/linalg/determinant.rs
+++ b/src/linalg/determinant.rs
@@ -1,13 +1,13 @@
-use alga::general::Real;
+use alga::general::ComplexField;
 
-use base::allocator::Allocator;
-use base::dimension::DimMin;
-use base::storage::Storage;
-use base::{DefaultAllocator, SquareMatrix};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::DimMin;
+use crate::base::storage::Storage;
+use crate::base::{DefaultAllocator, SquareMatrix};
 
-use linalg::LU;
+use crate::linalg::LU;
 
-impl<N: Real, D: DimMin<D, Output = D>, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
+impl<N: ComplexField, D: DimMin<D, Output = D>, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// Computes the matrix determinant.
     ///
     /// If the matrix has a dimension larger than 3, an LU decomposition is used.
diff --git a/src/linalg/eigen.rs b/src/linalg/eigen.rs
index c9fe16e67..8d1d26ca8 100644
--- a/src/linalg/eigen.rs
+++ b/src/linalg/eigen.rs
@@ -1,23 +1,23 @@
 #[cfg(feature = "serde-serialize")]
 use serde::{Serialize, Deserialize};
 
-use alga::general::Real;
+use alga::general::ComplexField;
 use num_complex::Complex;
 use std::cmp;
 use std::fmt::Display;
 use std::ops::MulAssign;
 
-use allocator::Allocator;
-use base::dimension::{Dim, DimDiff, DimSub, Dynamic, U1, U2, U3};
-use base::storage::Storage;
-use base::{DefaultAllocator, Hessenberg, MatrixN, SquareMatrix, Unit, Vector2, Vector3, VectorN};
-use constraint::{DimEq, ShapeConstraint};
+use crate::allocator::Allocator;
+use crate::base::dimension::{Dim, DimDiff, DimSub, Dynamic, U1, U2, U3};
+use crate::base::storage::Storage;
+use crate::base::{DefaultAllocator, Hessenberg, MatrixN, SquareMatrix, Unit, Vector2, Vector3, VectorN};
+use crate::constraint::{DimEq, ShapeConstraint};
 
-use geometry::{Reflection, UnitComplex};
-use linalg::householder;
-use linalg::RealSchur;
+use crate::geometry::{Reflection, UnitComplex};
+use crate::linalg::householder;
+use crate::linalg::Schur;
 
-/// Eigendecomposition of a matrix with real eigenvalues.
+/// Eigendecomposition of a real matrix with real eigenvalues (or complex eigen values for complex matrices).
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
@@ -40,7 +40,7 @@ use linalg::RealSchur;
     )
 )]
 #[derive(Clone, Debug)]
-pub struct RealEigen<N: Real, D: Dim>
+pub struct Eigen<N: ComplexField, D: Dim>
 where
     DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
 {
@@ -48,7 +48,7 @@ where
     pub eigenvalues: VectorN<N, D>,
 }
 
-impl<N: Real, D: Dim> Copy for RealEigen<N, D>
+impl<N: ComplexField, D: Dim> Copy for Eigen<N, D>
 where
     DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
     MatrixN<N, D>: Copy,
@@ -56,7 +56,7 @@ where
 {
 }
 
-impl<N: Real, D: Dim> RealEigen<N, D>
+impl<N: ComplexField, D: Dim> Eigen<N, D>
 where
     D: DimSub<U1>,                                   // For Hessenberg.
     ShapeConstraint: DimEq<Dynamic, DimDiff<D, U1>>, // For Hessenberg.
@@ -68,19 +68,19 @@ where
     DefaultAllocator: Allocator<usize, D, D>,
     MatrixN<N, D>: Display,
 {
-    /// Computes the eigendecomposition of a diagonalizable matrix with real eigenvalues.
-    pub fn new(m: MatrixN<N, D>) -> Option<RealEigen<N, D>> {
+    /// Computes the eigendecomposition of a diagonalizable matrix with Complex eigenvalues.
+    pub fn new(m: MatrixN<N, D>) -> Option<Eigen<N, D>> {
         assert!(
             m.is_square(),
             "Unable to compute the eigendecomposition of a non-square matrix."
         );
 
         let dim = m.nrows();
-        let (mut eigenvectors, mut eigenvalues) = RealSchur::new(m, 0).unwrap().unpack();
+        let (mut eigenvectors, mut eigenvalues) = Schur::new(m, 0).unwrap().unpack();
 
         println!("Schur eigenvalues: {}", eigenvalues);
 
-        // Check that the eigenvalues are all real.
+        // Check that the eigenvalues are all Complex.
         for i in 0..dim - 1 {
             if !eigenvalues[(i + 1, i)].is_zero() {
                 return None;
@@ -112,8 +112,8 @@ where
             let _ = eigenvectors.column_mut(i).normalize_mut();
         }
 
-        Some(RealEigen {
-            eigenvectors: eigenvectors,
+        Some(Eigen {
+            eigenvectors,
             eigenvalues: eigenvalues.diagonal(),
         })
     }
diff --git a/src/linalg/full_piv_lu.rs b/src/linalg/full_piv_lu.rs
index 962d4d8b4..04f61faff 100644
--- a/src/linalg/full_piv_lu.rs
+++ b/src/linalg/full_piv_lu.rs
@@ -1,15 +1,15 @@
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Serialize};
 
-use alga::general::Real;
-use allocator::Allocator;
-use base::{DefaultAllocator, Matrix, MatrixMN, MatrixN};
-use constraint::{SameNumberOfRows, ShapeConstraint};
-use dimension::{Dim, DimMin, DimMinimum};
-use storage::{Storage, StorageMut};
+use alga::general::ComplexField;
+use crate::allocator::Allocator;
+use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN};
+use crate::constraint::{SameNumberOfRows, ShapeConstraint};
+use crate::dimension::{Dim, DimMin, DimMinimum};
+use crate::storage::{Storage, StorageMut};
 
-use linalg::lu;
-use linalg::PermutationSequence;
+use crate::linalg::lu;
+use crate::linalg::PermutationSequence;
 
 /// LU decomposition with full row and column pivoting.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
@@ -32,7 +32,7 @@ use linalg::PermutationSequence;
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct FullPivLU<N: Real, R: DimMin<C>, C: Dim>
+pub struct FullPivLU<N: ComplexField, R: DimMin<C>, C: Dim>
 where DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>
 {
     lu: MatrixMN<N, R, C>,
@@ -40,14 +40,14 @@ where DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimu
     q: PermutationSequence<DimMinimum<R, C>>,
 }
 
-impl<N: Real, R: DimMin<C>, C: Dim> Copy for FullPivLU<N, R, C>
+impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for FullPivLU<N, R, C>
 where
     DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
     MatrixMN<N, R, C>: Copy,
     PermutationSequence<DimMinimum<R, C>>: Copy,
 {}
 
-impl<N: Real, R: DimMin<C>, C: Dim> FullPivLU<N, R, C>
+impl<N: ComplexField, R: DimMin<C>, C: Dim> FullPivLU<N, R, C>
 where DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>
 {
     /// Computes the LU decomposition with full pivoting of `matrix`.
@@ -69,7 +69,7 @@ where DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimu
         }
 
         for i in 0..min_nrows_ncols.value() {
-            let piv = matrix.slice_range(i.., i..).iamax_full();
+            let piv = matrix.slice_range(i.., i..).icamax_full();
             let row_piv = piv.0 + i;
             let col_piv = piv.1 + i;
             let diag = matrix[(row_piv, col_piv)];
@@ -156,7 +156,7 @@ where DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimu
     }
 }
 
-impl<N: Real, D: DimMin<D, Output = D>> FullPivLU<N, D, D>
+impl<N: ComplexField, D: DimMin<D, Output = D>> FullPivLU<N, D, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), D>
 {
     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
@@ -261,7 +261,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), D>
     }
 }
 
-impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
+impl<N: ComplexField, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
 where DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>
 {
     /// Computes the LU decomposition with full pivoting of `matrix`.
diff --git a/src/linalg/givens.rs b/src/linalg/givens.rs
index 9175bff9b..ed93a83c4 100644
--- a/src/linalg/givens.rs
+++ b/src/linalg/givens.rs
@@ -1,36 +1,161 @@
 //! Construction of givens rotations.
 
-use alga::general::Real;
-use num_complex::Complex;
-
-use base::dimension::U2;
-use base::storage::Storage;
-use base::Vector;
-
-use geometry::UnitComplex;
-
-/// Computes the rotation `R` required such that the `y` component of `R * v` is zero.
-///
-/// Returns `None` if no rotation is needed (i.e. if `v.y == 0`). Otherwise, this returns the norm
-/// of `v` and the rotation `r` such that `R * v = [ |v|, 0.0 ]^t` where `|v|` is the norm of `v`.
-pub fn cancel_y<N: Real, S: Storage<N, U2>>(v: &Vector<N, U2, S>) -> Option<(UnitComplex<N>, N)> {
-    if !v[1].is_zero() {
-        let c = Complex::new(v[0], -v[1]);
-        Some(UnitComplex::from_complex_and_get(c))
-    } else {
-        None
-    }
+use alga::general::ComplexField;
+use num::{Zero, One};
+
+use crate::base::dimension::{Dim, U2};
+use crate::base::constraint::{ShapeConstraint, DimEq};
+use crate::base::storage::{Storage, StorageMut};
+use crate::base::{Vector, Matrix};
+
+
+/// A Givens rotation.
+#[derive(Debug, Clone, Copy)]
+pub struct GivensRotation<N: ComplexField> {
+    c: N::RealField,
+    s: N
 }
 
-/// Computes the rotation `R` required such that the `x` component of `R * v` is zero.
-///
-/// Returns `None` if no rotation is needed (i.e. if `v.x == 0`). Otherwise, this returns the norm
-/// of `v` and the rotation `r` such that `R * v = [ 0.0, |v| ]^t` where `|v|` is the norm of `v`.
-pub fn cancel_x<N: Real, S: Storage<N, U2>>(v: &Vector<N, U2, S>) -> Option<(UnitComplex<N>, N)> {
-    if !v[0].is_zero() {
-        let c = Complex::new(v[1], v[0]);
-        Some(UnitComplex::from_complex_and_get(c))
-    } else {
-        None
+// Matrix = UnitComplex * Matrix
+impl<N: ComplexField> GivensRotation<N> {
+    /// The Givents rotation that does nothing.
+    pub fn identity() -> Self {
+        Self {
+            c: N::RealField::one(),
+            s: N::zero()
+        }
+    }
+
+    /// Initializes a Givens rotation from its components.
+    ///
+    /// The components are copies as-is. It is not checked whether they describe
+    /// an actually valid Givens rotation.
+    pub fn new_unchecked(c: N::RealField, s: N) -> Self {
+       Self {
+           c, s
+       }
+    }
+
+    /// Initializes a Givens rotation from its non-normalized cosine an sine components.
+    pub fn new(c: N, s: N) -> (Self, N) {
+        Self::try_new(c, s, N::RealField::zero()).unwrap()
+    }
+
+    /// Initializes a Givens rotation form its non-normalized cosine an sine components.
+    pub fn try_new(c: N, s: N, eps: N::RealField) -> Option<(Self, N)> {
+        let (mod0, sign0) = c.to_exp();
+        let denom = (mod0 * mod0 + s.modulus_squared()).sqrt();
+
+        if denom > eps {
+            let norm = sign0.scale(denom);
+            let c = mod0 / denom;
+            let s = s / norm;
+            Some((Self { c, s }, norm))
+        } else {
+            None
+        }
+    }
+
+    /// Computes the rotation `R` required such that the `y` component of `R * v` is zero.
+    ///
+    /// Returns `None` if no rotation is needed (i.e. if `v.y == 0`). Otherwise, this returns the norm
+    /// of `v` and the rotation `r` such that `R * v = [ |v|, 0.0 ]^t` where `|v|` is the norm of `v`.
+    pub fn cancel_y<S: Storage<N, U2>>(v: &Vector<N, U2, S>) -> Option<(Self, N)> {
+        if !v[1].is_zero() {
+            let (mod0, sign0) = v[0].to_exp();
+            let denom = (mod0 * mod0 + v[1].modulus_squared()).sqrt();
+            let c = mod0 / denom;
+            let s = -v[1] / sign0.scale(denom);
+            let r = sign0.scale(denom);
+            Some((Self { c, s }, r))
+        } else {
+            None
+        }
+    }
+
+    /// Computes the rotation `R` required such that the `x` component of `R * v` is zero.
+    ///
+    /// Returns `None` if no rotation is needed (i.e. if `v.x == 0`). Otherwise, this returns the norm
+    /// of `v` and the rotation `r` such that `R * v = [ 0.0, |v| ]^t` where `|v|` is the norm of `v`.
+    pub fn cancel_x<S: Storage<N, U2>>(v: &Vector<N, U2, S>) -> Option<(Self, N)> {
+        if !v[0].is_zero() {
+            let (mod1, sign1) = v[1].to_exp();
+            let denom = (mod1 * mod1 + v[0].modulus_squared()).sqrt();
+            let c = mod1 / denom;
+            let s = (v[0].conjugate() * sign1).unscale(denom);
+            let r = sign1.scale(denom);
+            Some((Self { c, s }, r))
+        } else {
+            None
+        }
+    }
+
+    /// The cos part of this roration.
+    pub fn c(&self) -> N::RealField {
+        self.c
+    }
+
+    /// The sin part of this roration.
+    pub fn s(&self) -> N {
+        self.s
+    }
+
+    /// The inverse of this givens rotation.
+    pub fn inverse(&self) -> Self {
+        Self { c: self.c, s: -self.s }
+    }
+
+    /// Performs the multiplication `rhs = self * rhs` in-place.
+    pub fn rotate<R2: Dim, C2: Dim, S2: StorageMut<N, R2, C2>>(
+        &self,
+        rhs: &mut Matrix<N, R2, C2, S2>,
+    ) where
+        ShapeConstraint: DimEq<R2, U2>,
+    {
+        assert_eq!(
+            rhs.nrows(),
+            2,
+            "Unit complex rotation: the input matrix must have exactly two rows."
+        );
+        let s = self.s;
+        let c = self.c;
+
+        for j in 0..rhs.ncols() {
+            unsafe {
+                let a = *rhs.get_unchecked((0, j));
+                let b = *rhs.get_unchecked((1, j));
+
+                *rhs.get_unchecked_mut((0, j)) = a.scale(c) - s.conjugate() * b;
+                *rhs.get_unchecked_mut((1, j)) = s * a + b.scale(c);
+            }
+        }
+    }
+
+    /// Performs the multiplication `lhs = lhs * self` in-place.
+    pub fn rotate_rows<R2: Dim, C2: Dim, S2: StorageMut<N, R2, C2>>(
+        &self,
+        lhs: &mut Matrix<N, R2, C2, S2>,
+    ) where
+        ShapeConstraint: DimEq<C2, U2>,
+    {
+        assert_eq!(
+            lhs.ncols(),
+            2,
+            "Unit complex rotation: the input matrix must have exactly two columns."
+        );
+        let s = self.s;
+        let c = self.c;
+
+        // FIXME: can we optimize that to iterate on one column at a time ?
+        for j in 0..lhs.nrows() {
+            unsafe {
+                let a = *lhs.get_unchecked((j, 0));
+                let b = *lhs.get_unchecked((j, 1));
+
+                *lhs.get_unchecked_mut((j, 0)) = a.scale(c) + s * b;
+                *lhs.get_unchecked_mut((j, 1)) = -s.conjugate() * a + b.scale(c);
+            }
+        }
     }
 }
+
diff --git a/src/linalg/hessenberg.rs b/src/linalg/hessenberg.rs
index 783055a32..c87c06a21 100644
--- a/src/linalg/hessenberg.rs
+++ b/src/linalg/hessenberg.rs
@@ -1,14 +1,13 @@
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Serialize};
 
-use alga::general::Real;
-use allocator::Allocator;
-use base::{DefaultAllocator, MatrixMN, MatrixN, SquareMatrix, VectorN};
-use constraint::{DimEq, ShapeConstraint};
-use dimension::{DimDiff, DimSub, Dynamic, U1};
-use storage::Storage;
+use alga::general::ComplexField;
+use crate::allocator::Allocator;
+use crate::base::{DefaultAllocator, MatrixMN, MatrixN, SquareMatrix, VectorN};
+use crate::dimension::{DimDiff, DimSub, U1};
+use crate::storage::Storage;
 
-use linalg::householder;
+use crate::linalg::householder;
 
 /// Hessenberg decomposition of a general matrix.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
@@ -31,21 +30,21 @@ use linalg::householder;
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct Hessenberg<N: Real, D: DimSub<U1>>
+pub struct Hessenberg<N: ComplexField, D: DimSub<U1>>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>
 {
     hess: MatrixN<N, D>,
     subdiag: VectorN<N, DimDiff<D, U1>>,
 }
 
-impl<N: Real, D: DimSub<U1>> Copy for Hessenberg<N, D>
+impl<N: ComplexField, D: DimSub<U1>> Copy for Hessenberg<N, D>
 where
     DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
     MatrixN<N, D>: Copy,
     VectorN<N, DimDiff<D, U1>>: Copy,
 {}
 
-impl<N: Real, D: DimSub<U1>> Hessenberg<N, D>
+impl<N: ComplexField, D: DimSub<U1>> Hessenberg<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> + Allocator<N, DimDiff<D, U1>>
 {
     /// Computes the Hessenberg decomposition using householder reflections.
@@ -92,8 +91,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> + Allocator<N, DimD
     /// Retrieves `(q, h)` with `q` the orthogonal matrix of this decomposition and `h` the
     /// hessenberg matrix.
     #[inline]
-    pub fn unpack(self) -> (MatrixN<N, D>, MatrixN<N, D>)
-    where ShapeConstraint: DimEq<Dynamic, DimDiff<D, U1>> {
+    pub fn unpack(self) -> (MatrixN<N, D>, MatrixN<N, D>) {
         let q = self.q();
 
         (q, self.unpack_h())
@@ -101,13 +99,12 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> + Allocator<N, DimD
 
     /// Retrieves the upper trapezoidal submatrix `H` of this decomposition.
     #[inline]
-    pub fn unpack_h(mut self) -> MatrixN<N, D>
-    where ShapeConstraint: DimEq<Dynamic, DimDiff<D, U1>> {
+    pub fn unpack_h(mut self) -> MatrixN<N, D> {
         let dim = self.hess.nrows();
         self.hess.fill_lower_triangle(N::zero(), 2);
         self.hess
             .slice_mut((1, 0), (dim - 1, dim - 1))
-            .set_diagonal(&self.subdiag);
+            .set_partial_diagonal(self.subdiag.iter().map(|e| N::from_real(e.modulus())));
         self.hess
     }
 
@@ -116,19 +113,18 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> + Allocator<N, DimD
     ///
     /// This is less efficient than `.unpack_h()` as it allocates a new matrix.
     #[inline]
-    pub fn h(&self) -> MatrixN<N, D>
-    where ShapeConstraint: DimEq<Dynamic, DimDiff<D, U1>> {
+    pub fn h(&self) -> MatrixN<N, D> {
         let dim = self.hess.nrows();
         let mut res = self.hess.clone();
         res.fill_lower_triangle(N::zero(), 2);
         res.slice_mut((1, 0), (dim - 1, dim - 1))
-            .set_diagonal(&self.subdiag);
+            .set_partial_diagonal(self.subdiag.iter().map(|e| N::from_real(e.modulus())));
         res
     }
 
     /// Computes the orthogonal matrix `Q` of this decomposition.
     pub fn q(&self) -> MatrixN<N, D> {
-        householder::assemble_q(&self.hess)
+        householder::assemble_q(&self.hess, self.subdiag.as_slice())
     }
 
     #[doc(hidden)]
@@ -137,7 +133,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> + Allocator<N, DimD
     }
 }
 
-impl<N: Real, D: DimSub<U1>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
+impl<N: ComplexField, D: DimSub<U1>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> + Allocator<N, DimDiff<D, U1>>
 {
     /// Computes the Hessenberg decomposition of this matrix using householder reflections.
diff --git a/src/linalg/householder.rs b/src/linalg/householder.rs
index 09c230916..11fa32eb7 100644
--- a/src/linalg/householder.rs
+++ b/src/linalg/householder.rs
@@ -1,12 +1,13 @@
 //! Construction of householder elementary reflections.
 
-use alga::general::Real;
-use allocator::Allocator;
-use base::{DefaultAllocator, MatrixMN, MatrixN, Unit, Vector, VectorN};
-use dimension::Dim;
-use storage::{Storage, StorageMut};
+use num::Zero;
+use alga::general::ComplexField;
+use crate::allocator::Allocator;
+use crate::base::{DefaultAllocator, MatrixMN, MatrixN, Unit, Vector, VectorN};
+use crate::dimension::Dim;
+use crate::storage::{Storage, StorageMut};
 
-use geometry::Reflection;
+use crate::geometry::Reflection;
 
 /// Replaces `column` by the axis of the householder reflection that transforms `column` into
 /// `(+/-|column|, 0, ..., 0)`.
@@ -15,35 +16,35 @@ use geometry::Reflection;
 /// `column` after reflection and `false` if no reflection was necessary.
 #[doc(hidden)]
 #[inline(always)]
-pub fn reflection_axis_mut<N: Real, D: Dim, S: StorageMut<N, D>>(
+pub fn reflection_axis_mut<N: ComplexField, D: Dim, S: StorageMut<N, D>>(
     column: &mut Vector<N, D, S>,
 ) -> (N, bool) {
     let reflection_sq_norm = column.norm_squared();
-    let mut reflection_norm = reflection_sq_norm.sqrt();
+    let reflection_norm = reflection_sq_norm.sqrt();
 
     let factor;
-    unsafe {
-        if *column.vget_unchecked(0) > N::zero() {
-            reflection_norm = -reflection_norm;
-        }
+    let signed_norm;
 
-        factor =
-            (reflection_sq_norm - *column.vget_unchecked(0) * reflection_norm) * ::convert(2.0);
-        *column.vget_unchecked_mut(0) -= reflection_norm;
-    }
+    unsafe {
+        let (modulus, sign) = column.vget_unchecked(0).to_exp();
+        signed_norm = sign.scale(reflection_norm);
+        factor = (reflection_sq_norm + modulus * reflection_norm) * crate::convert(2.0);
+        *column.vget_unchecked_mut(0) += signed_norm;
+    };
 
     if !factor.is_zero() {
-        *column /= factor.sqrt();
-        (reflection_norm, true)
+        column.unscale_mut(factor.sqrt());
+        (-signed_norm, true)
     } else {
-        (reflection_norm, false)
+        // FIXME: not sure why we don't have a - sign here.
+        (signed_norm, false)
     }
 }
 
 /// Uses an householder reflection to zero out the `icol`-th column, starting with the `shift + 1`-th
 /// subdiagonal element.
 #[doc(hidden)]
-pub fn clear_column_unchecked<N: Real, R: Dim, C: Dim>(
+pub fn clear_column_unchecked<N: ComplexField, R: Dim, C: Dim>(
     matrix: &mut MatrixMN<N, R, C>,
     diag_elt: &mut N,
     icol: usize,
@@ -60,17 +61,18 @@ pub fn clear_column_unchecked<N: Real, R: Dim, C: Dim>(
 
     if not_zero {
         let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
+        let sign = reflection_norm.signum();
         if let Some(mut work) = bilateral {
-            refl.reflect_rows(&mut right, &mut work);
+            refl.reflect_rows_with_sign(&mut right, &mut work, sign);
         }
-        refl.reflect(&mut right.rows_range_mut(icol + shift..));
+        refl.reflect_with_sign(&mut right.rows_range_mut(icol + shift..), sign.conjugate());
     }
 }
 
-/// Uses an hoseholder reflection to zero out the `irow`-th row, ending before the `shift + 1`-th
+/// Uses an householder reflection to zero out the `irow`-th row, ending before the `shift + 1`-th
 /// superdiagonal element.
 #[doc(hidden)]
-pub fn clear_row_unchecked<N: Real, R: Dim, C: Dim>(
+pub fn clear_row_unchecked<N: ComplexField, R: Dim, C: Dim>(
     matrix: &mut MatrixMN<N, R, C>,
     diag_elt: &mut N,
     axis_packed: &mut VectorN<N, C>,
@@ -85,26 +87,28 @@ pub fn clear_row_unchecked<N: Real, R: Dim, C: Dim>(
     axis.tr_copy_from(&top.columns_range(irow + shift..));
 
     let (reflection_norm, not_zero) = reflection_axis_mut(&mut axis);
+    axis.conjugate_mut(); // So that reflect_rows actually cancels the first row.
     *diag_elt = reflection_norm;
 
     if not_zero {
         let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
-        refl.reflect_rows(
+        refl.reflect_rows_with_sign(
             &mut bottom.columns_range_mut(irow + shift..),
             &mut work.rows_range_mut(irow + 1..),
+            reflection_norm.signum().conjugate(),
         );
         top.columns_range_mut(irow + shift..)
-            .tr_copy_from(refl.axis());
+            .tr_copy_from(&refl.axis());
     } else {
         top.columns_range_mut(irow + shift..).tr_copy_from(&axis);
     }
 }
 
-/// Computes the orthogonal transformation described by the elementary reflector axices stored on
+/// Computes the orthogonal transformation described by the elementary reflector axii stored on
 /// the lower-diagonal element of the given matrix.
 /// matrices.
 #[doc(hidden)]
-pub fn assemble_q<N: Real, D: Dim>(m: &MatrixN<N, D>) -> MatrixN<N, D>
+pub fn assemble_q<N: ComplexField, D: Dim>(m: &MatrixN<N, D>, signs: &[N]) -> MatrixN<N, D>
 where DefaultAllocator: Allocator<N, D, D> {
     assert!(m.is_square());
     let dim = m.data.shape().0;
@@ -118,7 +122,7 @@ where DefaultAllocator: Allocator<N, D, D> {
         let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
 
         let mut res_rows = res.slice_range_mut(i + 1.., i..);
-        refl.reflect(&mut res_rows);
+        refl.reflect_with_sign(&mut res_rows, signs[i].signum());
     }
 
     res
diff --git a/src/linalg/inverse.rs b/src/linalg/inverse.rs
index 69f1463d1..944624429 100644
--- a/src/linalg/inverse.rs
+++ b/src/linalg/inverse.rs
@@ -1,13 +1,13 @@
-use alga::general::Real;
+use alga::general::ComplexField;
 
-use base::allocator::Allocator;
-use base::dimension::Dim;
-use base::storage::{Storage, StorageMut};
-use base::{DefaultAllocator, MatrixN, SquareMatrix};
+use crate::base::allocator::Allocator;
+use crate::base::dimension::Dim;
+use crate::base::storage::{Storage, StorageMut};
+use crate::base::{DefaultAllocator, MatrixN, SquareMatrix};
 
-use linalg::lu;
+use crate::linalg::lu;
 
-impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
+impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// Attempts to invert this matrix.
     #[inline]
     pub fn try_inverse(self) -> Option<MatrixN<N, D>>
@@ -21,7 +21,7 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     }
 }
 
-impl<N: Real, D: Dim, S: StorageMut<N, D, D>> SquareMatrix<N, D, S> {
+impl<N: ComplexField, D: Dim, S: StorageMut<N, D, D>> SquareMatrix<N, D, S> {
     /// Attempts to invert this matrix in-place. Returns `false` and leaves `self` untouched if
     /// inversion fails.
     #[inline]
@@ -115,7 +115,7 @@ impl<N: Real, D: Dim, S: StorageMut<N, D, D>> SquareMatrix<N, D, S> {
 }
 
 // NOTE: this is an extremely efficient, loop-unrolled matrix inverse from MESA (MIT licensed).
-fn do_inverse4<N: Real, D: Dim, S: StorageMut<N, D, D>>(
+fn do_inverse4<N: ComplexField, D: Dim, S: StorageMut<N, D, D>>(
     m: &MatrixN<N, D>,
     out: &mut SquareMatrix<N, D, S>,
 ) -> bool
diff --git a/src/linalg/lu.rs b/src/linalg/lu.rs
index 67fae23fa..2c3beee3c 100644
--- a/src/linalg/lu.rs
+++ b/src/linalg/lu.rs
@@ -1,15 +1,15 @@
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Serialize};
 
-use alga::general::{Field, Real};
-use allocator::{Allocator, Reallocator};
-use base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar};
-use constraint::{SameNumberOfRows, ShapeConstraint};
-use dimension::{Dim, DimMin, DimMinimum};
+use alga::general::{Field, ComplexField};
+use crate::allocator::{Allocator, Reallocator};
+use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar};
+use crate::constraint::{SameNumberOfRows, ShapeConstraint};
+use crate::dimension::{Dim, DimMin, DimMinimum};
 use std::mem;
-use storage::{Storage, StorageMut};
+use crate::storage::{Storage, StorageMut};
 
-use linalg::PermutationSequence;
+use crate::linalg::PermutationSequence;
 
 /// LU decomposition with partial (row) pivoting.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
@@ -32,14 +32,14 @@ use linalg::PermutationSequence;
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct LU<N: Real, R: DimMin<C>, C: Dim>
+pub struct LU<N: ComplexField, R: DimMin<C>, C: Dim>
 where DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>
 {
     lu: MatrixMN<N, R, C>,
     p: PermutationSequence<DimMinimum<R, C>>,
 }
 
-impl<N: Real, R: DimMin<C>, C: Dim> Copy for LU<N, R, C>
+impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for LU<N, R, C>
 where
     DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
     MatrixMN<N, R, C>: Copy,
@@ -49,7 +49,7 @@ where
 /// Performs a LU decomposition to overwrite `out` with the inverse of `matrix`.
 ///
 /// If `matrix` is not invertible, `false` is returned and `out` may contain invalid data.
-pub fn try_invert_to<N: Real, D: Dim, S>(
+pub fn try_invert_to<N: ComplexField, D: Dim, S>(
     mut matrix: MatrixN<N, D>,
     out: &mut Matrix<N, D, D, S>,
 ) -> bool
@@ -66,7 +66,7 @@ where
     out.fill_with_identity();
 
     for i in 0..dim {
-        let piv = matrix.slice_range(i.., i).iamax() + i;
+        let piv = matrix.slice_range(i.., i).icamax() + i;
         let diag = matrix[(piv, i)];
 
         if diag.is_zero() {
@@ -86,7 +86,7 @@ where
     matrix.solve_upper_triangular_mut(out)
 }
 
-impl<N: Real, R: DimMin<C>, C: Dim> LU<N, R, C>
+impl<N: ComplexField, R: DimMin<C>, C: Dim> LU<N, R, C>
 where DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>
 {
     /// Computes the LU decomposition with partial (row) pivoting of `matrix`.
@@ -101,7 +101,7 @@ where DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimu
         }
 
         for i in 0..min_nrows_ncols.value() {
-            let piv = matrix.slice_range(i.., i).iamax() + i;
+            let piv = matrix.slice_range(i.., i).icamax() + i;
             let diag = matrix[(piv, i)];
 
             if diag.is_zero() {
@@ -197,7 +197,7 @@ where DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimu
     }
 }
 
-impl<N: Real, D: DimMin<D, Output = D>> LU<N, D, D>
+impl<N: ComplexField, D: DimMin<D, Output = D>> LU<N, D, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), D>
 {
     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
@@ -368,7 +368,7 @@ pub fn gauss_step_swap<N, R: Dim, C: Dim, S>(
     }
 }
 
-impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
+impl<N: ComplexField, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
 where DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>
 {
     /// Computes the LU decomposition with partial (row) pivoting of `matrix`.
diff --git a/src/linalg/permutation_sequence.rs b/src/linalg/permutation_sequence.rs
index 3aef1be62..ce493905e 100644
--- a/src/linalg/permutation_sequence.rs
+++ b/src/linalg/permutation_sequence.rs
@@ -4,12 +4,12 @@ use serde::{Deserialize, Serialize};
 use alga::general::ClosedNeg;
 use num::One;
 
-use allocator::Allocator;
-use base::{DefaultAllocator, Matrix, Scalar, VectorN};
+use crate::allocator::Allocator;
+use crate::base::{DefaultAllocator, Matrix, Scalar, VectorN};
 #[cfg(any(feature = "std", feature = "alloc"))]
-use dimension::Dynamic;
-use dimension::{Dim, DimName, U1};
-use storage::StorageMut;
+use crate::dimension::Dynamic;
+use crate::dimension::{Dim, DimName, U1};
+use crate::storage::StorageMut;
 
 /// A sequence of row or column permutations.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
diff --git a/src/linalg/qr.rs b/src/linalg/qr.rs
index 81f722697..683c11b8c 100644
--- a/src/linalg/qr.rs
+++ b/src/linalg/qr.rs
@@ -1,15 +1,16 @@
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Serialize};
+use num::Zero;
 
-use alga::general::Real;
-use allocator::{Allocator, Reallocator};
-use base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Unit, VectorN};
-use constraint::{SameNumberOfRows, ShapeConstraint};
-use dimension::{Dim, DimMin, DimMinimum, U1};
-use storage::{Storage, StorageMut};
+use alga::general::ComplexField;
+use crate::allocator::{Allocator, Reallocator};
+use crate::base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Unit, VectorN};
+use crate::constraint::{SameNumberOfRows, ShapeConstraint};
+use crate::dimension::{Dim, DimMin, DimMinimum, U1};
+use crate::storage::{Storage, StorageMut};
 
-use geometry::Reflection;
-use linalg::householder;
+use crate::geometry::Reflection;
+use crate::linalg::householder;
 
 /// The QR decomposition of a general matrix.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
@@ -32,21 +33,21 @@ use linalg::householder;
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct QR<N: Real, R: DimMin<C>, C: Dim>
+pub struct QR<N: ComplexField, R: DimMin<C>, C: Dim>
 where DefaultAllocator: Allocator<N, R, C> + Allocator<N, DimMinimum<R, C>>
 {
     qr: MatrixMN<N, R, C>,
     diag: VectorN<N, DimMinimum<R, C>>,
 }
 
-impl<N: Real, R: DimMin<C>, C: Dim> Copy for QR<N, R, C>
+impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for QR<N, R, C>
 where
     DefaultAllocator: Allocator<N, R, C> + Allocator<N, DimMinimum<R, C>>,
     MatrixMN<N, R, C>: Copy,
     VectorN<N, DimMinimum<R, C>>: Copy,
 {}
 
-impl<N: Real, R: DimMin<C>, C: Dim> QR<N, R, C>
+impl<N: ComplexField, R: DimMin<C>, C: Dim> QR<N, R, C>
 where DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, DimMinimum<R, C>>
 {
     /// Computes the QR decomposition using householder reflections.
@@ -78,12 +79,10 @@ where DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, DimM
     pub fn r(&self) -> MatrixMN<N, DimMinimum<R, C>, C>
     where
         DefaultAllocator: Allocator<N, DimMinimum<R, C>, C>,
-        // FIXME: the following bound is ugly.
-        DimMinimum<R, C>: DimMin<C, Output = DimMinimum<R, C>>,
     {
         let (nrows, ncols) = self.qr.data.shape();
         let mut res = self.qr.rows_generic(0, nrows.min(ncols)).upper_triangle();
-        res.set_diagonal(&self.diag);
+        res.set_partial_diagonal(self.diag.iter().map(|e| N::from_real(e.modulus())));
         res
     }
 
@@ -94,13 +93,11 @@ where DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, DimM
     pub fn unpack_r(self) -> MatrixMN<N, DimMinimum<R, C>, C>
     where
         DefaultAllocator: Reallocator<N, R, C, DimMinimum<R, C>, C>,
-        // FIXME: the following bound is ugly (needed by `set_diagonal`).
-        DimMinimum<R, C>: DimMin<C, Output = DimMinimum<R, C>>,
     {
         let (nrows, ncols) = self.qr.data.shape();
         let mut res = self.qr.resize_generic(nrows.min(ncols), ncols, N::zero());
         res.fill_lower_triangle(N::zero(), 1);
-        res.set_diagonal(&self.diag);
+        res.set_partial_diagonal(self.diag.iter().map(|e| N::from_real(e.modulus())));
         res
     }
 
@@ -120,7 +117,7 @@ where DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, DimM
             let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
 
             let mut res_rows = res.slice_range_mut(i.., i..);
-            refl.reflect(&mut res_rows);
+            refl.reflect_with_sign(&mut res_rows, self.diag[i].signum());
         }
 
         res
@@ -157,12 +154,12 @@ where DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, DimM
             let refl = Reflection::new(Unit::new_unchecked(axis), N::zero());
 
             let mut rhs_rows = rhs.rows_range_mut(i..);
-            refl.reflect(&mut rhs_rows);
+            refl.reflect_with_sign(&mut rhs_rows, self.diag[i].signum().conjugate());
         }
     }
 }
 
-impl<N: Real, D: DimMin<D, Output = D>> QR<N, D, D>
+impl<N: ComplexField, D: DimMin<D, Output = D>> QR<N, D, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
@@ -226,13 +223,13 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
                 let coeff;
 
                 unsafe {
-                    let diag = *self.diag.vget_unchecked(i);
+                    let diag = self.diag.vget_unchecked(i).modulus();
 
                     if diag.is_zero() {
                         return false;
                     }
 
-                    coeff = *b.vget_unchecked(i) / diag;
+                    coeff = b.vget_unchecked(i).unscale(diag);
                     *b.vget_unchecked_mut(i) = coeff;
                 }
 
@@ -294,7 +291,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
     // }
 }
 
-impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
+impl<N: ComplexField, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
 where DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, DimMinimum<R, C>>
 {
     /// Computes the QR decomposition of this matrix.
diff --git a/src/linalg/schur.rs b/src/linalg/schur.rs
index 0d4250878..b31be9f67 100644
--- a/src/linalg/schur.rs
+++ b/src/linalg/schur.rs
@@ -1,21 +1,24 @@
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Serialize};
 
-use alga::general::Real;
-use num_complex::Complex;
+use approx::AbsDiffEq;
+use alga::general::{ComplexField, RealField};
+use num_complex::Complex as NumComplex;
 use std::cmp;
 
-use allocator::Allocator;
-use base::dimension::{Dim, DimDiff, DimSub, Dynamic, U1, U2, U3};
-use base::storage::Storage;
-use base::{DefaultAllocator, MatrixN, SquareMatrix, Unit, Vector2, Vector3, VectorN};
-use constraint::{DimEq, ShapeConstraint};
+use crate::allocator::Allocator;
+use crate::base::dimension::{Dim, DimDiff, DimSub, Dynamic, U1, U2, U3};
+use crate::base::storage::Storage;
+use crate::base::{DefaultAllocator, MatrixN, SquareMatrix, Unit, Vector2, Vector3, VectorN};
 
-use geometry::{Reflection, UnitComplex};
-use linalg::householder;
-use linalg::Hessenberg;
+use crate::geometry::Reflection;
+use crate::linalg::householder;
+use crate::linalg::Hessenberg;
+use crate::linalg::givens::GivensRotation;
 
-/// Real Schur decomposition of a square matrix.
+/// Schur decomposition of a square matrix.
+///
+/// If this is a real matrix, this will be a RealField Schur decomposition.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
@@ -32,23 +35,22 @@ use linalg::Hessenberg;
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct RealSchur<N: Real, D: Dim>
+pub struct Schur<N: ComplexField, D: Dim>
 where DefaultAllocator: Allocator<N, D, D>
 {
     q: MatrixN<N, D>,
     t: MatrixN<N, D>,
 }
 
-impl<N: Real, D: Dim> Copy for RealSchur<N, D>
+impl<N: ComplexField, D: Dim> Copy for Schur<N, D>
 where
     DefaultAllocator: Allocator<N, D, D>,
     MatrixN<N, D>: Copy,
 {}
 
-impl<N: Real, D: Dim> RealSchur<N, D>
+impl<N: ComplexField, D: Dim> Schur<N, D>
 where
     D: DimSub<U1>,                                   // For Hessenberg.
-    ShapeConstraint: DimEq<Dynamic, DimDiff<D, U1>>, // For Hessenberg.
     DefaultAllocator: Allocator<N, D, DimDiff<D, U1>>
         + Allocator<N, DimDiff<D, U1>>
         + Allocator<N, D, D>
@@ -56,7 +58,7 @@ where
 {
     /// Computes the Schur decomposition of a square matrix.
     pub fn new(m: MatrixN<N, D>) -> Self {
-        Self::try_new(m, N::default_epsilon(), 0).unwrap()
+        Self::try_new(m, N::RealField::default_epsilon(), 0).unwrap()
     }
 
     /// Attempts to compute the Schur decomposition of a square matrix.
@@ -70,10 +72,10 @@ where
     /// * `max_niter` − maximum total number of iterations performed by the algorithm. If this
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.
-    pub fn try_new(m: MatrixN<N, D>, eps: N, max_niter: usize) -> Option<Self> {
+    pub fn try_new(m: MatrixN<N, D>, eps: N::RealField, max_niter: usize) -> Option<Self> {
         let mut work = unsafe { VectorN::new_uninitialized_generic(m.data.shape().0, U1) };
 
-        Self::do_decompose(m, &mut work, eps, max_niter, true).map(|(q, t)| RealSchur {
+        Self::do_decompose(m, &mut work, eps, max_niter, true).map(|(q, t)| Schur {
             q: q.unwrap(),
             t: t,
         })
@@ -82,7 +84,7 @@ where
     fn do_decompose(
         mut m: MatrixN<N, D>,
         work: &mut VectorN<N, D>,
-        eps: N,
+        eps: N::RealField,
         max_niter: usize,
         compute_q: bool,
     ) -> Option<(Option<MatrixN<N, D>>, MatrixN<N, D>)>
@@ -94,6 +96,7 @@ where
 
         let dim = m.data.shape().0;
 
+        // Specialization would make this easier.
         if dim.value() == 0 {
             let vecs = Some(MatrixN::from_element_generic(dim, dim, N::zero()));
             let vals = MatrixN::from_element_generic(dim, dim, N::zero());
@@ -105,14 +108,12 @@ where
             } else {
                 return Some((None, m));
             }
-        }
-        // Specialization would make this easier.
-        else if dim.value() == 2 {
+        } else if dim.value() == 2 {
             return decompose_2x2(m, compute_q);
         }
 
-        let amax_m = m.amax();
-        m /= amax_m;
+        let amax_m = m.camax();
+        m.unscale_mut(amax_m);
 
         let hess = Hessenberg::new_with_workspace(m, work);
         let mut q;
@@ -259,7 +260,7 @@ where
             }
         }
 
-        t *= amax_m;
+        t.scale_mut(amax_m);
 
         Some((q, t))
     }
@@ -289,8 +290,9 @@ where
     }
 
     /// Computes the complex eigenvalues of the decomposed matrix.
-    fn do_complex_eigenvalues(t: &MatrixN<N, D>, out: &mut VectorN<Complex<N>, D>)
-    where DefaultAllocator: Allocator<Complex<N>, D> {
+    fn do_complex_eigenvalues(t: &MatrixN<N, D>, out: &mut VectorN<NumComplex<N>, D>)
+    where N: RealField,
+          DefaultAllocator: Allocator<NumComplex<N>, D> {
         let dim = t.nrows();
         let mut m = 0;
 
@@ -298,7 +300,7 @@ where
             let n = m + 1;
 
             if t[(n, m)].is_zero() {
-                out[m] = Complex::new(t[(m, m)], N::zero());
+                out[m] = NumComplex::new(t[(m, m)], N::zero());
                 m += 1;
             } else {
                 // Solve the 2x2 eigenvalue subproblem.
@@ -309,25 +311,25 @@ where
 
                 let tra = hnn + hmm;
                 let det = hnn * hmm - hnm * hmn;
-                let discr = tra * tra * ::convert(0.25) - det;
+                let discr = tra * tra * crate::convert(0.25) - det;
 
                 // All 2x2 blocks have negative discriminant because we already decoupled those
                 // with positive eigenvalues..
-                let sqrt_discr = Complex::new(N::zero(), (-discr).sqrt());
+                let sqrt_discr = NumComplex::new(N::zero(), (-discr).sqrt());
 
-                out[m] = Complex::new(tra * ::convert(0.5), N::zero()) + sqrt_discr;
-                out[m + 1] = Complex::new(tra * ::convert(0.5), N::zero()) - sqrt_discr;
+                out[m] = NumComplex::new(tra * crate::convert(0.5), N::zero()) + sqrt_discr;
+                out[m + 1] = NumComplex::new(tra * crate::convert(0.5), N::zero()) - sqrt_discr;
 
                 m += 2;
             }
         }
 
         if m == dim - 1 {
-            out[m] = Complex::new(t[(m, m)], N::zero());
+            out[m] = NumComplex::new(t[(m, m)], N::zero());
         }
     }
 
-    fn delimit_subproblem(t: &mut MatrixN<N, D>, eps: N, end: usize) -> (usize, usize)
+    fn delimit_subproblem(t: &mut MatrixN<N, D>, eps: N::RealField, end: usize) -> (usize, usize)
     where
         D: DimSub<U1>,
         DefaultAllocator: Allocator<N, DimDiff<D, U1>>,
@@ -337,7 +339,7 @@ where
         while n > 0 {
             let m = n - 1;
 
-            if t[(n, m)].abs() <= eps * (t[(n, n)].abs() + t[(m, m)].abs()) {
+            if t[(n, m)].norm1() <= eps * (t[(n, n)].norm1() + t[(m, m)].norm1()) {
                 t[(n, m)] = N::zero();
             } else {
                 break;
@@ -356,7 +358,7 @@ where
 
             let off_diag = t[(new_start, m)];
             if off_diag.is_zero()
-                || off_diag.abs() <= eps * (t[(new_start, new_start)].abs() + t[(m, m)].abs())
+                || off_diag.norm1() <= eps * (t[(new_start, new_start)].norm1() + t[(m, m)].norm1())
             {
                 t[(new_start, m)] = N::zero();
                 break;
@@ -387,15 +389,16 @@ where
     }
 
     /// Computes the complex eigenvalues of the decomposed matrix.
-    pub fn complex_eigenvalues(&self) -> VectorN<Complex<N>, D>
-    where DefaultAllocator: Allocator<Complex<N>, D> {
+    pub fn complex_eigenvalues(&self) -> VectorN<NumComplex<N>, D>
+    where N: RealField,
+          DefaultAllocator: Allocator<NumComplex<N>, D> {
         let mut out = unsafe { VectorN::new_uninitialized_generic(self.t.data.shape().0, U1) };
         Self::do_complex_eigenvalues(&self.t, &mut out);
         out
     }
 }
 
-fn decompose_2x2<N: Real, D: Dim>(
+fn decompose_2x2<N: ComplexField, D: Dim>(
     mut m: MatrixN<N, D>,
     compute_q: bool,
 ) -> Option<(Option<MatrixN<N, D>>, MatrixN<N, D>)>
@@ -412,13 +415,13 @@ where
             rot.rotate_rows(&mut m);
 
             if compute_q {
-                let c = rot.into_inner();
                 // XXX: we have to build the matrix manually because
                 // rot.to_rotation_matrix().unwrap() causes an ICE.
+                let c = N::from_real(rot.c());
                 q = Some(MatrixN::from_column_slice_generic(
                     dim,
                     dim,
-                    &[c.re, c.im, -c.im, c.re],
+                    &[c, rot.s(), -rot.s().conjugate(), c],
                 ));
             }
         }
@@ -432,7 +435,7 @@ where
     Some((q, m))
 }
 
-fn compute_2x2_eigvals<N: Real, S: Storage<N, U2, U2>>(
+fn compute_2x2_eigvals<N: ComplexField, S: Storage<N, U2, U2>>(
     m: &SquareMatrix<N, U2, S>,
 ) -> Option<(N, N)> {
     // Solve the 2x2 eigenvalue subproblem.
@@ -441,19 +444,16 @@ fn compute_2x2_eigvals<N: Real, S: Storage<N, U2, U2>>(
     let h01 = m[(0, 1)];
     let h11 = m[(1, 1)];
 
-    // NOTE: this discriminant computation is mor stable than the
+    // NOTE: this discriminant computation is more stable than the
     // one based on the trace and determinant: 0.25 * tra * tra - det
-    // because et ensures positiveness for symmetric matrices.
-    let val = (h00 - h11) * ::convert(0.5);
+    // because it ensures positiveness for symmetric matrices.
+    let val = (h00 - h11) * crate::convert(0.5);
     let discr = h10 * h01 + val * val;
 
-    if discr >= N::zero() {
-        let sqrt_discr = discr.sqrt();
-        let half_tra = (h00 + h11) * ::convert(0.5);
-        Some((half_tra + sqrt_discr, half_tra - sqrt_discr))
-    } else {
-        None
-    }
+    discr.try_sqrt().map(|sqrt_discr| {
+        let half_tra = (h00 + h11) * crate::convert(0.5);
+        (half_tra + sqrt_discr, half_tra - sqrt_discr)
+    })
 }
 
 // Computes the 2x2 transformation that upper-triangulates a 2x2 matrix with real eigenvalues.
@@ -461,9 +461,9 @@ fn compute_2x2_eigvals<N: Real, S: Storage<N, U2, U2>>(
 ///
 /// Returns `None` if the matrix has complex eigenvalues, or is upper-triangular. In both case,
 /// the basis is the identity.
-fn compute_2x2_basis<N: Real, S: Storage<N, U2, U2>>(
+fn compute_2x2_basis<N: ComplexField, S: Storage<N, U2, U2>>(
     m: &SquareMatrix<N, U2, S>,
-) -> Option<UnitComplex<N>> {
+) -> Option<GivensRotation<N>> {
     let h10 = m[(1, 0)];
 
     if h10.is_zero() {
@@ -471,36 +471,33 @@ fn compute_2x2_basis<N: Real, S: Storage<N, U2, U2>>(
     }
 
     if let Some((eigval1, eigval2)) = compute_2x2_eigvals(m) {
-        let x1 = m[(1, 1)] - eigval1;
-        let x2 = m[(1, 1)] - eigval2;
+        let x1 = eigval1 - m[(1, 1)];
+        let x2 = eigval2 - m[(1, 1)];
 
         // NOTE: Choose the one that yields a larger x component.
         // This is necessary for numerical stability of the normalization of the complex
         // number.
-        let basis = if x1.abs() > x2.abs() {
-            Complex::new(x1, -h10)
+        if x1.norm1() > x2.norm1() {
+            Some(GivensRotation::new(x1, h10).0)
         } else {
-            Complex::new(x2, -h10)
-        };
-
-        Some(UnitComplex::from_complex(basis))
+            Some(GivensRotation::new(x2, h10).0)
+        }
     } else {
         None
     }
 }
 
-impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S>
+impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S>
 where
     D: DimSub<U1>,                                   // For Hessenberg.
-    ShapeConstraint: DimEq<Dynamic, DimDiff<D, U1>>, // For Hessenberg.
     DefaultAllocator: Allocator<N, D, DimDiff<D, U1>>
         + Allocator<N, DimDiff<D, U1>>
         + Allocator<N, D, D>
         + Allocator<N, D>,
 {
     /// Computes the Schur decomposition of a square matrix.
-    pub fn real_schur(self) -> RealSchur<N, D> {
-        RealSchur::new(self.into_owned())
+    pub fn schur(self) -> Schur<N, D> {
+        Schur::new(self.into_owned())
     }
 
     /// Attempts to compute the Schur decomposition of a square matrix.
@@ -514,8 +511,8 @@ where
     /// * `max_niter` − maximum total number of iterations performed by the algorithm. If this
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.
-    pub fn try_real_schur(self, eps: N, max_niter: usize) -> Option<RealSchur<N, D>> {
-        RealSchur::try_new(self.into_owned(), eps, max_niter)
+    pub fn try_schur(self, eps: N::RealField, max_niter: usize) -> Option<Schur<N, D>> {
+        Schur::try_new(self.into_owned(), eps, max_niter)
     }
 
     /// Computes the eigenvalues of this matrix.
@@ -543,15 +540,15 @@ where
         }
 
         // FIXME: add balancing?
-        let schur = RealSchur::do_decompose(
+        let schur = Schur::do_decompose(
             self.clone_owned(),
             &mut work,
-            N::default_epsilon(),
+            N::RealField::default_epsilon(),
             0,
             false,
         )
         .unwrap();
-        if RealSchur::do_eigenvalues(&schur.1, &mut work) {
+        if Schur::do_eigenvalues(&schur.1, &mut work) {
             Some(work)
         } else {
             None
@@ -559,13 +556,14 @@ where
     }
 
     /// Computes the eigenvalues of this matrix.
-    pub fn complex_eigenvalues(&self) -> VectorN<Complex<N>, D>
+    pub fn complex_eigenvalues(&self) -> VectorN<NumComplex<N>, D>
     // FIXME: add balancing?
-    where DefaultAllocator: Allocator<Complex<N>, D> {
+    where N: RealField,
+          DefaultAllocator: Allocator<NumComplex<N>, D> {
         let dim = self.data.shape().0;
         let mut work = unsafe { VectorN::new_uninitialized_generic(dim, U1) };
 
-        let schur = RealSchur::do_decompose(
+        let schur = Schur::do_decompose(
             self.clone_owned(),
             &mut work,
             N::default_epsilon(),
@@ -574,7 +572,7 @@ where
         )
         .unwrap();
         let mut eig = unsafe { VectorN::new_uninitialized_generic(dim, U1) };
-        RealSchur::do_complex_eigenvalues(&schur.1, &mut eig);
+        Schur::do_complex_eigenvalues(&schur.1, &mut eig);
         eig
     }
 }
diff --git a/src/linalg/solve.rs b/src/linalg/solve.rs
index 4d2d103f5..f10b1d004 100644
--- a/src/linalg/solve.rs
+++ b/src/linalg/solve.rs
@@ -1,12 +1,12 @@
-use alga::general::Real;
+use alga::general::ComplexField;
 
-use base::allocator::Allocator;
-use base::constraint::{SameNumberOfRows, ShapeConstraint};
-use base::dimension::{Dim, U1};
-use base::storage::{Storage, StorageMut};
-use base::{DefaultAllocator, Matrix, MatrixMN, SquareMatrix, Vector};
+use crate::base::allocator::Allocator;
+use crate::base::constraint::{SameNumberOfRows, ShapeConstraint};
+use crate::base::dimension::{Dim, U1};
+use crate::base::storage::{Storage, StorageMut};
+use crate::base::{DefaultAllocator, Matrix, MatrixMN, SquareMatrix, Vector, DVectorSlice};
 
-impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
+impl<N: ComplexField, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// Computes the solution of the linear system `self . x = b` where `x` is the unknown and only
     /// the lower-triangular part of `self` (including the diagonal) is considered not-zero.
     #[inline]
@@ -180,10 +180,9 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
 
     /*
      *
-     * Transpose versions
+     * Transpose and adjoint versions
      *
      */
-
     /// Computes the solution of the linear system `self.transpose() . x = b` where `x` is the unknown and only
     /// the lower-triangular part of `self` (including the diagonal) is considered not-zero.
     #[inline]
@@ -191,10 +190,10 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         &self,
         b: &Matrix<N, R2, C2, S2>,
     ) -> Option<MatrixMN<N, R2, C2>>
-    where
-        S2: StorageMut<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
-        ShapeConstraint: SameNumberOfRows<R2, D>,
+        where
+            S2: StorageMut<N, R2, C2>,
+            DefaultAllocator: Allocator<N, R2, C2>,
+            ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
         if self.tr_solve_lower_triangular_mut(&mut res) {
@@ -211,10 +210,10 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         &self,
         b: &Matrix<N, R2, C2, S2>,
     ) -> Option<MatrixMN<N, R2, C2>>
-    where
-        S2: StorageMut<N, R2, C2>,
-        DefaultAllocator: Allocator<N, R2, C2>,
-        ShapeConstraint: SameNumberOfRows<R2, D>,
+        where
+            S2: StorageMut<N, R2, C2>,
+            DefaultAllocator: Allocator<N, R2, C2>,
+            ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let mut res = b.clone_owned();
         if self.tr_solve_upper_triangular_mut(&mut res) {
@@ -230,14 +229,14 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         &self,
         b: &mut Matrix<N, R2, C2, S2>,
     ) -> bool
-    where
-        S2: StorageMut<N, R2, C2>,
-        ShapeConstraint: SameNumberOfRows<R2, D>,
+        where
+            S2: StorageMut<N, R2, C2>,
+            ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let cols = b.ncols();
 
         for i in 0..cols {
-            if !self.tr_solve_lower_triangular_vector_mut(&mut b.column_mut(i)) {
+            if !self.xx_solve_lower_triangular_vector_mut(&mut b.column_mut(i), |e| e, |a, b| a.dot(b)) {
                 return false;
             }
         }
@@ -245,46 +244,102 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         true
     }
 
-    fn tr_solve_lower_triangular_vector_mut<R2: Dim, S2>(&self, b: &mut Vector<N, R2, S2>) -> bool
-    where
-        S2: StorageMut<N, R2, U1>,
-        ShapeConstraint: SameNumberOfRows<R2, D>,
+    /// Solves the linear system `self.transpose() . x = b` where `x` is the unknown and only the
+    /// upper-triangular part of `self` (including the diagonal) is considered not-zero.
+    pub fn tr_solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
+        &self,
+        b: &mut Matrix<N, R2, C2, S2>,
+    ) -> bool
+        where
+            S2: StorageMut<N, R2, C2>,
+            ShapeConstraint: SameNumberOfRows<R2, D>,
     {
-        let dim = self.nrows();
+        let cols = b.ncols();
 
-        for i in (0..dim).rev() {
-            let dot = self.slice_range(i + 1.., i).dot(&b.slice_range(i + 1.., 0));
+        for i in 0..cols {
+            if !self.xx_solve_upper_triangular_vector_mut(&mut b.column_mut(i), |e| e, |a, b| a.dot(b)) {
+                return false;
+            }
+        }
 
-            unsafe {
-                let b_i = b.vget_unchecked_mut(i);
+        true
+    }
 
-                let diag = *self.get_unchecked((i, i));
+    /// Computes the solution of the linear system `self.adjoint() . x = b` where `x` is the unknown and only
+    /// the lower-triangular part of `self` (including the diagonal) is considered not-zero.
+    #[inline]
+    pub fn ad_solve_lower_triangular<R2: Dim, C2: Dim, S2>(
+        &self,
+        b: &Matrix<N, R2, C2, S2>,
+    ) -> Option<MatrixMN<N, R2, C2>>
+        where
+            S2: StorageMut<N, R2, C2>,
+            DefaultAllocator: Allocator<N, R2, C2>,
+            ShapeConstraint: SameNumberOfRows<R2, D>,
+    {
+        let mut res = b.clone_owned();
+        if self.ad_solve_lower_triangular_mut(&mut res) {
+            Some(res)
+        } else {
+            None
+        }
+    }
 
-                if diag.is_zero() {
-                    return false;
-                }
+    /// Computes the solution of the linear system `self.adjoint() . x = b` where `x` is the unknown and only
+    /// the upper-triangular part of `self` (including the diagonal) is considered not-zero.
+    #[inline]
+    pub fn ad_solve_upper_triangular<R2: Dim, C2: Dim, S2>(
+        &self,
+        b: &Matrix<N, R2, C2, S2>,
+    ) -> Option<MatrixMN<N, R2, C2>>
+        where
+            S2: StorageMut<N, R2, C2>,
+            DefaultAllocator: Allocator<N, R2, C2>,
+            ShapeConstraint: SameNumberOfRows<R2, D>,
+    {
+        let mut res = b.clone_owned();
+        if self.ad_solve_upper_triangular_mut(&mut res) {
+            Some(res)
+        } else {
+            None
+        }
+    }
 
-                *b_i = (*b_i - dot) / diag;
+    /// Solves the linear system `self.adjoint() . x = b` where `x` is the unknown and only the
+    /// lower-triangular part of `self` (including the diagonal) is considered not-zero.
+    pub fn ad_solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>(
+        &self,
+        b: &mut Matrix<N, R2, C2, S2>,
+    ) -> bool
+        where
+            S2: StorageMut<N, R2, C2>,
+            ShapeConstraint: SameNumberOfRows<R2, D>,
+    {
+        let cols = b.ncols();
+
+        for i in 0..cols {
+            if !self.xx_solve_lower_triangular_vector_mut(&mut b.column_mut(i), |e| e.conjugate(), |a, b| a.dotc(b)) {
+                return false;
             }
         }
 
         true
     }
 
-    /// Solves the linear system `self.transpose() . x = b` where `x` is the unknown and only the
+    /// Solves the linear system `self.adjoint() . x = b` where `x` is the unknown and only the
     /// upper-triangular part of `self` (including the diagonal) is considered not-zero.
-    pub fn tr_solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
+    pub fn ad_solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
         b: &mut Matrix<N, R2, C2, S2>,
     ) -> bool
-    where
-        S2: StorageMut<N, R2, C2>,
-        ShapeConstraint: SameNumberOfRows<R2, D>,
+        where
+            S2: StorageMut<N, R2, C2>,
+            ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let cols = b.ncols();
 
         for i in 0..cols {
-            if !self.tr_solve_upper_triangular_vector_mut(&mut b.column_mut(i)) {
+            if !self.xx_solve_upper_triangular_vector_mut(&mut b.column_mut(i), |e| e.conjugate(), |a, b| a.dotc(b)) {
                 return false;
             }
         }
@@ -292,19 +347,58 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
         true
     }
 
-    fn tr_solve_upper_triangular_vector_mut<R2: Dim, S2>(&self, b: &mut Vector<N, R2, S2>) -> bool
-    where
-        S2: StorageMut<N, R2, U1>,
-        ShapeConstraint: SameNumberOfRows<R2, D>,
+
+    #[inline(always)]
+    fn xx_solve_lower_triangular_vector_mut<R2: Dim, S2>(
+        &self,
+        b: &mut Vector<N, R2, S2>,
+        conjugate: impl Fn(N) -> N,
+        dot: impl Fn(&DVectorSlice<N, S::RStride, S::CStride>, &DVectorSlice<N, S2::RStride, S2::CStride>) -> N,
+    ) -> bool
+        where
+            S2: StorageMut<N, R2, U1>,
+            ShapeConstraint: SameNumberOfRows<R2, D>,
+    {
+        let dim = self.nrows();
+
+        for i in (0..dim).rev() {
+            let dot = dot(&self.slice_range(i + 1.., i), &b.slice_range(i + 1.., 0));
+
+            unsafe {
+                let b_i = b.vget_unchecked_mut(i);
+
+                let diag = conjugate(*self.get_unchecked((i, i)));
+
+                if diag.is_zero() {
+                    return false;
+                }
+
+                *b_i = (*b_i - dot) / diag;
+            }
+        }
+
+        true
+    }
+
+    #[inline(always)]
+    fn xx_solve_upper_triangular_vector_mut<R2: Dim, S2>(
+        &self,
+        b: &mut Vector<N, R2, S2>,
+        conjugate: impl Fn(N) -> N,
+        dot: impl Fn(&DVectorSlice<N, S::RStride, S::CStride>, &DVectorSlice<N, S2::RStride, S2::CStride>) -> N,
+    ) -> bool
+        where
+            S2: StorageMut<N, R2, U1>,
+            ShapeConstraint: SameNumberOfRows<R2, D>,
     {
         let dim = self.nrows();
 
         for i in 0..dim {
-            let dot = self.slice_range(..i, i).dot(&b.slice_range(..i, 0));
+            let dot = dot(&self.slice_range(..i, i), &b.slice_range(..i, 0));
 
             unsafe {
                 let b_i = b.vget_unchecked_mut(i);
-                let diag = *self.get_unchecked((i, i));
+                let diag = conjugate(*self.get_unchecked((i, i)));
 
                 if diag.is_zero() {
                     return false;
diff --git a/src/linalg/svd.rs b/src/linalg/svd.rs
index 67b49604e..b608ec0cd 100644
--- a/src/linalg/svd.rs
+++ b/src/linalg/svd.rs
@@ -1,72 +1,69 @@
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Serialize};
 
-use num_complex::Complex;
-use std::ops::MulAssign;
+use num::{Zero, One};
+use approx::AbsDiffEq;
 
-use alga::general::Real;
-use allocator::Allocator;
-use base::{DefaultAllocator, Matrix, Matrix2x3, MatrixMN, Vector2, VectorN};
-use constraint::{SameNumberOfRows, ShapeConstraint};
-use dimension::{Dim, DimDiff, DimMin, DimMinimum, DimSub, U1, U2};
-use storage::Storage;
+use alga::general::{RealField, ComplexField};
+use crate::allocator::Allocator;
+use crate::base::{DefaultAllocator, Matrix, Matrix2x3, MatrixMN, Vector2, VectorN};
+use crate::constraint::{SameNumberOfRows, ShapeConstraint};
+use crate::dimension::{Dim, DimDiff, DimMin, DimMinimum, DimSub, U1, U2};
+use crate::storage::Storage;
 
-use geometry::UnitComplex;
-use linalg::givens;
-use linalg::symmetric_eigen;
-use linalg::Bidiagonal;
+use crate::linalg::symmetric_eigen;
+use crate::linalg::Bidiagonal;
+use crate::linalg::givens::GivensRotation;
 
 /// Singular Value Decomposition of a general matrix.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(
-        serialize = "DefaultAllocator: Allocator<N, R, C>                +
-                           Allocator<N, DimMinimum<R, C>>    +
+        serialize = "DefaultAllocator: Allocator<N::RealField, DimMinimum<R, C>>    +
                            Allocator<N, DimMinimum<R, C>, C> +
                            Allocator<N, R, DimMinimum<R, C>>,
          MatrixMN<N, R, DimMinimum<R, C>>: Serialize,
          MatrixMN<N, DimMinimum<R, C>, C>: Serialize,
-         VectorN<N, DimMinimum<R, C>>: Serialize"
+         VectorN<N::RealField, DimMinimum<R, C>>: Serialize"
     ))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(
-        deserialize = "DefaultAllocator: Allocator<N, R, C>                +
-                           Allocator<N, DimMinimum<R, C>>    +
+        deserialize = "DefaultAllocator: Allocator<N::RealField, DimMinimum<R, C>>    +
                            Allocator<N, DimMinimum<R, C>, C> +
                            Allocator<N, R, DimMinimum<R, C>>,
          MatrixMN<N, R, DimMinimum<R, C>>: Deserialize<'de>,
          MatrixMN<N, DimMinimum<R, C>, C>: Deserialize<'de>,
-         VectorN<N, DimMinimum<R, C>>: Deserialize<'de>"
+         VectorN<N::RealField, DimMinimum<R, C>>: Deserialize<'de>"
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct SVD<N: Real, R: DimMin<C>, C: Dim>
+pub struct SVD<N: ComplexField, R: DimMin<C>, C: Dim>
 where DefaultAllocator: Allocator<N, DimMinimum<R, C>, C>
         + Allocator<N, R, DimMinimum<R, C>>
-        + Allocator<N, DimMinimum<R, C>>
+        + Allocator<N::RealField, DimMinimum<R, C>>
 {
     /// The left-singular vectors `U` of this SVD.
     pub u: Option<MatrixMN<N, R, DimMinimum<R, C>>>,
     /// The right-singular vectors `V^t` of this SVD.
     pub v_t: Option<MatrixMN<N, DimMinimum<R, C>, C>>,
     /// The singular values of this SVD.
-    pub singular_values: VectorN<N, DimMinimum<R, C>>,
+    pub singular_values: VectorN<N::RealField, DimMinimum<R, C>>,
 }
 
-impl<N: Real, R: DimMin<C>, C: Dim> Copy for SVD<N, R, C>
+impl<N: ComplexField, R: DimMin<C>, C: Dim> Copy for SVD<N, R, C>
 where
     DefaultAllocator: Allocator<N, DimMinimum<R, C>, C>
         + Allocator<N, R, DimMinimum<R, C>>
-        + Allocator<N, DimMinimum<R, C>>,
+        + Allocator<N::RealField, DimMinimum<R, C>>,
     MatrixMN<N, R, DimMinimum<R, C>>: Copy,
     MatrixMN<N, DimMinimum<R, C>, C>: Copy,
-    VectorN<N, DimMinimum<R, C>>: Copy,
+    VectorN<N::RealField, DimMinimum<R, C>>: Copy,
 {}
 
-impl<N: Real, R: DimMin<C>, C: Dim> SVD<N, R, C>
+impl<N: ComplexField, R: DimMin<C>, C: Dim> SVD<N, R, C>
 where
     DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
     DefaultAllocator: Allocator<N, R, C>
@@ -75,11 +72,13 @@ where
         + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>
         + Allocator<N, DimMinimum<R, C>, C>
         + Allocator<N, R, DimMinimum<R, C>>
-        + Allocator<N, DimMinimum<R, C>>,
+        + Allocator<N, DimMinimum<R, C>>
+        + Allocator<N::RealField, DimMinimum<R, C>>
+        + Allocator<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
 {
     /// Computes the Singular Value Decomposition of `matrix` using implicit shift.
     pub fn new(matrix: MatrixMN<N, R, C>, compute_u: bool, compute_v: bool) -> Self {
-        Self::try_new(matrix, compute_u, compute_v, N::default_epsilon(), 0).unwrap()
+        Self::try_new(matrix, compute_u, compute_v, N::RealField::default_epsilon(), 0).unwrap()
     }
 
     /// Attempts to compute the Singular Value Decomposition of `matrix` using implicit shift.
@@ -96,7 +95,7 @@ where
         mut matrix: MatrixMN<N, R, C>,
         compute_u: bool,
         compute_v: bool,
-        eps: N,
+        eps: N::RealField,
         max_niter: usize,
     ) -> Option<Self>
     {
@@ -108,18 +107,20 @@ where
         let min_nrows_ncols = nrows.min(ncols);
         let dim = min_nrows_ncols.value();
 
-        let m_amax = matrix.amax();
+        let m_amax = matrix.camax();
 
         if !m_amax.is_zero() {
-            matrix /= m_amax;
+            matrix.unscale_mut(m_amax);
         }
 
-        let mut b = Bidiagonal::new(matrix);
+        let b = Bidiagonal::new(matrix);
         let mut u = if compute_u { Some(b.u()) } else { None };
         let mut v_t = if compute_v { Some(b.v_t()) } else { None };
+        let mut diagonal = b.diagonal();
+        let mut off_diagonal = b.off_diagonal();
 
         let mut niter = 0;
-        let (mut start, mut end) = Self::delimit_subproblem(&mut b, &mut u, &mut v_t, dim - 1, eps);
+        let (mut start, mut end) = Self::delimit_subproblem(&mut diagonal, &mut off_diagonal, &mut u, &mut v_t, b.is_upper_diagonal(), dim - 1, eps);
 
         while end != start {
             let subdim = end - start + 1;
@@ -131,52 +132,55 @@ where
 
                 let mut vec;
                 {
-                    let dm = b.diagonal[m];
-                    let dn = b.diagonal[n];
-                    let fm = b.off_diagonal[m];
+                    let dm = diagonal[m];
+                    let dn = diagonal[n];
+                    let fm = off_diagonal[m];
 
-                    let tmm = dm * dm + b.off_diagonal[m - 1] * b.off_diagonal[m - 1];
+                    let tmm = dm * dm + off_diagonal[m - 1] * off_diagonal[m - 1];
                     let tmn = dm * fm;
                     let tnn = dn * dn + fm * fm;
 
                     let shift = symmetric_eigen::wilkinson_shift(tmm, tnn, tmn);
 
                     vec = Vector2::new(
-                        b.diagonal[start] * b.diagonal[start] - shift,
-                        b.diagonal[start] * b.off_diagonal[start],
+                        diagonal[start] * diagonal[start] - shift,
+                        diagonal[start] * off_diagonal[start],
                     );
                 }
 
                 for k in start..n {
                     let m12 = if k == n - 1 {
-                        N::zero()
+                        N::RealField::zero()
                     } else {
-                        b.off_diagonal[k + 1]
+                        off_diagonal[k + 1]
                     };
 
                     let mut subm = Matrix2x3::new(
-                        b.diagonal[k],
-                        b.off_diagonal[k],
-                        N::zero(),
-                        N::zero(),
-                        b.diagonal[k + 1],
+                        diagonal[k],
+                        off_diagonal[k],
+                        N::RealField::zero(),
+                        N::RealField::zero(),
+                        diagonal[k + 1],
                         m12,
                     );
 
-                    if let Some((rot1, norm1)) = givens::cancel_y(&vec) {
-                        rot1.conjugate()
-                            .rotate_rows(&mut subm.fixed_columns_mut::<U2>(0));
+                    if let Some((rot1, norm1)) = GivensRotation::cancel_y(&vec) {
+                        rot1.inverse().rotate_rows(&mut subm.fixed_columns_mut::<U2>(0));
+                        let rot1 = GivensRotation::new_unchecked(rot1.c(), N::from_real(rot1.s()));
 
                         if k > start {
                             // This is not the first iteration.
-                            b.off_diagonal[k - 1] = norm1;
+                            off_diagonal[k - 1] = norm1;
                         }
 
                         let v = Vector2::new(subm[(0, 0)], subm[(1, 0)]);
                         // FIXME: does the case `v.y == 0` ever happen?
                         let (rot2, norm2) =
-                            givens::cancel_y(&v).unwrap_or((UnitComplex::identity(), subm[(0, 0)]));
+                            GivensRotation::cancel_y(&v).unwrap_or((GivensRotation::identity(), subm[(0, 0)]));
+
                         rot2.rotate(&mut subm.fixed_columns_mut::<U2>(1));
+                        let rot2 = GivensRotation::new_unchecked(rot2.c(), N::from_real(rot2.s()));
+
                         subm[(0, 0)] = norm2;
 
                         if let Some(ref mut v_t) = v_t {
@@ -197,12 +201,12 @@ where
                             }
                         }
 
-                        b.diagonal[k + 0] = subm[(0, 0)];
-                        b.diagonal[k + 1] = subm[(1, 1)];
-                        b.off_diagonal[k + 0] = subm[(0, 1)];
+                        diagonal[k + 0] = subm[(0, 0)];
+                        diagonal[k + 1] = subm[(1, 1)];
+                        off_diagonal[k + 0] = subm[(0, 1)];
 
                         if k != n - 1 {
-                            b.off_diagonal[k + 1] = subm[(1, 2)];
+                            off_diagonal[k + 1] = subm[(1, 2)];
                         }
 
                         vec.x = subm[(0, 1)];
@@ -213,17 +217,19 @@ where
                 }
             } else if subdim == 2 {
                 // Solve the remaining 2x2 subproblem.
-                let (u2, s, v2) = Self::compute_2x2_uptrig_svd(
-                    b.diagonal[start],
-                    b.off_diagonal[start],
-                    b.diagonal[start + 1],
+                let (u2, s, v2) = compute_2x2_uptrig_svd(
+                    diagonal[start],
+                    off_diagonal[start],
+                    diagonal[start + 1],
                     compute_u && b.is_upper_diagonal() || compute_v && !b.is_upper_diagonal(),
                     compute_v && b.is_upper_diagonal() || compute_u && !b.is_upper_diagonal(),
                 );
+                let u2 = u2.map(|u2| GivensRotation::new_unchecked(u2.c(), N::from_real(u2.s())));
+                let v2 = v2.map(|v2| GivensRotation::new_unchecked(v2.c(), N::from_real(v2.s())));
 
-                b.diagonal[start + 0] = s[0];
-                b.diagonal[start + 1] = s[1];
-                b.off_diagonal[start] = N::zero();
+                diagonal[start + 0] = s[0];
+                diagonal[start + 1] = s[1];
+                off_diagonal[start] = N::RealField::zero();
 
                 if let Some(ref mut u) = u {
                     let rot = if b.is_upper_diagonal() {
@@ -247,7 +253,7 @@ where
             }
 
             // Re-delimit the subproblem in case some decoupling occurred.
-            let sub = Self::delimit_subproblem(&mut b, &mut u, &mut v_t, end, eps);
+            let sub = Self::delimit_subproblem(&mut diagonal, &mut off_diagonal, &mut u, &mut v_t, b.is_upper_diagonal(), end, eps);
             start = sub.0;
             end = sub.1;
 
@@ -257,13 +263,14 @@ where
             }
         }
 
-        b.diagonal *= m_amax;
+        diagonal *= m_amax;
 
         // Ensure all singular value are non-negative.
         for i in 0..dim {
-            let sval = b.diagonal[i];
-            if sval < N::zero() {
-                b.diagonal[i] = -sval;
+            let sval = diagonal[i];
+
+            if sval < N::RealField::zero() {
+                diagonal[i] = -sval;
 
                 if let Some(ref mut u) = u {
                     u.column_mut(i).neg_mut();
@@ -272,56 +279,12 @@ where
         }
 
         Some(Self {
-            u: u,
-            v_t: v_t,
-            singular_values: b.diagonal,
+            u,
+            v_t,
+            singular_values: diagonal,
         })
     }
 
-    // Explicit formulaes inspired from the paper "Computing the Singular Values of 2-by-2 Complex
-    // Matrices", Sanzheng Qiao and Xiaohong Wang.
-    // http://www.cas.mcmaster.ca/sqrl/papers/sqrl5.pdf
-    fn compute_2x2_uptrig_svd(
-        m11: N,
-        m12: N,
-        m22: N,
-        compute_u: bool,
-        compute_v: bool,
-    ) -> (Option<UnitComplex<N>>, Vector2<N>, Option<UnitComplex<N>>)
-    {
-        let two: N = ::convert(2.0f64);
-        let half: N = ::convert(0.5f64);
-
-        let denom = (m11 + m22).hypot(m12) + (m11 - m22).hypot(m12);
-
-        // NOTE: v1 is the singular value that is the closest to m22.
-        // This prevents cancellation issues when constructing the vector `csv` below. If we chose
-        // otherwise, we would have v1 ~= m11 when m12 is small. This would cause catastrophic
-        // cancellation on `v1 * v1 - m11 * m11` below.
-        let v1 = two * m11 * m22 / denom;
-        let v2 = half * denom;
-
-        let mut u = None;
-        let mut v_t = None;
-
-        if compute_u || compute_v {
-            let csv = Vector2::new(m11 * m12, v1 * v1 - m11 * m11).normalize();
-
-            if compute_v {
-                v_t = Some(UnitComplex::new_unchecked(Complex::new(csv.x, csv.y)));
-            }
-
-            if compute_u {
-                let cu = (m11 * csv.x + m12 * csv.y) / v1;
-                let su = (m22 * csv.y) / v1;
-
-                u = Some(UnitComplex::new_unchecked(Complex::new(cu, su)));
-            }
-        }
-
-        (u, Vector2::new(v1, v2), v_t)
-    }
-
     /*
     fn display_bidiag(b: &Bidiagonal<N, R, C>, begin: usize, end: usize) {
         for i in begin .. end {
@@ -338,11 +301,13 @@ where
     */
 
     fn delimit_subproblem(
-        b: &mut Bidiagonal<N, R, C>,
+        diagonal: &mut VectorN<N::RealField, DimMinimum<R, C>>,
+        off_diagonal: &mut VectorN<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
         u: &mut Option<MatrixMN<N, R, DimMinimum<R, C>>>,
         v_t: &mut Option<MatrixMN<N, DimMinimum<R, C>, C>>,
+        is_upper_diagonal: bool,
         end: usize,
-        eps: N,
+        eps: N::RealField,
     ) -> (usize, usize)
     {
         let mut n = end;
@@ -350,20 +315,20 @@ where
         while n > 0 {
             let m = n - 1;
 
-            if b.off_diagonal[m].is_zero()
-                || b.off_diagonal[m].abs() <= eps * (b.diagonal[n].abs() + b.diagonal[m].abs())
+            if off_diagonal[m].is_zero()
+                || off_diagonal[m].norm1() <= eps * (diagonal[n].norm1() + diagonal[m].norm1())
             {
-                b.off_diagonal[m] = N::zero();
-            } else if b.diagonal[m].abs() <= eps {
-                b.diagonal[m] = N::zero();
-                Self::cancel_horizontal_off_diagonal_elt(b, u, v_t, m, m + 1);
+                off_diagonal[m] = N::RealField::zero();
+            } else if diagonal[m].norm1() <= eps {
+                diagonal[m] = N::RealField::zero();
+                Self::cancel_horizontal_off_diagonal_elt(diagonal, off_diagonal, u, v_t, is_upper_diagonal, m, m + 1);
 
                 if m != 0 {
-                    Self::cancel_vertical_off_diagonal_elt(b, u, v_t, m - 1);
+                    Self::cancel_vertical_off_diagonal_elt(diagonal, off_diagonal, u, v_t, is_upper_diagonal, m - 1);
                 }
-            } else if b.diagonal[n].abs() <= eps {
-                b.diagonal[n] = N::zero();
-                Self::cancel_vertical_off_diagonal_elt(b, u, v_t, m);
+            } else if diagonal[n].norm1() <= eps {
+                diagonal[n] = N::RealField::zero();
+                Self::cancel_vertical_off_diagonal_elt(diagonal, off_diagonal, u, v_t, is_upper_diagonal, m);
             } else {
                 break;
             }
@@ -379,18 +344,18 @@ where
         while new_start > 0 {
             let m = new_start - 1;
 
-            if b.off_diagonal[m].abs() <= eps * (b.diagonal[new_start].abs() + b.diagonal[m].abs())
+            if off_diagonal[m].norm1() <= eps * (diagonal[new_start].norm1() + diagonal[m].norm1())
             {
-                b.off_diagonal[m] = N::zero();
+                off_diagonal[m] = N::RealField::zero();
                 break;
             }
             // FIXME: write a test that enters this case.
-            else if b.diagonal[m].abs() <= eps {
-                b.diagonal[m] = N::zero();
-                Self::cancel_horizontal_off_diagonal_elt(b, u, v_t, m, n);
+            else if diagonal[m].norm1() <= eps {
+                diagonal[m] = N::RealField::zero();
+                Self::cancel_horizontal_off_diagonal_elt(diagonal, off_diagonal, u, v_t, is_upper_diagonal, m, n);
 
                 if m != 0 {
-                    Self::cancel_vertical_off_diagonal_elt(b, u, v_t, m - 1);
+                    Self::cancel_vertical_off_diagonal_elt(diagonal, off_diagonal, u, v_t, is_upper_diagonal, m - 1);
                 }
                 break;
             }
@@ -403,21 +368,24 @@ where
 
     // Cancels the i-th off-diagonal element using givens rotations.
     fn cancel_horizontal_off_diagonal_elt(
-        b: &mut Bidiagonal<N, R, C>,
+        diagonal: &mut VectorN<N::RealField, DimMinimum<R, C>>,
+        off_diagonal: &mut VectorN<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
         u: &mut Option<MatrixMN<N, R, DimMinimum<R, C>>>,
         v_t: &mut Option<MatrixMN<N, DimMinimum<R, C>, C>>,
+        is_upper_diagonal: bool,
         i: usize,
         end: usize,
     )
     {
-        let mut v = Vector2::new(b.off_diagonal[i], b.diagonal[i + 1]);
-        b.off_diagonal[i] = N::zero();
+        let mut v = Vector2::new(off_diagonal[i], diagonal[i + 1]);
+        off_diagonal[i] = N::RealField::zero();
 
         for k in i..end {
-            if let Some((rot, norm)) = givens::cancel_x(&v) {
-                b.diagonal[k + 1] = norm;
+            if let Some((rot, norm)) = GivensRotation::cancel_x(&v) {
+                let rot = GivensRotation::new_unchecked(rot.c(), N::from_real(rot.s()));
+                diagonal[k + 1] = norm;
 
-                if b.is_upper_diagonal() {
+                if is_upper_diagonal {
                     if let Some(ref mut u) = *u {
                         rot.inverse()
                             .rotate_rows(&mut u.fixed_columns_with_step_mut::<U2>(i, k - i));
@@ -427,9 +395,9 @@ where
                 }
 
                 if k + 1 != end {
-                    v.x = -rot.sin_angle() * b.off_diagonal[k + 1];
-                    v.y = b.diagonal[k + 2];
-                    b.off_diagonal[k + 1] *= rot.cos_angle();
+                    v.x = -rot.s().real() * off_diagonal[k + 1];
+                    v.y = diagonal[k + 2];
+                    off_diagonal[k + 1] *= rot.c();
                 }
             } else {
                 break;
@@ -439,20 +407,23 @@ where
 
     // Cancels the i-th off-diagonal element using givens rotations.
     fn cancel_vertical_off_diagonal_elt(
-        b: &mut Bidiagonal<N, R, C>,
+        diagonal: &mut VectorN<N::RealField, DimMinimum<R, C>>,
+        off_diagonal: &mut VectorN<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
         u: &mut Option<MatrixMN<N, R, DimMinimum<R, C>>>,
         v_t: &mut Option<MatrixMN<N, DimMinimum<R, C>, C>>,
+        is_upper_diagonal: bool,
         i: usize,
     )
     {
-        let mut v = Vector2::new(b.diagonal[i], b.off_diagonal[i]);
-        b.off_diagonal[i] = N::zero();
+        let mut v = Vector2::new(diagonal[i], off_diagonal[i]);
+        off_diagonal[i] = N::RealField::zero();
 
         for k in (0..i + 1).rev() {
-            if let Some((rot, norm)) = givens::cancel_y(&v) {
-                b.diagonal[k] = norm;
+            if let Some((rot, norm)) = GivensRotation::cancel_y(&v) {
+                let rot = GivensRotation::new_unchecked(rot.c(), N::from_real(rot.s()));
+                diagonal[k] = norm;
 
-                if b.is_upper_diagonal() {
+                if is_upper_diagonal {
                     if let Some(ref mut v_t) = *v_t {
                         rot.rotate(&mut v_t.fixed_rows_with_step_mut::<U2>(k, i - k));
                     }
@@ -462,9 +433,9 @@ where
                 }
 
                 if k > 0 {
-                    v.x = b.diagonal[k - 1];
-                    v.y = rot.sin_angle() * b.off_diagonal[k - 1];
-                    b.off_diagonal[k - 1] *= rot.cos_angle();
+                    v.x = diagonal[k - 1];
+                    v.y = rot.s().real() * off_diagonal[k - 1];
+                    off_diagonal[k - 1] *= rot.c();
                 }
             } else {
                 break;
@@ -474,9 +445,9 @@ where
 
     /// Computes the rank of the decomposed matrix, i.e., the number of singular values greater
     /// than `eps`.
-    pub fn rank(&self, eps: N) -> usize {
+    pub fn rank(&self, eps: N::RealField) -> usize {
         assert!(
-            eps >= N::zero(),
+            eps >= N::RealField::zero(),
             "SVD rank: the epsilon must be non-negative."
         );
         self.singular_values.iter().filter(|e| **e > eps).count()
@@ -492,7 +463,7 @@ where
             (Some(mut u), Some(v_t)) => {
                 for i in 0..self.singular_values.len() {
                     let val = self.singular_values[i];
-                    u.column_mut(i).mul_assign(val);
+                    u.column_mut(i).scale_mut(val);
                 }
                 Ok(u * v_t)
             }
@@ -507,11 +478,11 @@ where
     /// Any singular value smaller than `eps` is assumed to be zero.
     /// Returns `Err` if the right- and left- singular vectors have not
     /// been computed at construction-time.
-    pub fn pseudo_inverse(mut self, eps: N) -> Result<MatrixMN<N, C, R>, &'static str>
+    pub fn pseudo_inverse(mut self, eps: N::RealField) -> Result<MatrixMN<N, C, R>, &'static str>
     where
         DefaultAllocator: Allocator<N, C, R>,
     {
-        if eps < N::zero() {
+        if eps < N::RealField::zero() {
             Err("SVD pseudo inverse: the epsilon must be non-negative.")
         }
         else {
@@ -519,13 +490,13 @@ where
                 let val = self.singular_values[i];
 
                 if val > eps {
-                    self.singular_values[i] = N::one() / val;
+                    self.singular_values[i] = N::RealField::one() / val;
                 } else {
-                    self.singular_values[i] = N::zero();
+                    self.singular_values[i] = N::RealField::zero();
                 }
             }
 
-            self.recompose().map(|m| m.transpose())
+            self.recompose().map(|m| m.adjoint())
         }
     }
 
@@ -537,20 +508,20 @@ where
     pub fn solve<R2: Dim, C2: Dim, S2>(
         &self,
         b: &Matrix<N, R2, C2, S2>,
-        eps: N,
+        eps: N::RealField,
     ) -> Result<MatrixMN<N, C, C2>, &'static str>
     where
         S2: Storage<N, R2, C2>,
         DefaultAllocator: Allocator<N, C, C2> + Allocator<N, DimMinimum<R, C>, C2>,
         ShapeConstraint: SameNumberOfRows<R, R2>,
     {
-        if eps < N::zero() {
+        if eps < N::RealField::zero() {
             Err("SVD solve: the epsilon must be non-negative.")
         }
         else {
             match (&self.u, &self.v_t) {
                 (Some(u), Some(v_t)) => {
-                    let mut ut_b = u.tr_mul(b);
+                    let mut ut_b = u.ad_mul(b);
 
                     for j in 0..ut_b.ncols() {
                         let mut col = ut_b.column_mut(j);
@@ -558,14 +529,14 @@ where
                         for i in 0..self.singular_values.len() {
                             let val = self.singular_values[i];
                             if val > eps {
-                                col[i] /= val;
+                                col[i] = col[i].unscale(val);
                             } else {
                                 col[i] = N::zero();
                             }
                         }
                     }
 
-                    Ok(v_t.tr_mul(&ut_b))
+                    Ok(v_t.ad_mul(&ut_b))
                 }
                 (None, None) => Err("SVD solve: U and V^t have not been computed."),
                 (None, _) => Err("SVD solve: U has not been computed."),
@@ -575,7 +546,7 @@ where
     }
 }
 
-impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
+impl<N: ComplexField, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
 where
     DimMinimum<R, C>: DimSub<U1>, // for Bidiagonal.
     DefaultAllocator: Allocator<N, R, C>
@@ -584,7 +555,9 @@ where
         + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>
         + Allocator<N, DimMinimum<R, C>, C>
         + Allocator<N, R, DimMinimum<R, C>>
-        + Allocator<N, DimMinimum<R, C>>,
+        + Allocator<N, DimMinimum<R, C>>
+        + Allocator<N::RealField, DimMinimum<R, C>>
+        + Allocator<N::RealField, DimDiff<DimMinimum<R, C>, U1>>,
 {
     /// Computes the Singular Value Decomposition using implicit shift.
     pub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<N, R, C> {
@@ -605,7 +578,7 @@ where
         self,
         compute_u: bool,
         compute_v: bool,
-        eps: N,
+        eps: N::RealField,
         max_niter: usize,
     ) -> Option<SVD<N, R, C>>
     {
@@ -613,14 +586,14 @@ where
     }
 
     /// Computes the singular values of this matrix.
-    pub fn singular_values(&self) -> VectorN<N, DimMinimum<R, C>> {
+    pub fn singular_values(&self) -> VectorN<N::RealField, DimMinimum<R, C>> {
         SVD::new(self.clone_owned(), false, false).singular_values
     }
 
     /// Computes the rank of this matrix.
     ///
     /// All singular values below `eps` are considered equal to 0.
-    pub fn rank(&self, eps: N) -> usize {
+    pub fn rank(&self, eps: N::RealField) -> usize {
         let svd = SVD::new(self.clone_owned(), false, false);
         svd.rank(eps)
     }
@@ -628,10 +601,60 @@ where
     /// Computes the pseudo-inverse of this matrix.
     ///
     /// All singular values below `eps` are considered equal to 0.
-    pub fn pseudo_inverse(self, eps: N) -> Result<MatrixMN<N, C, R>, &'static str>
+    pub fn pseudo_inverse(self, eps: N::RealField) -> Result<MatrixMN<N, C, R>, &'static str>
     where
         DefaultAllocator: Allocator<N, C, R>,
     {
         SVD::new(self.clone_owned(), true, true).pseudo_inverse(eps)
     }
 }
+
+
+// Explicit formulae inspired from the paper "Computing the Singular Values of 2-by-2 Complex
+// Matrices", Sanzheng Qiao and Xiaohong Wang.
+// http://www.cas.mcmaster.ca/sqrl/papers/sqrl5.pdf
+fn compute_2x2_uptrig_svd<N: RealField>(
+    m11: N,
+    m12: N,
+    m22: N,
+    compute_u: bool,
+    compute_v: bool,
+) -> (Option<GivensRotation<N>>, Vector2<N>, Option<GivensRotation<N>>)
+{
+    let two: N::RealField = crate::convert(2.0f64);
+    let half: N::RealField = crate::convert(0.5f64);
+
+    let denom = (m11 + m22).hypot(m12) + (m11 - m22).hypot(m12);
+
+    // NOTE: v1 is the singular value that is the closest to m22.
+    // This prevents cancellation issues when constructing the vector `csv` below. If we chose
+    // otherwise, we would have v1 ~= m11 when m12 is small. This would cause catastrophic
+    // cancellation on `v1 * v1 - m11 * m11` below.
+    let mut v1 = m11 * m22 * two / denom;
+    let mut v2 = half * denom;
+
+    let mut u = None;
+    let mut v_t = None;
+
+    if compute_u || compute_v {
+        let (csv, sgn_v) = GivensRotation::new(m11 * m12, v1 * v1 - m11 * m11);
+        v1 *= sgn_v;
+        v2 *= sgn_v;
+
+        if compute_v {
+            v_t = Some(csv);
+        }
+
+        if compute_u {
+            let cu = (m11.scale(csv.c()) + m12 * csv.s()) / v1;
+            let su = (m22 * csv.s()) / v1;
+            let (csu, sgn_u) = GivensRotation::new(cu, su);
+
+            v1 *= sgn_u;
+            v2 *= sgn_u;
+            u = Some(csu);
+        }
+    }
+
+    (u, Vector2::new(v1, v2), v_t)
+}
\ No newline at end of file
diff --git a/src/linalg/symmetric_eigen.rs b/src/linalg/symmetric_eigen.rs
index cd455b7c6..fc493dca2 100644
--- a/src/linalg/symmetric_eigen.rs
+++ b/src/linalg/symmetric_eigen.rs
@@ -1,18 +1,17 @@
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Serialize};
 
-use num_complex::Complex;
-use std::ops::MulAssign;
+use num::Zero;
+use approx::AbsDiffEq;
 
-use alga::general::Real;
-use allocator::Allocator;
-use base::{DefaultAllocator, Matrix2, MatrixN, SquareMatrix, Vector2, VectorN};
-use dimension::{Dim, DimDiff, DimSub, U1, U2};
-use storage::Storage;
+use alga::general::ComplexField;
+use crate::allocator::Allocator;
+use crate::base::{DefaultAllocator, Matrix2, MatrixN, SquareMatrix, Vector2, VectorN};
+use crate::dimension::{Dim, DimDiff, DimSub, U1, U2};
+use crate::storage::Storage;
 
-use geometry::UnitComplex;
-use linalg::givens;
-use linalg::SymmetricTridiagonal;
+use crate::linalg::givens::GivensRotation;
+use crate::linalg::SymmetricTridiagonal;
 
 /// Eigendecomposition of a symmetric matrix.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
@@ -20,8 +19,8 @@ use linalg::SymmetricTridiagonal;
     feature = "serde-serialize",
     serde(bound(
         serialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N, D>,
-         VectorN<N, D>: Serialize,
+                           Allocator<N::RealField, D>,
+         VectorN<N::RealField, D>: Serialize,
          MatrixN<N, D>: Serialize"
     ))
 )]
@@ -29,31 +28,31 @@ use linalg::SymmetricTridiagonal;
     feature = "serde-serialize",
     serde(bound(
         deserialize = "DefaultAllocator: Allocator<N, D, D> +
-                           Allocator<N, D>,
-         VectorN<N, D>: Deserialize<'de>,
+                           Allocator<N::RealField, D>,
+         VectorN<N::RealField, D>: Deserialize<'de>,
          MatrixN<N, D>: Deserialize<'de>"
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct SymmetricEigen<N: Real, D: Dim>
-where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
+pub struct SymmetricEigen<N: ComplexField, D: Dim>
+where DefaultAllocator: Allocator<N, D, D> + Allocator<N::RealField, D>
 {
     /// The eigenvectors of the decomposed matrix.
     pub eigenvectors: MatrixN<N, D>,
 
     /// The unsorted eigenvalues of the decomposed matrix.
-    pub eigenvalues: VectorN<N, D>,
+    pub eigenvalues: VectorN<N::RealField, D>,
 }
 
-impl<N: Real, D: Dim> Copy for SymmetricEigen<N, D>
+impl<N: ComplexField, D: Dim> Copy for SymmetricEigen<N, D>
 where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+    DefaultAllocator: Allocator<N, D, D> + Allocator<N::RealField, D>,
     MatrixN<N, D>: Copy,
-    VectorN<N, D>: Copy,
+    VectorN<N::RealField, D>: Copy,
 {}
 
-impl<N: Real, D: Dim> SymmetricEigen<N, D>
-where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
+impl<N: ComplexField, D: Dim> SymmetricEigen<N, D>
+where DefaultAllocator: Allocator<N, D, D> + Allocator<N::RealField, D>
 {
     /// Computes the eigendecomposition of the given symmetric matrix.
     ///
@@ -61,9 +60,10 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
     pub fn new(m: MatrixN<N, D>) -> Self
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<N, DimDiff<D, U1>> + // For tridiagonalization
+        Allocator<N::RealField, DimDiff<D, U1>>,
     {
-        Self::try_new(m, N::default_epsilon(), 0).unwrap()
+        Self::try_new(m, N::RealField::default_epsilon(), 0).unwrap()
     }
 
     /// Computes the eigendecomposition of the given symmetric matrix with user-specified
@@ -77,10 +77,11 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
     /// * `max_niter` − maximum total number of iterations performed by the algorithm. If this
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.
-    pub fn try_new(m: MatrixN<N, D>, eps: N, max_niter: usize) -> Option<Self>
+    pub fn try_new(m: MatrixN<N, D>, eps: N::RealField, max_niter: usize) -> Option<Self>
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<N, DimDiff<D, U1>> + // For tridiagonalization
+                          Allocator<N::RealField, DimDiff<D, U1>>,
     {
         Self::do_decompose(m, true, eps, max_niter).map(|(vals, vecs)| SymmetricEigen {
             eigenvectors: vecs.unwrap(),
@@ -91,23 +92,23 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
     fn do_decompose(
         mut m: MatrixN<N, D>,
         eigenvectors: bool,
-        eps: N,
+        eps: N::RealField,
         max_niter: usize,
-    ) -> Option<(VectorN<N, D>, Option<MatrixN<N, D>>)>
+    ) -> Option<(VectorN<N::RealField, D>, Option<MatrixN<N, D>>)>
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<N, DimDiff<D, U1>> + // For tridiagonalization
+                          Allocator<N::RealField, DimDiff<D, U1>>,
     {
         assert!(
             m.is_square(),
             "Unable to compute the eigendecomposition of a non-square matrix."
         );
         let dim = m.nrows();
-
-        let m_amax = m.amax();
+        let m_amax = m.camax();
 
         if !m_amax.is_zero() {
-            m /= m_amax;
+            m.unscale_mut(m_amax);
         }
 
         let (mut q, mut diag, mut off_diag);
@@ -125,7 +126,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
         }
 
         if dim == 1 {
-            diag *= m_amax;
+            diag.scale_mut(m_amax);
             return Some((diag, q));
         }
 
@@ -147,21 +148,22 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
                 for i in start..n {
                     let j = i + 1;
 
-                    if let Some((rot, norm)) = givens::cancel_y(&v) {
+                    if let Some((rot, norm)) = GivensRotation::cancel_y(&v) {
                         if i > start {
                             // Not the first iteration.
                             off_diag[i - 1] = norm;
                         }
 
+
                         let mii = diag[i];
                         let mjj = diag[j];
                         let mij = off_diag[i];
 
-                        let cc = rot.cos_angle() * rot.cos_angle();
-                        let ss = rot.sin_angle() * rot.sin_angle();
-                        let cs = rot.cos_angle() * rot.sin_angle();
+                        let cc = rot.c() * rot.c();
+                        let ss = rot.s() * rot.s();
+                        let cs = rot.c() * rot.s();
 
-                        let b = cs * ::convert(2.0) * mij;
+                        let b = cs * crate::convert(2.0) * mij;
 
                         diag[i] = (cc * mii + ss * mjj) - b;
                         diag[j] = (ss * mii + cc * mjj) + b;
@@ -169,11 +171,12 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 
                         if i != n - 1 {
                             v.x = off_diag[i];
-                            v.y = -rot.sin_angle() * off_diag[i + 1];
-                            off_diag[i + 1] *= rot.cos_angle();
+                            v.y = -rot.s() * off_diag[i + 1];
+                            off_diag[i + 1] *= rot.c();
                         }
 
                         if let Some(ref mut q) = q {
+                            let rot = GivensRotation::new_unchecked(rot.c(), N::from_real(rot.s()));
                             rot.inverse().rotate_rows(&mut q.fixed_columns_mut::<U2>(i));
                         }
                     } else {
@@ -181,15 +184,13 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
                     }
                 }
 
-                if off_diag[m].abs() <= eps * (diag[m].abs() + diag[n].abs()) {
+                if off_diag[m].norm1() <= eps * (diag[m].norm1() + diag[n].norm1()) {
                     end -= 1;
                 }
             } else if subdim == 2 {
                 let m = Matrix2::new(
-                    diag[start],
-                    off_diag[start],
-                    off_diag[start],
-                    diag[start + 1],
+                    diag[start], off_diag[start].conjugate(),
+                    off_diag[start], diag[start + 1],
                 );
                 let eigvals = m.eigenvalues().unwrap();
                 let basis = Vector2::new(eigvals.x - diag[start + 1], off_diag[start]);
@@ -198,8 +199,8 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
                 diag[start + 1] = eigvals[1];
 
                 if let Some(ref mut q) = q {
-                    if let Some(basis) = basis.try_normalize(eps) {
-                        let rot = UnitComplex::new_unchecked(Complex::new(basis.x, basis.y));
+                    if let Some((rot, _)) = GivensRotation::try_new(basis.x, basis.y, eps) {
+                        let rot = GivensRotation::new_unchecked(rot.c(), N::from_real(rot.s()));
                         rot.rotate_rows(&mut q.fixed_columns_mut::<U2>(start));
                     }
                 }
@@ -219,27 +220,27 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
             }
         }
 
-        diag *= m_amax;
+        diag.scale_mut(m_amax);
 
         Some((diag, q))
     }
 
     fn delimit_subproblem(
-        diag: &VectorN<N, D>,
-        off_diag: &mut VectorN<N, DimDiff<D, U1>>,
+        diag: &VectorN<N::RealField, D>,
+        off_diag: &mut VectorN<N::RealField, DimDiff<D, U1>>,
         end: usize,
-        eps: N,
+        eps: N::RealField,
     ) -> (usize, usize)
     where
         D: DimSub<U1>,
-        DefaultAllocator: Allocator<N, DimDiff<D, U1>>,
+        DefaultAllocator: Allocator<N::RealField, DimDiff<D, U1>>,
     {
         let mut n = end;
 
         while n > 0 {
             let m = n - 1;
 
-            if off_diag[m].abs() > eps * (diag[n].abs() + diag[m].abs()) {
+            if off_diag[m].norm1() > eps * (diag[n].norm1() + diag[m].norm1()) {
                 break;
             }
 
@@ -255,9 +256,9 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
             let m = new_start - 1;
 
             if off_diag[m].is_zero()
-                || off_diag[m].abs() <= eps * (diag[new_start].abs() + diag[m].abs())
+                || off_diag[m].norm1() <= eps * (diag[new_start].norm1() + diag[m].norm1())
             {
-                off_diag[m] = N::zero();
+                off_diag[m] = N::RealField::zero();
                 break;
             }
 
@@ -274,9 +275,9 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
         let mut u_t = self.eigenvectors.clone();
         for i in 0..self.eigenvalues.len() {
             let val = self.eigenvalues[i];
-            u_t.column_mut(i).mul_assign(val);
+            u_t.column_mut(i).scale_mut(val);
         }
-        u_t.transpose_mut();
+        u_t.adjoint_mut();
         &self.eigenvectors * u_t
     }
 }
@@ -287,11 +288,11 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 /// The inputs are interpreted as the 2x2 matrix:
 ///     tmm  tmn
 ///     tmn  tnn
-pub fn wilkinson_shift<N: Real>(tmm: N, tnn: N, tmn: N) -> N {
+pub fn wilkinson_shift<N: ComplexField>(tmm: N, tnn: N, tmn: N) -> N {
     let sq_tmn = tmn * tmn;
     if !sq_tmn.is_zero() {
         // We have the guarantee that the denominator won't be zero.
-        let d = (tmm - tnn) * ::convert(0.5);
+        let d = (tmm - tnn) * crate::convert(0.5);
         tnn - sq_tmn / (d + d.signum() * (d * d + sq_tmn).sqrt())
     } else {
         tnn
@@ -303,8 +304,9 @@ pub fn wilkinson_shift<N: Real>(tmm: N, tnn: N, tmn: N) -> N {
  * Computations of eigenvalues for symmetric matrices.
  *
  */
-impl<N: Real, D: DimSub<U1>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
-where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> + Allocator<N, DimDiff<D, U1>>
+impl<N: ComplexField, D: DimSub<U1>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
+where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>> +
+                        Allocator<N::RealField, D> + Allocator<N::RealField, DimDiff<D, U1>>
 {
     /// Computes the eigendecomposition of this symmetric matrix.
     ///
@@ -324,15 +326,15 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> + Allocator<N, DimD
     /// * `max_niter` − maximum total number of iterations performed by the algorithm. If this
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.
-    pub fn try_symmetric_eigen(self, eps: N, max_niter: usize) -> Option<SymmetricEigen<N, D>> {
+    pub fn try_symmetric_eigen(self, eps: N::RealField, max_niter: usize) -> Option<SymmetricEigen<N, D>> {
         SymmetricEigen::try_new(self.into_owned(), eps, max_niter)
     }
 
     /// Computes the eigenvalues of this symmetric matrix.
     ///
     /// Only the lower-triangular part of the matrix is read.
-    pub fn symmetric_eigenvalues(&self) -> VectorN<N, D> {
-        SymmetricEigen::do_decompose(self.clone_owned(), false, N::default_epsilon(), 0)
+    pub fn symmetric_eigenvalues(&self) -> VectorN<N::RealField, D> {
+        SymmetricEigen::do_decompose(self.clone_owned(), false, N::RealField::default_epsilon(), 0)
             .unwrap()
             .0
     }
@@ -340,7 +342,7 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D> + Allocator<N, DimD
 
 #[cfg(test)]
 mod test {
-    use base::Matrix2;
+    use crate::base::Matrix2;
 
     fn expected_shift(m: Matrix2<f64>) -> f64 {
         let vals = m.eigenvalues().unwrap();
@@ -360,7 +362,6 @@ mod test {
 
             let expected = expected_shift(m);
             let computed = super::wilkinson_shift(m.m11, m.m22, m.m12);
-            println!("{} {}", expected, computed);
             assert!(relative_eq!(expected, computed, epsilon = 1.0e-7));
         }
     }
diff --git a/src/linalg/symmetric_tridiagonal.rs b/src/linalg/symmetric_tridiagonal.rs
index 2e4108aef..40da8677a 100644
--- a/src/linalg/symmetric_tridiagonal.rs
+++ b/src/linalg/symmetric_tridiagonal.rs
@@ -1,13 +1,13 @@
 #[cfg(feature = "serde-serialize")]
 use serde::{Deserialize, Serialize};
 
-use alga::general::Real;
-use allocator::Allocator;
-use base::{DefaultAllocator, MatrixMN, MatrixN, SquareMatrix, VectorN};
-use dimension::{DimDiff, DimSub, U1};
-use storage::Storage;
+use alga::general::ComplexField;
+use crate::allocator::Allocator;
+use crate::base::{DefaultAllocator, MatrixMN, MatrixN, SquareMatrix, VectorN};
+use crate::dimension::{DimDiff, DimSub, U1};
+use crate::storage::Storage;
 
-use linalg::householder;
+use crate::linalg::householder;
 
 /// Tridiagonalization of a symmetric matrix.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
@@ -30,21 +30,21 @@ use linalg::householder;
     ))
 )]
 #[derive(Clone, Debug)]
-pub struct SymmetricTridiagonal<N: Real, D: DimSub<U1>>
+pub struct SymmetricTridiagonal<N: ComplexField, D: DimSub<U1>>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>
 {
     tri: MatrixN<N, D>,
     off_diagonal: VectorN<N, DimDiff<D, U1>>,
 }
 
-impl<N: Real, D: DimSub<U1>> Copy for SymmetricTridiagonal<N, D>
+impl<N: ComplexField, D: DimSub<U1>> Copy for SymmetricTridiagonal<N, D>
 where
     DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
     MatrixN<N, D>: Copy,
     VectorN<N, DimDiff<D, U1>>: Copy,
 {}
 
-impl<N: Real, D: DimSub<U1>> SymmetricTridiagonal<N, D>
+impl<N: ComplexField, D: DimSub<U1>> SymmetricTridiagonal<N, D>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>
 {
     /// Computes the tridiagonalization of the symmetric matrix `m`.
@@ -75,17 +75,18 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>
             if not_zero {
                 let mut p = p.rows_range_mut(i..);
 
-                p.gemv_symm(::convert(2.0), &m, &axis, N::zero());
-                let dot = axis.dot(&p);
-                p.axpy(-dot, &axis, N::one());
-                m.ger_symm(-N::one(), &p, &axis, N::one());
-                m.ger_symm(-N::one(), &axis, &p, N::one());
+                p.hegemv(crate::convert(2.0), &m, &axis, N::zero());
+
+                let dot = axis.dotc(&p);
+                m.hegerc(-N::one(), &p, &axis, N::one());
+                m.hegerc(-N::one(), &axis, &p, N::one());
+                m.hegerc(dot * crate::convert(2.0), &axis, &axis, N::one());
             }
         }
 
         Self {
             tri: m,
-            off_diagonal: off_diagonal,
+            off_diagonal,
         }
     }
 
@@ -97,37 +98,35 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>
 
     /// Retrieve the orthogonal transformation, diagonal, and off diagonal elements of this
     /// decomposition.
-    pub fn unpack(self) -> (MatrixN<N, D>, VectorN<N, D>, VectorN<N, DimDiff<D, U1>>)
-    where DefaultAllocator: Allocator<N, D> {
+    pub fn unpack(self) -> (MatrixN<N, D>, VectorN<N::RealField, D>, VectorN<N::RealField, DimDiff<D, U1>>)
+    where DefaultAllocator: Allocator<N::RealField, D>
+                          + Allocator<N::RealField, DimDiff<D, U1>> {
         let diag = self.diagonal();
         let q = self.q();
 
-        (q, diag, self.off_diagonal)
+        (q, diag, self.off_diagonal.map(N::modulus))
     }
 
     /// Retrieve the diagonal, and off diagonal elements of this decomposition.
-    pub fn unpack_tridiagonal(self) -> (VectorN<N, D>, VectorN<N, DimDiff<D, U1>>)
-    where DefaultAllocator: Allocator<N, D> {
-        let diag = self.diagonal();
-
-        (diag, self.off_diagonal)
+    pub fn unpack_tridiagonal(self) -> (VectorN<N::RealField, D>, VectorN<N::RealField, DimDiff<D, U1>>)
+        where DefaultAllocator: Allocator<N::RealField, D>
+                              + Allocator<N::RealField, DimDiff<D, U1>> {
+        (self.diagonal(), self.off_diagonal.map(N::modulus))
     }
 
     /// The diagonal components of this decomposition.
-    pub fn diagonal(&self) -> VectorN<N, D>
-    where DefaultAllocator: Allocator<N, D> {
-        self.tri.diagonal()
-    }
+    pub fn diagonal(&self) -> VectorN<N::RealField, D>
+    where DefaultAllocator: Allocator<N::RealField, D> { self.tri.map_diagonal(|e| e.real()) }
 
     /// The off-diagonal components of this decomposition.
-    pub fn off_diagonal(&self) -> &VectorN<N, DimDiff<D, U1>>
-    where DefaultAllocator: Allocator<N, D> {
-        &self.off_diagonal
+    pub fn off_diagonal(&self) -> VectorN<N::RealField, DimDiff<D, U1>>
+    where DefaultAllocator: Allocator<N::RealField, DimDiff<D, U1>> {
+        self.off_diagonal.map(N::modulus)
     }
 
     /// Computes the orthogonal matrix `Q` of this decomposition.
     pub fn q(&self) -> MatrixN<N, D> {
-        householder::assemble_q(&self.tri)
+        householder::assemble_q(&self.tri, self.off_diagonal.as_slice())
     }
 
     /// Recomputes the original symmetric matrix.
@@ -137,15 +136,16 @@ where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>
         self.tri.fill_upper_triangle(N::zero(), 2);
 
         for i in 0..self.off_diagonal.len() {
-            self.tri[(i + 1, i)] = self.off_diagonal[i];
-            self.tri[(i, i + 1)] = self.off_diagonal[i];
+            let val = N::from_real(self.off_diagonal[i].modulus());
+            self.tri[(i + 1, i)] = val;
+            self.tri[(i, i + 1)] = val;
         }
 
-        &q * self.tri * q.transpose()
+        &q * self.tri * q.adjoint()
     }
 }
 
-impl<N: Real, D: DimSub<U1>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
+impl<N: ComplexField, D: DimSub<U1>, S: Storage<N, D, D>> SquareMatrix<N, D, S>
 where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>
 {
     /// Computes the tridiagonalization of this symmetric matrix.
diff --git a/src/sparse/cs_matrix.rs b/src/sparse/cs_matrix.rs
index 4c2983eb8..2fc571c76 100644
--- a/src/sparse/cs_matrix.rs
+++ b/src/sparse/cs_matrix.rs
@@ -5,9 +5,9 @@ use std::marker::PhantomData;
 use std::ops::Range;
 use std::slice;
 
-use allocator::Allocator;
-use sparse::cs_utils;
-use {
+use crate::allocator::Allocator;
+use crate::sparse::cs_utils;
+use crate::{
     DefaultAllocator, Dim, Dynamic, Scalar, Vector, VectorN, U1
 };
 
diff --git a/src/sparse/cs_matrix_cholesky.rs b/src/sparse/cs_matrix_cholesky.rs
index 5d834ef21..4c3fffd82 100644
--- a/src/sparse/cs_matrix_cholesky.rs
+++ b/src/sparse/cs_matrix_cholesky.rs
@@ -1,12 +1,12 @@
 use std::iter;
 use std::mem;
 
-use allocator::Allocator;
-use sparse::{CsMatrix, CsStorage, CsStorageIter, CsStorageIterMut, CsVecStorage};
-use {DefaultAllocator, Dim, Real, VectorN, U1};
+use crate::allocator::Allocator;
+use crate::sparse::{CsMatrix, CsStorage, CsStorageIter, CsStorageIterMut, CsVecStorage};
+use crate::{DefaultAllocator, Dim, RealField, VectorN, U1};
 
 /// The cholesky decomposition of a column compressed sparse matrix.
-pub struct CsCholesky<N: Real, D: Dim>
+pub struct CsCholesky<N: RealField, D: Dim>
 where DefaultAllocator: Allocator<usize, D> + Allocator<N, D>
 {
     // Non-zero pattern of the original matrix upper-triangular part.
@@ -25,7 +25,7 @@ where DefaultAllocator: Allocator<usize, D> + Allocator<N, D>
     work_c: VectorN<usize, D>,
 }
 
-impl<N: Real, D: Dim> CsCholesky<N, D>
+impl<N: RealField, D: Dim> CsCholesky<N, D>
 where DefaultAllocator: Allocator<usize, D> + Allocator<N, D>
 {
     /// Computes the cholesky decomposition of the sparse matrix `m`.
diff --git a/src/sparse/cs_matrix_conversion.rs b/src/sparse/cs_matrix_conversion.rs
index 0017340f0..31e537963 100644
--- a/src/sparse/cs_matrix_conversion.rs
+++ b/src/sparse/cs_matrix_conversion.rs
@@ -1,11 +1,11 @@
 use alga::general::ClosedAdd;
 use num::Zero;
 
-use allocator::Allocator;
-use sparse::cs_utils;
-use sparse::{CsMatrix, CsStorage};
-use storage::Storage;
-use {DefaultAllocator, Dim, Dynamic, Matrix, MatrixMN, Scalar};
+use crate::allocator::Allocator;
+use crate::sparse::cs_utils;
+use crate::sparse::{CsMatrix, CsStorage};
+use crate::storage::Storage;
+use crate::{DefaultAllocator, Dim, Dynamic, Matrix, MatrixMN, Scalar};
 
 impl<'a, N: Scalar + Zero + ClosedAdd> CsMatrix<N> {
     /// Creates a column-compressed sparse matrix from a sparse matrix in triplet form.
diff --git a/src/sparse/cs_matrix_ops.rs b/src/sparse/cs_matrix_ops.rs
index b944c4e2f..322ebb34c 100644
--- a/src/sparse/cs_matrix_ops.rs
+++ b/src/sparse/cs_matrix_ops.rs
@@ -2,11 +2,11 @@ use alga::general::{ClosedAdd, ClosedMul};
 use num::{One, Zero};
 use std::ops::{Add, Mul};
 
-use allocator::Allocator;
-use constraint::{AreMultipliable, DimEq, ShapeConstraint};
-use sparse::{CsMatrix, CsStorage, CsStorageMut, CsVector};
-use storage::StorageMut;
-use {DefaultAllocator, Dim, Scalar, Vector, VectorN, U1};
+use crate::allocator::Allocator;
+use crate::constraint::{AreMultipliable, DimEq, ShapeConstraint};
+use crate::sparse::{CsMatrix, CsStorage, CsStorageMut, CsVector};
+use crate::storage::StorageMut;
+use crate::{DefaultAllocator, Dim, Scalar, Vector, VectorN, U1};
 
 impl<N: Scalar, R: Dim, C: Dim, S: CsStorage<N, R, C>> CsMatrix<N, R, C, S> {
     fn scatter<R2: Dim, C2: Dim>(
diff --git a/src/sparse/cs_matrix_solve.rs b/src/sparse/cs_matrix_solve.rs
index 2a13188e6..14ca9f781 100644
--- a/src/sparse/cs_matrix_solve.rs
+++ b/src/sparse/cs_matrix_solve.rs
@@ -1,10 +1,10 @@
-use allocator::Allocator;
-use constraint::{SameNumberOfRows, ShapeConstraint};
-use sparse::{CsMatrix, CsStorage, CsVector};
-use storage::{Storage, StorageMut};
-use {DefaultAllocator, Dim, Matrix, MatrixMN, Real, VectorN, U1};
+use crate::allocator::Allocator;
+use crate::constraint::{SameNumberOfRows, ShapeConstraint};
+use crate::sparse::{CsMatrix, CsStorage, CsVector};
+use crate::storage::{Storage, StorageMut};
+use crate::{DefaultAllocator, Dim, Matrix, MatrixMN, RealField, VectorN, U1};
 
-impl<N: Real, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
+impl<N: RealField, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
     /// Solve a lower-triangular system with a dense right-hand-side.
     pub fn solve_lower_triangular<R2: Dim, C2: Dim, S2>(
         &self,
@@ -78,7 +78,8 @@ impl<N: Real, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
                 }
 
                 for (i, val) in column {
-                    b[i] -= b[j] * val;
+                    let bj = b[j];
+                    b[i] -= bj * val;
                 }
             }
         }
@@ -119,7 +120,8 @@ impl<N: Real, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
 
                 if let Some(diag) = diag {
                     for (i, val) in column {
-                        b[j] -= val * b[i];
+                        let bi = b[i];
+                        b[j] -= val * bi;
                     }
 
                     b[j] /= diag;
@@ -178,7 +180,8 @@ impl<N: Real, D: Dim, S: CsStorage<N, D, D>> CsMatrix<N, D, D, S> {
             }
 
             for (i, val) in column {
-                workspace[i] -= workspace[j] * val;
+                let wj = workspace[j];
+                workspace[i] -= wj * val;
             }
         }
 
diff --git a/src/sparse/cs_utils.rs b/src/sparse/cs_utils.rs
index 3c5db43e4..a8a454eb6 100644
--- a/src/sparse/cs_utils.rs
+++ b/src/sparse/cs_utils.rs
@@ -1,5 +1,5 @@
-use allocator::Allocator;
-use {DefaultAllocator, Dim, VectorN};
+use crate::allocator::Allocator;
+use crate::{DefaultAllocator, Dim, VectorN};
 
 pub fn cumsum<D: Dim>(a: &mut VectorN<usize, D>, b: &mut VectorN<usize, D>) -> usize
 where DefaultAllocator: Allocator<usize, D> {
diff --git a/tests/core/abomonation.rs b/tests/core/abomonation.rs
index be3952cd6..01760e14a 100644
--- a/tests/core/abomonation.rs
+++ b/tests/core/abomonation.rs
@@ -40,7 +40,7 @@ fn assert_encode_and_decode<T: Abomonation + PartialEq + Clone>(original_data: T
     // Encode
     let mut bytes = Vec::new();
     unsafe {
-        encode(&original_data, &mut bytes);
+        let _ = encode(&original_data, &mut bytes);
     }
 
     // Drop the original, so that dangling pointers are revealed by the test
diff --git a/tests/core/blas.rs b/tests/core/blas.rs
index 00eac3a3f..38113c17d 100644
--- a/tests/core/blas.rs
+++ b/tests/core/blas.rs
@@ -19,14 +19,14 @@ quickcheck! {
         let mut y2 = y1.clone();
 
         y1.gemv(alpha, &a, &x, beta);
-        y2.gemv_symm(alpha, &a.lower_triangle(), &x, beta);
+        y2.sygemv(alpha, &a.lower_triangle(), &x, beta);
 
         if !relative_eq!(y1, y2, epsilon = 1.0e-10) {
             return false;
         }
 
         y1.gemv(alpha, &a, &x, 0.0);
-        y2.gemv_symm(alpha, &a.lower_triangle(), &x, 0.0);
+        y2.sygemv(alpha, &a.lower_triangle(), &x, 0.0);
 
         relative_eq!(y1, y2, epsilon = 1.0e-10)
     }
@@ -61,14 +61,14 @@ quickcheck! {
         let y = DVector::new_random(n);
 
         a1.ger(alpha, &x, &y, beta);
-        a2.ger_symm(alpha, &x, &y, beta);
+        a2.syger(alpha, &x, &y, beta);
 
         if !relative_eq!(a1.lower_triangle(), a2) {
             return false;
         }
 
         a1.ger(alpha, &x, &y, 0.0);
-        a2.ger_symm(alpha, &x, &y, 0.0);
+        a2.syger(alpha, &x, &y, 0.0);
 
         relative_eq!(a1.lower_triangle(), a2)
     }
diff --git a/tests/core/helper.rs b/tests/core/helper.rs
new file mode 100644
index 000000000..625a4a464
--- /dev/null
+++ b/tests/core/helper.rs
@@ -0,0 +1,54 @@
+// This module implement several methods to fill some
+// missing features of num-complex when it comes to randomness.
+
+use quickcheck::{Arbitrary, Gen};
+use rand::distributions::{Standard, Distribution};
+use rand::Rng;
+use num_complex::Complex;
+use na::RealField;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct RandComplex<N>(pub Complex<N>);
+
+impl<N: Arbitrary + RealField> Arbitrary for RandComplex<N> {
+    #[inline]
+    fn arbitrary<G: Gen>(rng: &mut G) -> Self {
+        let im = Arbitrary::arbitrary(rng);
+        let re = Arbitrary::arbitrary(rng);
+        RandComplex(Complex::new(re, im))
+    }
+}
+
+impl<N: RealField> Distribution<RandComplex<N>> for Standard
+    where
+        Standard: Distribution<N>,
+{
+    #[inline]
+    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> RandComplex<N> {
+        let re = rng.gen();
+        let im = rng.gen();
+        RandComplex(Complex::new(re, im))
+    }
+}
+
+// This is a wrapper similar to RandComplex, but for non-complex.
+// This exists only to make generic tests easier to write.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct RandScalar<N>(pub N);
+
+impl<N: Arbitrary> Arbitrary for RandScalar<N> {
+    #[inline]
+    fn arbitrary<G: Gen>(rng: &mut G) -> Self {
+        RandScalar(Arbitrary::arbitrary(rng))
+    }
+}
+
+impl<N: RealField> Distribution<RandScalar<N>> for Standard
+    where
+        Standard: Distribution<N>,
+{
+    #[inline]
+    fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> RandScalar<N> {
+        RandScalar(self.sample(rng))
+    }
+}
\ No newline at end of file
diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs
index 9c6d468af..e4fb4d0c2 100644
--- a/tests/core/matrix.rs
+++ b/tests/core/matrix.rs
@@ -4,7 +4,7 @@ use std::cmp::Ordering;
 use na::dimension::{U15, U8};
 use na::{
     self, DMatrix, DVector, Matrix2, Matrix2x3, Matrix2x4, Matrix3, Matrix3x2, Matrix3x4, Matrix4,
-    Matrix4x3, Matrix4x5, Matrix5, Matrix6, MatrixMN, Real, RowVector3, RowVector4, RowVector5,
+    Matrix4x3, Matrix4x5, Matrix5, Matrix6, MatrixMN, RowVector3, RowVector4, RowVector5,
     Vector1, Vector2, Vector3, Vector4, Vector5, Vector6,
 };
 
@@ -417,7 +417,7 @@ fn simple_scalar_conversion() {
 #[test]
 fn apply() {
     let mut a = Matrix4::new(
-        1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 8.8, 7.7, 6.6, 5.5, 4.4, 3.3, 2.2,
+        1.1f32, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 8.8, 7.7, 6.6, 5.5, 4.4, 3.3, 2.2,
     );
 
     let expected = Matrix4::new(
@@ -1022,7 +1022,7 @@ mod finite_dim_inner_space_tests {
      *
      */
     #[cfg(feature = "arbitrary")]
-    fn is_subspace_basis<T: FiniteDimInnerSpace<Real = f64> + Display>(vs: &[T]) -> bool {
+    fn is_subspace_basis<T: FiniteDimInnerSpace<RealField = f64, ComplexField = f64> + Display>(vs: &[T]) -> bool {
         for i in 0..vs.len() {
             // Basis elements must be normalized.
             if !relative_eq!(vs[i].norm(), 1.0, epsilon = 1.0e-7) {
diff --git a/tests/core/mod.rs b/tests/core/mod.rs
index 7e1f85919..c53493bdc 100644
--- a/tests/core/mod.rs
+++ b/tests/core/mod.rs
@@ -8,3 +8,7 @@ mod matrix_slice;
 #[cfg(feature = "mint")]
 mod mint;
 mod serde;
+
+
+#[cfg(feature = "arbitrary")]
+pub mod helper;
\ No newline at end of file
diff --git a/tests/geometry/isometry.rs b/tests/geometry/isometry.rs
index a0e002722..ecf29e94e 100644
--- a/tests/geometry/isometry.rs
+++ b/tests/geometry/isometry.rs
@@ -1,7 +1,6 @@
 #![cfg(feature = "arbitrary")]
 #![allow(non_snake_case)]
 
-use alga::linear::{ProjectiveTransformation, Transformation};
 use na::{
     Isometry2, Isometry3, Point2, Point3, Rotation2, Rotation3, Translation2, Translation3,
     UnitComplex, UnitQuaternion, Vector2, Vector3,
@@ -82,7 +81,7 @@ quickcheck!(
         r: Rotation2<f64>,
         t: Translation2<f64>,
         v: Vector2<f64>,
-        p: Point2<f64>,
+        p: Point2<f64>
     ) -> bool
     {
         // (rotation × translation) * point = rotation × (translation * point)
@@ -120,7 +119,7 @@ quickcheck!(
         r: Rotation3<f64>,
         t: Translation3<f64>,
         v: Vector3<f64>,
-        p: Point3<f64>,
+        p: Point3<f64>
     ) -> bool
     {
         // (rotation × translation) * point = rotation × (translation * point)
@@ -158,7 +157,7 @@ quickcheck!(
         t: Translation3<f64>,
         v: Vector3<f64>,
         p: Point3<f64>,
-        r: Rotation3<f64>,
+        r: Rotation3<f64>
     ) -> bool
     {
         let iMi = i * i;
diff --git a/tests/geometry/rotation.rs b/tests/geometry/rotation.rs
index e4b1f9d75..c08867549 100644
--- a/tests/geometry/rotation.rs
+++ b/tests/geometry/rotation.rs
@@ -1,4 +1,4 @@
-use na::{Quaternion, Real, UnitQuaternion, Vector2, Vector3};
+use na::{Quaternion, RealField, UnitQuaternion, Vector2, Vector3};
 
 #[test]
 fn angle_2() {
@@ -32,7 +32,7 @@ fn quaternion_euler_angles_issue_494() {
 
 #[cfg(feature = "arbitrary")]
 mod quickcheck_tests {
-    use alga::general::Real;
+    use alga::general::RealField;
     use na::{self, Rotation2, Rotation3, Unit, Vector2, Vector3};
     use std::f64;
 
diff --git a/tests/geometry/similarity.rs b/tests/geometry/similarity.rs
index 68b86943d..a57368646 100644
--- a/tests/geometry/similarity.rs
+++ b/tests/geometry/similarity.rs
@@ -1,7 +1,6 @@
 #![cfg(feature = "arbitrary")]
 #![allow(non_snake_case)]
 
-use alga::linear::{ProjectiveTransformation, Transformation};
 use na::{Isometry3, Point3, Similarity3, Translation3, UnitQuaternion, Vector3};
 
 quickcheck!(
@@ -19,7 +18,7 @@ quickcheck!(
     fn inverse_is_parts_inversion(
         t: Translation3<f64>,
         r: UnitQuaternion<f64>,
-        scaling: f64,
+        scaling: f64
     ) -> bool
     {
         if relative_eq!(scaling, 0.0) {
@@ -33,7 +32,7 @@ quickcheck!(
     fn multiply_equals_alga_transform(
         s: Similarity3<f64>,
         v: Vector3<f64>,
-        p: Point3<f64>,
+        p: Point3<f64>
     ) -> bool
     {
         s * v == s.transform_vector(&v)
@@ -56,7 +55,7 @@ quickcheck!(
         t: Translation3<f64>,
         v: Vector3<f64>,
         p: Point3<f64>,
-        scaling: f64,
+        scaling: f64
     ) -> bool
     {
         if relative_eq!(scaling, 0.0) {
@@ -152,7 +151,7 @@ quickcheck!(
         uq: UnitQuaternion<f64>,
         t: Translation3<f64>,
         v: Vector3<f64>,
-        p: Point3<f64>,
+        p: Point3<f64>
     ) -> bool
     {
         let sMs = s * s;
diff --git a/tests/geometry/unit_complex.rs b/tests/geometry/unit_complex.rs
index 88988aa87..469980368 100644
--- a/tests/geometry/unit_complex.rs
+++ b/tests/geometry/unit_complex.rs
@@ -72,7 +72,7 @@ quickcheck!(
         uc: UnitComplex<f64>,
         v: Vector2<f64>,
         p: Point2<f64>,
-        r: Rotation2<f64>,
+        r: Rotation2<f64>
     ) -> bool
     {
         let uv = Unit::new_normalize(v);
diff --git a/tests/lib.rs b/tests/lib.rs
index c32f40669..f6634d0fc 100644
--- a/tests/lib.rs
+++ b/tests/lib.rs
@@ -12,9 +12,10 @@ extern crate num_traits as num;
 extern crate quickcheck;
 extern crate rand;
 extern crate serde_json;
+extern crate num_complex;
 
 mod core;
 mod geometry;
 mod linalg;
-#[cfg(feature = "sparse")]
-mod sparse;
+//#[cfg(feature = "sparse")]
+//mod sparse;
diff --git a/tests/linalg/bidiagonal.rs b/tests/linalg/bidiagonal.rs
index a7d5952fd..9778eea31 100644
--- a/tests/linalg/bidiagonal.rs
+++ b/tests/linalg/bidiagonal.rs
@@ -1,59 +1,78 @@
 #![cfg(feature = "arbitrary")]
 
-use na::{DMatrix, Matrix2, Matrix3x5, Matrix4, Matrix5x3};
-
-quickcheck! {
-    fn bidiagonal(m: DMatrix<f64>) -> bool {
-        if m.len() == 0  {
-            return true;
+macro_rules! gen_tests(
+    ($module: ident, $scalar: ty) => {
+        mod $module {
+            use na::{DMatrix, Matrix2, Matrix3x5, Matrix4, Matrix5x3};
+            #[allow(unused_imports)]
+            use crate::core::helper::{RandScalar, RandComplex};
+
+            quickcheck! {
+                fn bidiagonal(m: DMatrix<$scalar>) -> bool {
+                    let m = m.map(|e| e.0);
+                    if m.len() == 0  {
+                        return true;
+                    }
+
+                    let bidiagonal = m.clone().bidiagonalize();
+                    let (u, d, v_t) = bidiagonal.unpack();
+
+                    relative_eq!(m, &u * d * &v_t, epsilon = 1.0e-7)
+                }
+
+                fn bidiagonal_static_5_3(m: Matrix5x3<$scalar>) -> bool {
+                    let m = m.map(|e| e.0);
+                    let bidiagonal = m.bidiagonalize();
+                    let (u, d, v_t) = bidiagonal.unpack();
+
+                    relative_eq!(m, &u * d * &v_t, epsilon = 1.0e-7)
+                }
+
+                fn bidiagonal_static_3_5(m: Matrix3x5<$scalar>) -> bool {
+                    let m = m.map(|e| e.0);
+                    let bidiagonal = m.bidiagonalize();
+                    let (u, d, v_t) = bidiagonal.unpack();
+
+                    relative_eq!(m, &u * d * &v_t, epsilon = 1.0e-7)
+                }
+
+                fn bidiagonal_static_square(m: Matrix4<$scalar>) -> bool {
+                    let m = m.map(|e| e.0);
+                    let bidiagonal = m.bidiagonalize();
+                    let (u, d, v_t) = bidiagonal.unpack();
+
+                    relative_eq!(m, &u * d * &v_t, epsilon = 1.0e-7)
+                }
+
+                fn bidiagonal_static_square_2x2(m: Matrix2<$scalar>) -> bool {
+                    let m = m.map(|e| e.0);
+                    let bidiagonal = m.bidiagonalize();
+                    let (u, d, v_t) = bidiagonal.unpack();
+
+                    relative_eq!(m, &u * d * &v_t, epsilon = 1.0e-7)
+                }
+            }
         }
-
-        let bidiagonal = m.clone().bidiagonalize();
-        let (u, d, v_t) = bidiagonal.unpack();
-
-        println!("{}{}{}", &u, &d, &v_t);
-        println!("{:.7}{:.7}", &u * &d * &v_t, m);
-
-        relative_eq!(m, &u * d * &v_t, epsilon = 1.0e-7)
-    }
-
-    fn bidiagonal_static_5_3(m: Matrix5x3<f64>) -> bool {
-        let bidiagonal = m.bidiagonalize();
-        let (u, d, v_t) = bidiagonal.unpack();
-
-        println!("{}{}{}", &u, &d, &v_t);
-        println!("{:.7}{:.7}", &u * &d * &v_t, m);
-
-        relative_eq!(m, &u * d * &v_t, epsilon = 1.0e-7)
-    }
-
-    fn bidiagonal_static_3_5(m: Matrix3x5<f64>) -> bool {
-        let bidiagonal = m.bidiagonalize();
-        let (u, d, v_t) = bidiagonal.unpack();
-
-        println!("{}{}{}", &u, &d, &v_t);
-        println!("{:.7}{:.7}", &u * &d * &v_t, m);
-
-        relative_eq!(m, &u * d * &v_t, epsilon = 1.0e-7)
-    }
-
-    fn bidiagonal_static_square(m: Matrix4<f64>) -> bool {
-        let bidiagonal = m.bidiagonalize();
-        let (u, d, v_t) = bidiagonal.unpack();
-
-        println!("{}{}{}", &u, &d, &v_t);
-        println!("{:.7}{:.7}", &u * &d * &v_t, m);
-
-        relative_eq!(m, &u * d * &v_t, epsilon = 1.0e-7)
-    }
-
-    fn bidiagonal_static_square_2x2(m: Matrix2<f64>) -> bool {
-        let bidiagonal = m.bidiagonalize();
-        let (u, d, v_t) = bidiagonal.unpack();
-
-        println!("{}{}{}", &u, &d, &v_t);
-        println!("{:.7}{:.7}", &u * &d * &v_t, m);
-
-        relative_eq!(m, &u * d * &v_t, epsilon = 1.0e-7)
     }
-}
+);
+
+gen_tests!(complex, RandComplex<f64>);
+gen_tests!(f64, RandScalar<f64>);
+
+#[test]
+fn bidiagonal_identity() {
+    let m = na::DMatrix::<f64>::identity(10, 10);
+    let bidiagonal = m.clone().bidiagonalize();
+    let (u, d, v_t) = bidiagonal.unpack();
+    assert_eq!(m, &u * d * &v_t);
+
+    let m = na::DMatrix::<f64>::identity(10, 15);
+    let bidiagonal = m.clone().bidiagonalize();
+    let (u, d, v_t) = bidiagonal.unpack();
+    assert_eq!(m, &u * d * &v_t);
+
+    let m = na::DMatrix::<f64>::identity(15, 10);
+    let bidiagonal = m.clone().bidiagonalize();
+    let (u, d, v_t) = bidiagonal.unpack();
+    assert_eq!(m, &u * d * &v_t);
+}
\ No newline at end of file
diff --git a/tests/linalg/cholesky.rs b/tests/linalg/cholesky.rs
index 9fe086ff9..cefc26307 100644
--- a/tests/linalg/cholesky.rs
+++ b/tests/linalg/cholesky.rs
@@ -1,81 +1,87 @@
 #![cfg(all(feature = "arbitrary", feature = "debug"))]
 
-use na::debug::RandomSDP;
-use na::dimension::U4;
-use na::{DMatrix, DVector, Matrix4x3, Vector4};
-use std::cmp;
 
-quickcheck! {
-    fn cholesky(m: RandomSDP<f64>) -> bool {
-        let mut m = m.unwrap();
-
-        // Put garbage on the upper triangle to make sure it is not read by the decomposition.
-        m.fill_upper_triangle(23.0, 1);
-
-        let l = m.clone().cholesky().unwrap().unpack();
-        m.fill_upper_triangle_with_lower_triangle();
-        relative_eq!(m, &l * l.transpose(), epsilon = 1.0e-7)
-    }
-
-    fn cholesky_static(m: RandomSDP<f64, U4>) -> bool {
-        let m = m.unwrap();
-        let chol = m.cholesky().unwrap();
-        let l    = chol.unpack();
-
-        if !relative_eq!(m, &l * l.transpose(), epsilon = 1.0e-7) {
-            false
-        }
-        else {
-            true
+macro_rules! gen_tests(
+    ($module: ident, $scalar: ty) => {
+        mod $module {
+            use na::debug::RandomSDP;
+            use na::dimension::{U4, Dynamic};
+            use na::{DMatrix, DVector, Matrix4x3, Vector4};
+            use rand::random;
+            #[allow(unused_imports)]
+            use crate::core::helper::{RandScalar, RandComplex};
+            use std::cmp;
+
+            quickcheck! {
+                fn cholesky(n: usize) -> bool {
+                    let m = RandomSDP::new(Dynamic::new(n.max(1).min(50)), || random::<$scalar>().0).unwrap();
+                    let l = m.clone().cholesky().unwrap().unpack();
+                    relative_eq!(m, &l * l.adjoint(), epsilon = 1.0e-7)
+                }
+
+                fn cholesky_static(_m: RandomSDP<f64, U4>) -> bool {
+                    let m = RandomSDP::new(U4, || random::<$scalar>().0).unwrap();
+                    let chol = m.cholesky().unwrap();
+                    let l    = chol.unpack();
+
+                    if !relative_eq!(m, &l * l.adjoint(), epsilon = 1.0e-7) {
+                        false
+                    }
+                    else {
+                        true
+                    }
+                }
+
+                fn cholesky_solve(n: usize, nb: usize) -> bool {
+                    let n = n.max(1).min(50);
+                    let m = RandomSDP::new(Dynamic::new(n), || random::<$scalar>().0).unwrap();
+                    let nb = cmp::min(nb, 50); // To avoid slowing down the test too much.
+
+                    let chol = m.clone().cholesky().unwrap();
+                    let b1 = DVector::<$scalar>::new_random(n).map(|e| e.0);
+                    let b2 = DMatrix::<$scalar>::new_random(n, nb).map(|e| e.0);
+
+                    let sol1 = chol.solve(&b1);
+                    let sol2 = chol.solve(&b2);
+
+                    relative_eq!(&m * &sol1, b1, epsilon = 1.0e-7) &&
+                    relative_eq!(&m * &sol2, b2, epsilon = 1.0e-7)
+                }
+
+                fn cholesky_solve_static(_n: usize) -> bool {
+                    let m = RandomSDP::new(U4, || random::<$scalar>().0).unwrap();
+                    let chol = m.clone().cholesky().unwrap();
+                    let b1 = Vector4::<$scalar>::new_random().map(|e| e.0);
+                    let b2 = Matrix4x3::<$scalar>::new_random().map(|e| e.0);
+
+                    let sol1 = chol.solve(&b1);
+                    let sol2 = chol.solve(&b2);
+
+                    relative_eq!(m * sol1, b1, epsilon = 1.0e-7) &&
+                    relative_eq!(m * sol2, b2, epsilon = 1.0e-7)
+                }
+
+                fn cholesky_inverse(n: usize) -> bool {
+                    let m = RandomSDP::new(Dynamic::new(n.max(1).min(50)), || random::<$scalar>().0).unwrap();
+                    let m1 = m.clone().cholesky().unwrap().inverse();
+                    let id1 = &m  * &m1;
+                    let id2 = &m1 * &m;
+
+                    id1.is_identity(1.0e-7) && id2.is_identity(1.0e-7)
+                }
+
+                fn cholesky_inverse_static(_n: usize) -> bool {
+                    let m = RandomSDP::new(U4, || random::<$scalar>().0).unwrap();
+                    let m1 = m.clone().cholesky().unwrap().inverse();
+                    let id1 = &m  * &m1;
+                    let id2 = &m1 * &m;
+
+                    id1.is_identity(1.0e-7) && id2.is_identity(1.0e-7)
+                }
+            }
         }
     }
+);
 
-
-    fn cholesky_solve(m: RandomSDP<f64>, nb: usize) -> bool {
-        let m  = m.unwrap();
-        let n  = m.nrows();
-        let nb = cmp::min(nb, 50); // To avoid slowing down the test too much.
-
-        let chol = m.clone().cholesky().unwrap();
-        let b1 = DVector::new_random(n);
-        let b2 = DMatrix::new_random(n, nb);
-
-        let sol1 = chol.solve(&b1);
-        let sol2 = chol.solve(&b2);
-
-        relative_eq!(&m * &sol1, b1, epsilon = 1.0e-7) &&
-        relative_eq!(&m * &sol2, b2, epsilon = 1.0e-7)
-    }
-
-    fn cholesky_solve_static(m: RandomSDP<f64, U4>) -> bool {
-        let m = m.unwrap();
-        let chol = m.clone().cholesky().unwrap();
-        let b1 = Vector4::new_random();
-        let b2 = Matrix4x3::new_random();
-
-        let sol1 = chol.solve(&b1);
-        let sol2 = chol.solve(&b2);
-
-        relative_eq!(m * sol1, b1, epsilon = 1.0e-7) &&
-        relative_eq!(m * sol2, b2, epsilon = 1.0e-7)
-    }
-
-    fn cholesky_inverse(m: RandomSDP<f64>) -> bool {
-        let m = m.unwrap();
-
-        let m1 = m.clone().cholesky().unwrap().inverse();
-        let id1 = &m  * &m1;
-        let id2 = &m1 * &m;
-
-        id1.is_identity(1.0e-7) && id2.is_identity(1.0e-7)
-    }
-
-    fn cholesky_inverse_static(m: RandomSDP<f64, U4>) -> bool {
-        let m = m.unwrap();
-        let m1 = m.clone().cholesky().unwrap().inverse();
-        let id1 = &m  * &m1;
-        let id2 = &m1 * &m;
-
-        id1.is_identity(1.0e-7) && id2.is_identity(1.0e-7)
-    }
-}
+gen_tests!(complex, RandComplex<f64>);
+gen_tests!(f64, RandScalar<f64>);
diff --git a/tests/linalg/eigen.rs b/tests/linalg/eigen.rs
index 36855acfe..8b2f8ed1d 100644
--- a/tests/linalg/eigen.rs
+++ b/tests/linalg/eigen.rs
@@ -4,61 +4,65 @@ use na::DMatrix;
 
 #[cfg(feature = "arbitrary")]
 mod quickcheck_tests {
-    use na::{DMatrix, Matrix2, Matrix3, Matrix4};
-    use std::cmp;
-
-    quickcheck! {
-        fn symmetric_eigen(n: usize) -> bool {
-            let n      = cmp::max(1, cmp::min(n, 10));
-            let m      = DMatrix::<f64>::new_random(n, n);
-            let eig    = m.clone().symmetric_eigen();
-            let recomp = eig.recompose();
-
-            println!("{}{}", m.lower_triangle(), recomp.lower_triangle());
-
-            relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5)
-        }
-
-        fn symmetric_eigen_singular(n: usize) -> bool {
-            let n      = cmp::max(1, cmp::min(n, 10));
-            let mut m  = DMatrix::<f64>::new_random(n, n);
-            m.row_mut(n / 2).fill(0.0);
-            m.column_mut(n / 2).fill(0.0);
-            let eig    = m.clone().symmetric_eigen();
-            let recomp = eig.recompose();
-
-            println!("{}{}", m.lower_triangle(), recomp.lower_triangle());
-
-            relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5)
-        }
-
-        fn symmetric_eigen_static_square_4x4(m: Matrix4<f64>) -> bool {
-            let eig    = m.symmetric_eigen();
-            let recomp = eig.recompose();
-
-            println!("{}{}", m.lower_triangle(), recomp.lower_triangle());
-
-            relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5)
-        }
-
-        fn symmetric_eigen_static_square_3x3(m: Matrix3<f64>) -> bool {
-            let eig    = m.symmetric_eigen();
-            let recomp = eig.recompose();
-
-            println!("{}{}", m.lower_triangle(), recomp.lower_triangle());
-
-            relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5)
+    macro_rules! gen_tests(
+        ($module: ident, $scalar: ty) => {
+            mod $module {
+                use na::{DMatrix, Matrix2, Matrix3, Matrix4};
+                #[allow(unused_imports)]
+                use crate::core::helper::{RandScalar, RandComplex};
+                use std::cmp;
+
+                quickcheck! {
+                    fn symmetric_eigen(n: usize) -> bool {
+                        let n      = cmp::max(1, cmp::min(n, 10));
+                        let m      = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0).hermitian_part();
+                        let eig    = m.clone().symmetric_eigen();
+                        let recomp = eig.recompose();
+
+                        relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5)
+                    }
+
+                    fn symmetric_eigen_singular(n: usize) -> bool {
+                        let n      = cmp::max(1, cmp::min(n, 10));
+                        let mut m  = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0).hermitian_part();
+                        m.row_mut(n / 2).fill(na::zero());
+                        m.column_mut(n / 2).fill(na::zero());
+                        let eig    = m.clone().symmetric_eigen();
+                        let recomp = eig.recompose();
+
+                        relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5)
+                    }
+
+                    fn symmetric_eigen_static_square_4x4(m: Matrix4<$scalar>) -> bool {
+                        let m      = m.map(|e| e.0).hermitian_part();
+                        let eig    = m.symmetric_eigen();
+                        let recomp = eig.recompose();
+
+                        relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5)
+                    }
+
+                    fn symmetric_eigen_static_square_3x3(m: Matrix3<$scalar>) -> bool {
+                        let m      = m.map(|e| e.0).hermitian_part();
+                        let eig    = m.symmetric_eigen();
+                        let recomp = eig.recompose();
+
+                        relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5)
+                    }
+
+                    fn symmetric_eigen_static_square_2x2(m: Matrix2<$scalar>) -> bool {
+                        let m      = m.map(|e| e.0).hermitian_part();
+                        let eig    = m.symmetric_eigen();
+                        let recomp = eig.recompose();
+
+                        relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5)
+                    }
+                }
+            }
         }
+    );
 
-        fn symmetric_eigen_static_square_2x2(m: Matrix2<f64>) -> bool {
-            let eig    = m.symmetric_eigen();
-            let recomp = eig.recompose();
-
-            println!("{}{}", m.lower_triangle(), recomp.lower_triangle());
-
-            relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-5)
-        }
-    }
+    gen_tests!(complex, RandComplex<f64>);
+    gen_tests!(f64, RandScalar<f64>);
 }
 
 // Test proposed on the issue #176 of rulinalg.
@@ -98,11 +102,11 @@ fn symmetric_eigen_singular_24x24() {
     let eig = m.clone().symmetric_eigen();
     let recomp = eig.recompose();
 
-    assert!(relative_eq!(
+    assert_relative_eq!(
         m.lower_triangle(),
         recomp.lower_triangle(),
         epsilon = 1.0e-5
-    ));
+    );
 }
 
 //  #[cfg(feature = "arbitrary")]
diff --git a/tests/linalg/full_piv_lu.rs b/tests/linalg/full_piv_lu.rs
index 5a0ad75b1..320fe241d 100644
--- a/tests/linalg/full_piv_lu.rs
+++ b/tests/linalg/full_piv_lu.rs
@@ -42,122 +42,140 @@ fn full_piv_lu_simple_with_pivot() {
 
 #[cfg(feature = "arbitrary")]
 mod quickcheck_tests {
-    use std::cmp;
-    use na::{DMatrix, Matrix4, Matrix4x3, Matrix5x3, Matrix3x5, DVector, Vector4};
-
-    quickcheck! {
-        fn full_piv_lu(m: DMatrix<f64>) -> bool {
-            let mut m = m;
-            if m.len() == 0 {
-                m = DMatrix::new_random(1, 1);
+    macro_rules! gen_tests(
+    ($module: ident, $scalar: ty) => {
+            mod $module {
+                use std::cmp;
+                use num::One;
+                use na::{DMatrix, Matrix4, Matrix4x3, Matrix5x3, Matrix3x5, DVector, Vector4};
+                #[allow(unused_imports)]
+                use crate::core::helper::{RandScalar, RandComplex};
+
+                quickcheck! {
+                    fn full_piv_lu(m: DMatrix<$scalar>) -> bool {
+                        let mut m = m.map(|e| e.0);
+                        if m.len() == 0 {
+                            m = DMatrix::<$scalar>::new_random(1, 1).map(|e| e.0);
+                        }
+
+                        let lu = m.clone().full_piv_lu();
+                        let (p, l, u, q) = lu.unpack();
+                        let mut lu = l * u;
+                        p.inv_permute_rows(&mut lu);
+                        q.inv_permute_columns(&mut lu);
+
+                        relative_eq!(m, lu, epsilon = 1.0e-7)
+                    }
+
+                    fn full_piv_lu_static_3_5(m: Matrix3x5<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let lu = m.full_piv_lu();
+                        let (p, l, u, q) = lu.unpack();
+                        let mut lu = l * u;
+                        p.inv_permute_rows(&mut lu);
+                        q.inv_permute_columns(&mut lu);
+
+                        relative_eq!(m, lu, epsilon = 1.0e-7)
+                    }
+
+                    fn full_piv_lu_static_5_3(m: Matrix5x3<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let lu = m.full_piv_lu();
+                        let (p, l, u, q) = lu.unpack();
+                        let mut lu = l * u;
+                        p.inv_permute_rows(&mut lu);
+                        q.inv_permute_columns(&mut lu);
+
+                        relative_eq!(m, lu, epsilon = 1.0e-7)
+                    }
+
+                    fn full_piv_lu_static_square(m: Matrix4<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let lu = m.full_piv_lu();
+                        let (p, l, u, q) = lu.unpack();
+                        let mut lu = l * u;
+                        p.inv_permute_rows(&mut lu);
+                        q.inv_permute_columns(&mut lu);
+
+                        relative_eq!(m, lu, epsilon = 1.0e-7)
+                    }
+
+                    fn full_piv_lu_solve(n: usize, nb: usize) -> bool {
+                        if n != 0 && nb != 0 {
+                            let n  = cmp::min(n, 50);  // To avoid slowing down the test too much.
+                            let nb = cmp::min(nb, 50); // To avoid slowing down the test too much.
+                            let m  = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0);
+
+                            let lu = m.clone().full_piv_lu();
+                            let b1 = DVector::<$scalar>::new_random(n).map(|e| e.0);
+                            let b2 = DMatrix::<$scalar>::new_random(n, nb).map(|e| e.0);
+
+                            let sol1 = lu.solve(&b1);
+                            let sol2 = lu.solve(&b2);
+
+                            return (sol1.is_none() || relative_eq!(&m * sol1.unwrap(), b1, epsilon = 1.0e-6)) &&
+                                   (sol2.is_none() || relative_eq!(&m * sol2.unwrap(), b2, epsilon = 1.0e-6))
+                        }
+
+                        return true;
+                    }
+
+                    fn full_piv_lu_solve_static(m: Matrix4<$scalar>) -> bool {
+                         let m = m.map(|e| e.0);
+                         let lu = m.full_piv_lu();
+                         let b1 = Vector4::<$scalar>::new_random().map(|e| e.0);
+                         let b2 = Matrix4x3::<$scalar>::new_random().map(|e| e.0);
+
+                         let sol1 = lu.solve(&b1);
+                         let sol2 = lu.solve(&b2);
+
+                         return (sol1.is_none() || relative_eq!(&m * sol1.unwrap(), b1, epsilon = 1.0e-6)) &&
+                                (sol2.is_none() || relative_eq!(&m * sol2.unwrap(), b2, epsilon = 1.0e-6))
+                    }
+
+                    fn full_piv_lu_inverse(n: usize) -> bool {
+                        let n = cmp::max(1, cmp::min(n, 15)); // To avoid slowing down the test too much.
+                        let m = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0);
+
+                        let mut l = m.lower_triangle();
+                        let mut u = m.upper_triangle();
+
+                        // Ensure the matrix is well conditioned for inversion.
+                        l.fill_diagonal(One::one());
+                        u.fill_diagonal(One::one());
+                        let m = l * u;
+
+                        let m1  = m.clone().full_piv_lu().try_inverse().unwrap();
+                        let id1 = &m  * &m1;
+                        let id2 = &m1 * &m;
+
+                        return id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5);
+                    }
+
+                    fn full_piv_lu_inverse_static(m: Matrix4<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let lu = m.full_piv_lu();
+
+                        if let Some(m1)  = lu.try_inverse() {
+                            let id1 = &m  * &m1;
+                            let id2 = &m1 * &m;
+
+                            id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5)
+                        }
+                        else {
+                            true
+                        }
+                    }
+                }
             }
-
-            let lu = m.clone().full_piv_lu();
-            let (p, l, u, q) = lu.unpack();
-            let mut lu = l * u;
-            p.inv_permute_rows(&mut lu);
-            q.inv_permute_columns(&mut lu);
-
-            relative_eq!(m, lu, epsilon = 1.0e-7)
-        }
-
-        fn full_piv_lu_static_3_5(m: Matrix3x5<f64>) -> bool {
-            let lu = m.full_piv_lu();
-            let (p, l, u, q) = lu.unpack();
-            let mut lu = l * u;
-            p.inv_permute_rows(&mut lu);
-            q.inv_permute_columns(&mut lu);
-
-            relative_eq!(m, lu, epsilon = 1.0e-7)
-        }
-
-        fn full_piv_lu_static_5_3(m: Matrix5x3<f64>) -> bool {
-            let lu = m.full_piv_lu();
-            let (p, l, u, q) = lu.unpack();
-            let mut lu = l * u;
-            p.inv_permute_rows(&mut lu);
-            q.inv_permute_columns(&mut lu);
-
-            relative_eq!(m, lu, epsilon = 1.0e-7)
-        }
-
-        fn full_piv_lu_static_square(m: Matrix4<f64>) -> bool {
-            let lu = m.full_piv_lu();
-            let (p, l, u, q) = lu.unpack();
-            let mut lu = l * u;
-            p.inv_permute_rows(&mut lu);
-            q.inv_permute_columns(&mut lu);
-
-            relative_eq!(m, lu, epsilon = 1.0e-7)
-        }
-
-        fn full_piv_lu_solve(n: usize, nb: usize) -> bool {
-            if n != 0 && nb != 0 {
-                let n  = cmp::min(n, 50);  // To avoid slowing down the test too much.
-                let nb = cmp::min(nb, 50); // To avoid slowing down the test too much.
-                let m  = DMatrix::<f64>::new_random(n, n);
-
-                let lu = m.clone().full_piv_lu();
-                let b1 = DVector::new_random(n);
-                let b2 = DMatrix::new_random(n, nb);
-
-                let sol1 = lu.solve(&b1);
-                let sol2 = lu.solve(&b2);
-
-                return (sol1.is_none() || relative_eq!(&m * sol1.unwrap(), b1, epsilon = 1.0e-6)) &&
-                       (sol2.is_none() || relative_eq!(&m * sol2.unwrap(), b2, epsilon = 1.0e-6))
-            }
-
-            return true;
-        }
-
-        fn full_piv_lu_solve_static(m: Matrix4<f64>) -> bool {
-             let lu = m.full_piv_lu();
-             let b1 = Vector4::new_random();
-             let b2 = Matrix4x3::new_random();
-
-             let sol1 = lu.solve(&b1);
-             let sol2 = lu.solve(&b2);
-
-             return (sol1.is_none() || relative_eq!(&m * sol1.unwrap(), b1, epsilon = 1.0e-6)) &&
-                    (sol2.is_none() || relative_eq!(&m * sol2.unwrap(), b2, epsilon = 1.0e-6))
         }
+    );
 
-        fn full_piv_lu_inverse(n: usize) -> bool {
-            let n = cmp::max(1, cmp::min(n, 15)); // To avoid slowing down the test too much.
-            let m = DMatrix::<f64>::new_random(n, n);
-
-            let mut l = m.lower_triangle();
-            let mut u = m.upper_triangle();
-
-            // Ensure the matrix is well conditioned for inversion.
-            l.fill_diagonal(1.0);
-            u.fill_diagonal(1.0);
-            let m = l * u;
-
-            let m1  = m.clone().full_piv_lu().try_inverse().unwrap();
-            let id1 = &m  * &m1;
-            let id2 = &m1 * &m;
-
-            return id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5);
-        }
-
-        fn full_piv_lu_inverse_static(m: Matrix4<f64>) -> bool {
-            let lu = m.full_piv_lu();
-
-            if let Some(m1)  = lu.try_inverse() {
-                let id1 = &m  * &m1;
-                let id2 = &m1 * &m;
-
-                id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5)
-            }
-            else {
-                true
-            }
-        }
-    }
+    gen_tests!(complex, RandComplex<f64>);
+    gen_tests!(f64, RandScalar<f64>);
 }
 
+
 /*
 #[test]
 fn swap_rows() {
diff --git a/tests/linalg/hessenberg.rs b/tests/linalg/hessenberg.rs
index 22d62fbfa..378fbd877 100644
--- a/tests/linalg/hessenberg.rs
+++ b/tests/linalg/hessenberg.rs
@@ -1,7 +1,7 @@
 #![cfg(feature = "arbitrary")]
 
-use na::{DMatrix, Matrix2, Matrix4};
-use std::cmp;
+use na::Matrix2;
+
 
 #[test]
 fn hessenberg_simple() {
@@ -11,25 +11,42 @@ fn hessenberg_simple() {
     assert!(relative_eq!(m, p * h * p.transpose(), epsilon = 1.0e-7))
 }
 
-quickcheck! {
-    fn hessenberg(n: usize) -> bool {
-        let n = cmp::max(1, cmp::min(n, 50));
-        let m = DMatrix::<f64>::new_random(n, n);
 
-        let hess = m.clone().hessenberg();
-        let (p, h) = hess.unpack();
-        relative_eq!(m, &p * h * p.transpose(), epsilon = 1.0e-7)
-    }
+macro_rules! gen_tests(
+    ($module: ident, $scalar: ty) => {
+         mod $module {
+            use na::{DMatrix, Matrix2, Matrix4};
+            use std::cmp;
+            #[allow(unused_imports)]
+            use crate::core::helper::{RandScalar, RandComplex};
 
-    fn hessenberg_static_mat2(m: Matrix2<f64>) -> bool {
-        let hess = m.hessenberg();
-        let (p, h) = hess.unpack();
-        relative_eq!(m, p * h * p.transpose(), epsilon = 1.0e-7)
-    }
+            quickcheck! {
+                fn hessenberg(n: usize) -> bool {
+                    let n = cmp::max(1, cmp::min(n, 50));
+                    let m = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0);
+
+                    let hess = m.clone().hessenberg();
+                    let (p, h) = hess.unpack();
+                    relative_eq!(m, &p * h * p.adjoint(), epsilon = 1.0e-7)
+                }
 
-    fn hessenberg_static(m: Matrix4<f64>) -> bool {
-        let hess = m.hessenberg();
-        let (p, h) = hess.unpack();
-        relative_eq!(m, p * h * p.transpose(), epsilon = 1.0e-7)
+                fn hessenberg_static_mat2(m: Matrix2<$scalar>) -> bool {
+                    let m = m.map(|e| e.0);
+                    let hess = m.hessenberg();
+                    let (p, h) = hess.unpack();
+                    relative_eq!(m, p * h * p.adjoint(), epsilon = 1.0e-7)
+                }
+
+                fn hessenberg_static(m: Matrix4<$scalar>) -> bool {
+                    let m = m.map(|e| e.0);
+                    let hess = m.hessenberg();
+                    let (p, h) = hess.unpack();
+                    relative_eq!(m, p * h * p.adjoint(), epsilon = 1.0e-7)
+                }
+            }
+         }
     }
-}
+);
+
+gen_tests!(complex, RandComplex<f64>);
+gen_tests!(f64, RandScalar<f64>);
\ No newline at end of file
diff --git a/tests/linalg/lu.rs b/tests/linalg/lu.rs
index 5069f7e57..69c387d2a 100644
--- a/tests/linalg/lu.rs
+++ b/tests/linalg/lu.rs
@@ -40,114 +40,135 @@ fn lu_simple_with_pivot() {
 
 #[cfg(feature = "arbitrary")]
 mod quickcheck_tests {
-    use std::cmp;
-    use na::{DMatrix, Matrix4, Matrix4x3, Matrix5x3, Matrix3x5, DVector, Vector4};
-
-    quickcheck! {
-        fn lu(m: DMatrix<f64>) -> bool {
-            let mut m = m;
-            if m.len() == 0 {
-                m = DMatrix::new_random(1, 1);
+    #[allow(unused_imports)]
+    use crate::core::helper::{RandScalar, RandComplex};
+
+    macro_rules! gen_tests(
+        ($module: ident, $scalar: ty) => {
+            mod $module {
+                use std::cmp;
+                use na::{DMatrix, Matrix4, Matrix4x3, Matrix5x3, Matrix3x5, DVector, Vector4};
+                #[allow(unused_imports)]
+                use crate::core::helper::{RandScalar, RandComplex};
+
+                quickcheck! {
+                    fn lu(m: DMatrix<$scalar>) -> bool {
+                        let mut m = m;
+                        if m.len() == 0 {
+                             m = DMatrix::<$scalar>::new_random(1, 1);
+                        }
+
+                        let m = m.map(|e| e.0);
+
+                        let lu = m.clone().lu();
+                        let (p, l, u) = lu.unpack();
+                        let mut lu = l * u;
+                        p.inv_permute_rows(&mut lu);
+
+                        relative_eq!(m, lu, epsilon = 1.0e-7)
+                    }
+
+                    fn lu_static_3_5(m: Matrix3x5<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let lu = m.lu();
+                        let (p, l, u) = lu.unpack();
+                        let mut lu = l * u;
+                        p.inv_permute_rows(&mut lu);
+
+                        relative_eq!(m, lu, epsilon = 1.0e-7)
+                    }
+
+                    fn lu_static_5_3(m: Matrix5x3<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let lu = m.lu();
+                        let (p, l, u) = lu.unpack();
+                        let mut lu = l * u;
+                        p.inv_permute_rows(&mut lu);
+
+                        relative_eq!(m, lu, epsilon = 1.0e-7)
+                    }
+
+                    fn lu_static_square(m: Matrix4<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let lu = m.lu();
+                        let (p, l, u) = lu.unpack();
+                        let mut lu = l * u;
+                        p.inv_permute_rows(&mut lu);
+
+                        relative_eq!(m, lu, epsilon = 1.0e-7)
+                    }
+
+                    fn lu_solve(n: usize, nb: usize) -> bool {
+                        if n != 0 && nb != 0 {
+                            let n  = cmp::min(n, 50);  // To avoid slowing down the test too much.
+                            let nb = cmp::min(nb, 50); // To avoid slowing down the test too much.
+                            let m  = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0);
+
+                            let lu = m.clone().lu();
+                            let b1 = DVector::<$scalar>::new_random(n).map(|e| e.0);
+                            let b2 = DMatrix::<$scalar>::new_random(n, nb).map(|e| e.0);
+
+                            let sol1 = lu.solve(&b1);
+                            let sol2 = lu.solve(&b2);
+
+                            return (sol1.is_none() || relative_eq!(&m * sol1.unwrap(), b1, epsilon = 1.0e-6)) &&
+                                   (sol2.is_none() || relative_eq!(&m * sol2.unwrap(), b2, epsilon = 1.0e-6))
+                        }
+
+                        return true;
+                    }
+
+                    fn lu_solve_static(m: Matrix4<$scalar>) -> bool {
+                         let m = m.map(|e| e.0);
+                         let lu = m.lu();
+                         let b1 = Vector4::<$scalar>::new_random().map(|e| e.0);
+                         let b2 = Matrix4x3::<$scalar>::new_random().map(|e| e.0);
+
+                         let sol1 = lu.solve(&b1);
+                         let sol2 = lu.solve(&b2);
+
+                         return (sol1.is_none() || relative_eq!(&m * sol1.unwrap(), b1, epsilon = 1.0e-6)) &&
+                                (sol2.is_none() || relative_eq!(&m * sol2.unwrap(), b2, epsilon = 1.0e-6))
+                    }
+
+                    fn lu_inverse(n: usize) -> bool {
+                        let n = cmp::max(1, cmp::min(n, 15)); // To avoid slowing down the test too much.
+                        let m = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0);
+
+                        let mut l = m.lower_triangle();
+                        let mut u = m.upper_triangle();
+
+                        // Ensure the matrix is well conditioned for inversion.
+                        l.fill_diagonal(na::one());
+                        u.fill_diagonal(na::one());
+                        let m = l * u;
+
+                        let m1  = m.clone().lu().try_inverse().unwrap();
+                        let id1 = &m  * &m1;
+                        let id2 = &m1 * &m;
+
+                        return id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5);
+                    }
+
+                    fn lu_inverse_static(m: Matrix4<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let lu  = m.lu();
+
+                        if let Some(m1) = lu.try_inverse() {
+                            let id1 = &m  * &m1;
+                            let id2 = &m1 * &m;
+
+                            id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5)
+                        }
+                        else {
+                            true
+                        }
+                    }
+                }
             }
-
-            let lu = m.clone().lu();
-            let (p, l, u) = lu.unpack();
-            let mut lu = l * u;
-            p.inv_permute_rows(&mut lu);
-
-            relative_eq!(m, lu, epsilon = 1.0e-7)
-        }
-
-        fn lu_static_3_5(m: Matrix3x5<f64>) -> bool {
-            let lu = m.lu();
-            let (p, l, u) = lu.unpack();
-            let mut lu = l * u;
-            p.inv_permute_rows(&mut lu);
-
-            relative_eq!(m, lu, epsilon = 1.0e-7)
         }
+    );
 
-        fn lu_static_5_3(m: Matrix5x3<f64>) -> bool {
-            let lu = m.lu();
-            let (p, l, u) = lu.unpack();
-            let mut lu = l * u;
-            p.inv_permute_rows(&mut lu);
-
-            relative_eq!(m, lu, epsilon = 1.0e-7)
-        }
-
-        fn lu_static_square(m: Matrix4<f64>) -> bool {
-            let lu = m.lu();
-            let (p, l, u) = lu.unpack();
-            let mut lu = l * u;
-            p.inv_permute_rows(&mut lu);
-
-            relative_eq!(m, lu, epsilon = 1.0e-7)
-        }
-
-        fn lu_solve(n: usize, nb: usize) -> bool {
-            if n != 0 && nb != 0 {
-                let n  = cmp::min(n, 50);  // To avoid slowing down the test too much.
-                let nb = cmp::min(nb, 50); // To avoid slowing down the test too much.
-                let m  = DMatrix::<f64>::new_random(n, n);
-
-                let lu = m.clone().lu();
-                let b1 = DVector::new_random(n);
-                let b2 = DMatrix::new_random(n, nb);
-
-                let sol1 = lu.solve(&b1);
-                let sol2 = lu.solve(&b2);
-
-                return (sol1.is_none() || relative_eq!(&m * sol1.unwrap(), b1, epsilon = 1.0e-6)) &&
-                       (sol2.is_none() || relative_eq!(&m * sol2.unwrap(), b2, epsilon = 1.0e-6))
-            }
-
-            return true;
-        }
-
-        fn lu_solve_static(m: Matrix4<f64>) -> bool {
-             let lu = m.lu();
-             let b1 = Vector4::new_random();
-             let b2 = Matrix4x3::new_random();
-
-             let sol1 = lu.solve(&b1);
-             let sol2 = lu.solve(&b2);
-
-             return (sol1.is_none() || relative_eq!(&m * sol1.unwrap(), b1, epsilon = 1.0e-6)) &&
-                    (sol2.is_none() || relative_eq!(&m * sol2.unwrap(), b2, epsilon = 1.0e-6))
-        }
-
-        fn lu_inverse(n: usize) -> bool {
-            let n = cmp::max(1, cmp::min(n, 15)); // To avoid slowing down the test too much.
-            let m = DMatrix::<f64>::new_random(n, n);
-
-            let mut l = m.lower_triangle();
-            let mut u = m.upper_triangle();
-
-            // Ensure the matrix is well conditioned for inversion.
-            l.fill_diagonal(1.0);
-            u.fill_diagonal(1.0);
-            let m = l * u;
-
-            let m1  = m.clone().lu().try_inverse().unwrap();
-            let id1 = &m  * &m1;
-            let id2 = &m1 * &m;
-
-            return id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5);
-        }
-
-        fn lu_inverse_static(m: Matrix4<f64>) -> bool {
-            let lu  = m.lu();
-
-            if let Some(m1) = lu.try_inverse() {
-                let id1 = &m  * &m1;
-                let id2 = &m1 * &m;
-
-                id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5)
-            }
-            else {
-                true
-            }
-        }
-    }
+    gen_tests!(complex, RandComplex<f64>);
+    gen_tests!(f64, RandScalar<f64>);
 }
diff --git a/tests/linalg/mod.rs b/tests/linalg/mod.rs
index 4e0bf2ebf..e881d9997 100644
--- a/tests/linalg/mod.rs
+++ b/tests/linalg/mod.rs
@@ -7,7 +7,7 @@ mod hessenberg;
 mod inverse;
 mod lu;
 mod qr;
-mod real_schur;
+mod schur;
 mod solve;
 mod svd;
 mod tridiagonal;
diff --git a/tests/linalg/qr.rs b/tests/linalg/qr.rs
index d7211623c..93cb49733 100644
--- a/tests/linalg/qr.rs
+++ b/tests/linalg/qr.rs
@@ -1,112 +1,133 @@
 #![cfg(feature = "arbitrary")]
 
-use na::{DMatrix, DVector, Matrix3x5, Matrix4, Matrix4x3, Matrix5x3, Vector4};
-use std::cmp;
 
-quickcheck! {
-    fn qr(m: DMatrix<f64>) -> bool {
-        let qr = m.clone().qr();
-        let q  = qr.q();
-        let r  = qr.r();
-
-        relative_eq!(m, &q * r, epsilon = 1.0e-7) &&
-        q.is_orthogonal(1.0e-7)
-    }
-
-    fn qr_static_5_3(m: Matrix5x3<f64>) -> bool {
-        let qr = m.qr();
-        let q  = qr.q();
-        let r  = qr.r();
-
-        relative_eq!(m, q * r, epsilon = 1.0e-7) &&
-        q.is_orthogonal(1.0e-7)
-    }
-
-    fn qr_static_3_5(m: Matrix3x5<f64>) -> bool {
-        let qr = m.qr();
-        let q  = qr.q();
-        let r  = qr.r();
-
-        relative_eq!(m, q * r, epsilon = 1.0e-7) &&
-        q.is_orthogonal(1.0e-7)
-    }
-
-    fn qr_static_square(m: Matrix4<f64>) -> bool {
-        let qr = m.qr();
-        let q  = qr.q();
-        let r  = qr.r();
-
-        println!("{}{}{}{}", q, r, q * r, m);
-
-        relative_eq!(m, q * r, epsilon = 1.0e-7) &&
-        q.is_orthogonal(1.0e-7)
-    }
-
-    fn qr_solve(n: usize, nb: usize) -> bool {
-        if n != 0 && nb != 0 {
-            let n  = cmp::min(n, 50);  // To avoid slowing down the test too much.
-            let nb = cmp::min(nb, 50); // To avoid slowing down the test too much.
-            let m  = DMatrix::<f64>::new_random(n, n);
-
-            let qr = m.clone().qr();
-            let b1 = DVector::new_random(n);
-            let b2 = DMatrix::new_random(n, nb);
-
-            if qr.is_invertible() {
-                let sol1 = qr.solve(&b1).unwrap();
-                let sol2 = qr.solve(&b2).unwrap();
-
-                return relative_eq!(&m * sol1, b1, epsilon = 1.0e-6) &&
-                    relative_eq!(&m * sol2, b2, epsilon = 1.0e-6)
+macro_rules! gen_tests(
+    ($module: ident, $scalar: ty) => {
+        mod $module {
+            use na::{DMatrix, DVector, Matrix3x5, Matrix4, Matrix4x3, Matrix5x3, Vector4};
+            use std::cmp;
+            #[allow(unused_imports)]
+            use crate::core::helper::{RandScalar, RandComplex};
+
+            quickcheck! {
+                fn qr(m: DMatrix<$scalar>) -> bool {
+                    let m = m.map(|e| e.0);
+                    let qr = m.clone().qr();
+                    let q  = qr.q();
+                    let r  = qr.r();
+
+                    println!("m: {}", m);
+                    println!("qr: {}", &q * &r);
+
+                    relative_eq!(m, &q * r, epsilon = 1.0e-7) &&
+                    q.is_orthogonal(1.0e-7)
+                }
+
+                fn qr_static_5_3(m: Matrix5x3<$scalar>) -> bool {
+                    let m = m.map(|e| e.0);
+                    let qr = m.qr();
+                    let q  = qr.q();
+                    let r  = qr.r();
+
+                    relative_eq!(m, q * r, epsilon = 1.0e-7) &&
+                    q.is_orthogonal(1.0e-7)
+                }
+
+                fn qr_static_3_5(m: Matrix3x5<$scalar>) -> bool {
+                    let m = m.map(|e| e.0);
+                    let qr = m.qr();
+                    let q  = qr.q();
+                    let r  = qr.r();
+
+                    relative_eq!(m, q * r, epsilon = 1.0e-7) &&
+                    q.is_orthogonal(1.0e-7)
+                }
+
+                fn qr_static_square(m: Matrix4<$scalar>) -> bool {
+                    let m = m.map(|e| e.0);
+                    let qr = m.qr();
+                    let q  = qr.q();
+                    let r  = qr.r();
+
+                    println!("{}{}{}{}", q, r, q * r, m);
+
+                    relative_eq!(m, q * r, epsilon = 1.0e-7) &&
+                    q.is_orthogonal(1.0e-7)
+                }
+
+                fn qr_solve(n: usize, nb: usize) -> bool {
+                    if n != 0 && nb != 0 {
+                        let n  = cmp::min(n, 50);  // To avoid slowing down the test too much.
+                        let nb = cmp::min(nb, 50); // To avoid slowing down the test too much.
+                        let m  = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0);
+
+                        let qr = m.clone().qr();
+                        let b1 = DVector::<$scalar>::new_random(n).map(|e| e.0);
+                        let b2 = DMatrix::<$scalar>::new_random(n, nb).map(|e| e.0);
+
+                        if qr.is_invertible() {
+                            let sol1 = qr.solve(&b1).unwrap();
+                            let sol2 = qr.solve(&b2).unwrap();
+
+                            return relative_eq!(&m * sol1, b1, epsilon = 1.0e-6) &&
+                                relative_eq!(&m * sol2, b2, epsilon = 1.0e-6)
+                        }
+                    }
+
+                    return true;
+                }
+
+                fn qr_solve_static(m: Matrix4<$scalar>) -> bool {
+                     let m = m.map(|e| e.0);
+                     let qr = m.qr();
+                     let b1 = Vector4::<$scalar>::new_random().map(|e| e.0);
+                     let b2 = Matrix4x3::<$scalar>::new_random().map(|e| e.0);
+
+                     if qr.is_invertible() {
+                         let sol1 = qr.solve(&b1).unwrap();
+                         let sol2 = qr.solve(&b2).unwrap();
+
+                         relative_eq!(m * sol1, b1, epsilon = 1.0e-6) &&
+                         relative_eq!(m * sol2, b2, epsilon = 1.0e-6)
+                     }
+                     else {
+                         false
+                     }
+                }
+
+                fn qr_inverse(n: usize) -> bool {
+                    let n = cmp::max(1, cmp::min(n, 15)); // To avoid slowing down the test too much.
+                    let m = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0);
+
+                    if let Some(m1) = m.clone().qr().try_inverse() {
+                        let id1 = &m  * &m1;
+                        let id2 = &m1 * &m;
+
+                        id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5)
+                    }
+                    else {
+                        true
+                    }
+                }
+
+                fn qr_inverse_static(m: Matrix4<$scalar>) -> bool {
+                    let m  = m.map(|e| e.0);
+                    let qr = m.qr();
+
+                    if let Some(m1) = qr.try_inverse() {
+                        let id1 = &m  * &m1;
+                        let id2 = &m1 * &m;
+
+                        id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5)
+                    }
+                    else {
+                        true
+                    }
+                }
             }
         }
-
-        return true;
-    }
-
-    fn qr_solve_static(m: Matrix4<f64>) -> bool {
-         let qr = m.qr();
-         let b1 = Vector4::new_random();
-         let b2 = Matrix4x3::new_random();
-
-         if qr.is_invertible() {
-             let sol1 = qr.solve(&b1).unwrap();
-             let sol2 = qr.solve(&b2).unwrap();
-
-             relative_eq!(m * sol1, b1, epsilon = 1.0e-6) &&
-             relative_eq!(m * sol2, b2, epsilon = 1.0e-6)
-         }
-         else {
-             false
-         }
     }
+);
 
-    fn qr_inverse(n: usize) -> bool {
-        let n = cmp::max(1, cmp::min(n, 15)); // To avoid slowing down the test too much.
-        let m = DMatrix::<f64>::new_random(n, n);
-
-        if let Some(m1) = m.clone().qr().try_inverse() {
-            let id1 = &m  * &m1;
-            let id2 = &m1 * &m;
-
-            id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5)
-        }
-        else {
-            true
-        }
-    }
-
-    fn qr_inverse_static(m: Matrix4<f64>) -> bool {
-        let qr  = m.qr();
-
-        if let Some(m1) = qr.try_inverse() {
-            let id1 = &m  * &m1;
-            let id2 = &m1 * &m;
-
-            id1.is_identity(1.0e-5) && id2.is_identity(1.0e-5)
-        }
-        else {
-            true
-        }
-    }
-}
+gen_tests!(complex, RandComplex<f64>);
+gen_tests!(f64, RandScalar<f64>);
diff --git a/tests/linalg/real_schur.rs b/tests/linalg/schur.rs
similarity index 66%
rename from tests/linalg/real_schur.rs
rename to tests/linalg/schur.rs
index 554bbdefa..f9c923a26 100644
--- a/tests/linalg/real_schur.rs
+++ b/tests/linalg/schur.rs
@@ -2,14 +2,13 @@
 
 use na::{DMatrix, Matrix3, Matrix4};
 
-
 #[test]
 fn schur_simpl_mat3() {
     let m = Matrix3::new(-2.0, -4.0, 2.0,
                          -2.0,  1.0, 2.0,
                           4.0,  2.0, 5.0);
 
-    let schur = m.real_schur();
+    let schur = m.schur();
     let (vecs, vals) = schur.unpack();
 
     assert!(relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7));
@@ -17,54 +16,70 @@ fn schur_simpl_mat3() {
 
 #[cfg(feature = "arbitrary")]
 mod quickcheck_tests {
-    use std::cmp;
-    use na::{DMatrix, Matrix2, Matrix3, Matrix4};
-
-    quickcheck! {
-        fn schur(n: usize) -> bool {
-            let n = cmp::max(1, cmp::min(n, 10));
-            let m = DMatrix::<f64>::new_random(n, n);
-
-            let (vecs, vals) = m.clone().real_schur().unpack();
-
-            if !relative_eq!(&vecs * &vals * vecs.transpose(), m, epsilon = 1.0e-7) {
-                println!("{:.5}{:.5}", m, &vecs * &vals * vecs.transpose());
-            }
-
-            relative_eq!(&vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7)
-        }
-
-        fn schur_static_mat2(m: Matrix2<f64>) -> bool {
-            let (vecs, vals) = m.clone().real_schur().unpack();
-
-            let ok = relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7);
-            if !ok {
-                println!("{:.5}{:.5}", vecs, vals);
-                println!("Reconstruction:{}{}", m, &vecs * &vals * vecs.transpose());
-            }
-            ok
-        }
-
-        fn schur_static_mat3(m: Matrix3<f64>) -> bool {
-            let (vecs, vals) = m.clone().real_schur().unpack();
-
-            let ok = relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7);
-            if !ok {
-                println!("{:.5}{:.5}", m, &vecs * &vals * vecs.transpose());
+    macro_rules! gen_tests(
+        ($module: ident, $scalar: ty) => {
+            mod $module {
+                use std::cmp;
+                use na::{DMatrix, Matrix2, Matrix3, Matrix4};
+                #[allow(unused_imports)]
+                use crate::core::helper::{RandScalar, RandComplex};
+
+                quickcheck! {
+                    fn schur(n: usize) -> bool {
+                        let n = cmp::max(1, cmp::min(n, 10));
+                        let m = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0);
+
+                        let (vecs, vals) = m.clone().schur().unpack();
+
+                        if !relative_eq!(&vecs * &vals * vecs.adjoint(), m, epsilon = 1.0e-7) {
+                            println!("{:.5}{:.5}", m, &vecs * &vals * vecs.adjoint());
+                        }
+
+                        relative_eq!(&vecs * vals * vecs.adjoint(), m, epsilon = 1.0e-7)
+                    }
+
+                    fn schur_static_mat2(m: Matrix2<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let (vecs, vals) = m.clone().schur().unpack();
+
+                        let ok = relative_eq!(vecs * vals * vecs.adjoint(), m, epsilon = 1.0e-7);
+                        if !ok {
+                            println!("Vecs: {:.5} Vals: {:.5}", vecs, vals);
+                            println!("Reconstruction:{}{}", m, &vecs * &vals * vecs.adjoint());
+                        }
+                        ok
+                    }
+
+                    fn schur_static_mat3(m: Matrix3<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let (vecs, vals) = m.clone().schur().unpack();
+
+                        let ok = relative_eq!(vecs * vals * vecs.adjoint(), m, epsilon = 1.0e-7);
+                        if !ok {
+                            println!("Vecs: {:.5} Vals: {:.5}", vecs, vals);
+                            println!("{:.5}{:.5}", m, &vecs * &vals * vecs.adjoint());
+                        }
+                        ok
+                    }
+
+                    fn schur_static_mat4(m: Matrix4<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let (vecs, vals) = m.clone().schur().unpack();
+
+                        let ok = relative_eq!(vecs * vals * vecs.adjoint(), m, epsilon = 1.0e-7);
+                        if !ok {
+                            println!("{:.5}{:.5}", m, &vecs * &vals * vecs.adjoint());
+                        }
+
+                        ok
+                    }
+                }
             }
-            ok
         }
+    );
 
-        fn schur_static_mat4(m: Matrix4<f64>) -> bool {
-            let (vecs, vals) = m.clone().real_schur().unpack();
-
-            let ok = relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7);
-            if !ok {
-                println!("{:.5}{:.5}", m, &vecs * &vals * vecs.transpose());
-            }
-            ok
-        }
-    }
+    gen_tests!(complex, RandComplex<f64>);
+    gen_tests!(f64, RandScalar<f64>);
 }
 
 #[test]
@@ -75,8 +90,7 @@ fn schur_static_mat4_fail() {
         -94.61793793643038,  -18.64216213611094,   88.32376703241675,  -99.30169870309795,
          90.62661897246733,   96.74200696130146,    34.7421322611369,   84.86773307198098);
 
-    let (vecs, vals) = m.clone().real_schur().unpack();
-    println!("{:.6}{:.6}", m, &vecs * &vals * vecs.transpose());
+    let (vecs, vals) = m.clone().schur().unpack();
     assert!(relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7))
 }
 
@@ -88,8 +102,7 @@ fn schur_static_mat4_fail2() {
         27.932377940728202, 82.94220150938, -35.5898884705951, 67.56447552434219,
         55.66754906908682, -42.14328890569226, -20.684709585152206, -87.9456949841046);
 
-    let (vecs, vals) = m.clone().real_schur().unpack();
-    println!("{:.6}{:.6}", m, &vecs * &vals * vecs.transpose());
+    let (vecs, vals) = m.clone().schur().unpack();
     assert!(relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7))
 }
 
@@ -100,8 +113,7 @@ fn schur_static_mat3_fail() {
         -7.525423104386547, -17.827350599642287,  11.297377444555849,
         38.080736654870464,  -84.27428302131528,  -95.88198590331922);
 
-    let (vecs, vals) = m.clone().real_schur().unpack();
-    println!("{:.6}{:.6}", m, &vecs * &vals * vecs.transpose());
+    let (vecs, vals) = m.clone().schur().unpack();
     assert!(relative_eq!(vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7))
 }
 
@@ -134,7 +146,6 @@ fn schur_singular() {
         0.0,  0.0,  0.0,  0.0,  0.0, -4.0,  0.0,  0.0,  0.0,  4.0,  0.0,  0.0,  0.0, -4.0,  0.0,  0.0,  0.0,  0.0,  4.0,  0.0,  0.0,  0.0,  0.0,  0.0,
         0.0,  0.0,  0.0,  0.0,  0.0,  0.0,  0.0,  0.0,  0.0,  4.0,  0.0,  0.0,  0.0, -4.0,  0.0,  0.0,  0.0,  0.0,  4.0,  0.0,  0.0,  0.0,  0.0,  0.0]);
 
-    let (vecs, vals) = m.clone().real_schur().unpack();
-    println!("{:.6}{:.6}", m, &vecs * &vals * vecs.transpose());
+    let (vecs, vals) = m.clone().schur().unpack();
     assert!(relative_eq!(&vecs * vals * vecs.transpose(), m, epsilon = 1.0e-7))
 }
diff --git a/tests/linalg/solve.rs b/tests/linalg/solve.rs
index 76dc05b51..e917cfc54 100644
--- a/tests/linalg/solve.rs
+++ b/tests/linalg/solve.rs
@@ -1,57 +1,65 @@
 #![cfg(feature = "arbitrary")]
 
-use na::{Matrix4, Matrix4x5};
 
-fn unzero_diagonal(a: &mut Matrix4<f64>) {
-    for i in 0..4 {
-        if a[(i, i)] < 1.0e-7 {
-            a[(i, i)] = 1.0;
-        }
-    }
-}
+macro_rules! gen_tests(
+    ($module: ident, $scalar: ty) => {
+        mod $module {
+            use na::{Matrix4, Matrix4x5, ComplexField};
+            #[allow(unused_imports)]
+            use crate::core::helper::{RandScalar, RandComplex};
 
-quickcheck! {
-    fn solve_lower_triangular(a: Matrix4<f64>, b: Matrix4x5<f64>) -> bool {
-        let mut a = a;
-        unzero_diagonal(&mut a);
-        let tri = a.lower_triangle();
-        let x   = a.solve_lower_triangular(&b).unwrap();
+            fn unzero_diagonal<N: ComplexField>(a: &mut Matrix4<N>) {
+                for i in 0..4 {
+                    if a[(i, i)].norm1() < na::convert(1.0e-7) {
+                        a[(i, i)] = N::one();
+                    }
+                }
+            }
 
-        println!("{}\n{}\n{}\n{}", tri, x, tri * x, b);
+            quickcheck! {
+                fn solve_lower_triangular(a: Matrix4<$scalar>, b: Matrix4x5<$scalar>) -> bool {
+                    let b = b.map(|e| e.0);
+                    let mut a = a.map(|e| e.0);
+                    unzero_diagonal(&mut a);
+                    let tri = a.lower_triangle();
+                    let x   = a.solve_lower_triangular(&b).unwrap();
 
-        relative_eq!(tri * x, b, epsilon = 1.0e-7)
-    }
+                    relative_eq!(tri * x, b, epsilon = 1.0e-7)
+                }
 
-    fn solve_upper_triangular(a: Matrix4<f64>, b: Matrix4x5<f64>) -> bool {
-        let mut a = a;
-        unzero_diagonal(&mut a);
-        let tri = a.upper_triangle();
-        let x   = a.solve_upper_triangular(&b).unwrap();
+                fn solve_upper_triangular(a: Matrix4<$scalar>, b: Matrix4x5<$scalar>) -> bool {
+                    let b = b.map(|e| e.0);
+                    let mut a = a.map(|e| e.0);
+                    unzero_diagonal(&mut a);
+                    let tri = a.upper_triangle();
+                    let x   = a.solve_upper_triangular(&b).unwrap();
 
-        println!("{}\n{}\n{}\n{}", tri, x, tri * x, b);
+                    relative_eq!(tri * x, b, epsilon = 1.0e-7)
+                }
 
-        relative_eq!(tri * x, b, epsilon = 1.0e-7)
-    }
+                fn tr_solve_lower_triangular(a: Matrix4<$scalar>, b: Matrix4x5<$scalar>) -> bool {
+                    let b = b.map(|e| e.0);
+                    let mut a = a.map(|e| e.0);
+                    unzero_diagonal(&mut a);
+                    let tri = a.lower_triangle();
+                    let x   = a.tr_solve_lower_triangular(&b).unwrap();
 
-    fn tr_solve_lower_triangular(a: Matrix4<f64>, b: Matrix4x5<f64>) -> bool {
-        let mut a = a;
-        unzero_diagonal(&mut a);
-        let tri = a.lower_triangle();
-        let x   = a.tr_solve_lower_triangular(&b).unwrap();
+                    relative_eq!(tri.transpose() * x, b, epsilon = 1.0e-7)
+                }
 
-        println!("{}\n{}\n{}\n{}", tri, x, tri * x, b);
+                fn tr_solve_upper_triangular(a: Matrix4<$scalar>, b: Matrix4x5<$scalar>) -> bool {
+                    let b = b.map(|e| e.0);
+                    let mut a = a.map(|e| e.0);
+                    unzero_diagonal(&mut a);
+                    let tri = a.upper_triangle();
+                    let x   = a.tr_solve_upper_triangular(&b).unwrap();
 
-        relative_eq!(tri.transpose() * x, b, epsilon = 1.0e-7)
+                    relative_eq!(tri.transpose() * x, b, epsilon = 1.0e-7)
+                }
+            }
+        }
     }
+);
 
-    fn tr_solve_upper_triangular(a: Matrix4<f64>, b: Matrix4x5<f64>) -> bool {
-        let mut a = a;
-        unzero_diagonal(&mut a);
-        let tri = a.upper_triangle();
-        let x   = a.tr_solve_upper_triangular(&b).unwrap();
-
-        println!("{}\n{}\n{}\n{}", tri, x, tri * x, b);
-
-        relative_eq!(tri.transpose() * x, b, epsilon = 1.0e-7)
-    }
-}
+gen_tests!(complex, RandComplex<f64>);
+gen_tests!(f64, RandScalar<f64>);
diff --git a/tests/linalg/svd.rs b/tests/linalg/svd.rs
index e84108ed0..ca7bab4c5 100644
--- a/tests/linalg/svd.rs
+++ b/tests/linalg/svd.rs
@@ -3,146 +3,164 @@ use na::{DMatrix, Matrix6};
 
 #[cfg(feature = "arbitrary")]
 mod quickcheck_tests {
-    use na::{
-        DMatrix, DVector, Matrix2, Matrix2x5, Matrix3, Matrix3x5, Matrix4, Matrix5x2, Matrix5x3,
-    };
-    use std::cmp;
-
-    quickcheck! {
-        fn svd(m: DMatrix<f64>) -> bool {
-            if m.len() > 0 {
-                let svd = m.clone().svd(true, true);
-                let recomp_m = svd.clone().recompose().unwrap();
-                let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
-                let ds = DMatrix::from_diagonal(&s);
-
-                println!("{}{}", &m, &u * &ds * &v_t);
-
-                s.iter().all(|e| *e >= 0.0) &&
-                relative_eq!(&u * ds * &v_t, recomp_m, epsilon = 1.0e-5) &&
-                relative_eq!(m, recomp_m, epsilon = 1.0e-5)
-            }
-            else {
-                true
-            }
-        }
-
-        fn svd_static_5_3(m: Matrix5x3<f64>) -> bool {
-            let svd = m.svd(true, true);
-            let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
-            let ds = Matrix3::from_diagonal(&s);
-
-            s.iter().all(|e| *e >= 0.0) &&
-            relative_eq!(m, &u * ds * &v_t, epsilon = 1.0e-5) &&
-            u.is_orthogonal(1.0e-5) &&
-            v_t.is_orthogonal(1.0e-5)
-        }
-
-        fn svd_static_5_2(m: Matrix5x2<f64>) -> bool {
-            let svd = m.svd(true, true);
-            let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
-            let ds = Matrix2::from_diagonal(&s);
-
-            s.iter().all(|e| *e >= 0.0) &&
-            relative_eq!(m, &u * ds * &v_t, epsilon = 1.0e-5) &&
-            u.is_orthogonal(1.0e-5) &&
-            v_t.is_orthogonal(1.0e-5)
-        }
-
-        fn svd_static_3_5(m: Matrix3x5<f64>) -> bool {
-            let svd = m.svd(true, true);
-            let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
-
-            let ds = Matrix3::from_diagonal(&s);
-
-            s.iter().all(|e| *e >= 0.0) &&
-            relative_eq!(m, u * ds * v_t, epsilon = 1.0e-5)
-        }
-
-        fn svd_static_2_5(m: Matrix2x5<f64>) -> bool {
-            let svd = m.svd(true, true);
-            let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
-            let ds = Matrix2::from_diagonal(&s);
-
-            s.iter().all(|e| *e >= 0.0) &&
-            relative_eq!(m, u * ds * v_t, epsilon = 1.0e-5)
-        }
-
-        fn svd_static_square(m: Matrix4<f64>) -> bool {
-            let svd = m.svd(true, true);
-            let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
-            let ds = Matrix4::from_diagonal(&s);
-
-            s.iter().all(|e| *e >= 0.0) &&
-            relative_eq!(m, u * ds * v_t, epsilon = 1.0e-5) &&
-            u.is_orthogonal(1.0e-5) &&
-            v_t.is_orthogonal(1.0e-5)
-        }
-
-        fn svd_static_square_2x2(m: Matrix2<f64>) -> bool {
-            let svd = m.svd(true, true);
-            let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
-            let ds = Matrix2::from_diagonal(&s);
-
-            s.iter().all(|e| *e >= 0.0) &&
-            relative_eq!(m, u * ds * v_t, epsilon = 1.0e-5) &&
-            u.is_orthogonal(1.0e-5) &&
-            v_t.is_orthogonal(1.0e-5)
-        }
-
-        fn svd_pseudo_inverse(m: DMatrix<f64>) -> bool {
-            if m.len() > 0 {
-                let svd = m.clone().svd(true, true);
-                let pinv = svd.pseudo_inverse(1.0e-10).unwrap();
-
-                if m.nrows() > m.ncols() {
-                    println!("{}", &pinv * &m);
-                    (pinv * m).is_identity(1.0e-5)
-                }
-                else {
-                    println!("{}", &m * &pinv);
-                    (m * pinv).is_identity(1.0e-5)
+    macro_rules! gen_tests(
+        ($module: ident, $scalar: ty) => {
+            mod $module {
+                use na::{
+                    DMatrix, DVector, Matrix2, Matrix2x5, Matrix3, Matrix3x5, Matrix4, Matrix5x2, Matrix5x3,
+                    ComplexField
+                };
+                use std::cmp;
+                #[allow(unused_imports)]
+                use crate::core::helper::{RandScalar, RandComplex};
+
+                quickcheck! {
+                    fn svd(m: DMatrix<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        if m.len() > 0 {
+                            let svd = m.clone().svd(true, true);
+                            let recomp_m = svd.clone().recompose().unwrap();
+                            let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
+                            let ds = DMatrix::from_diagonal(&s.map(|e| ComplexField::from_real(e)));
+
+                            s.iter().all(|e| *e >= 0.0) &&
+                            relative_eq!(&u * ds * &v_t, recomp_m, epsilon = 1.0e-5) &&
+                            relative_eq!(m, recomp_m, epsilon = 1.0e-5)
+                        }
+                        else {
+                            true
+                        }
+                    }
+
+                    fn svd_static_5_3(m: Matrix5x3<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let svd = m.svd(true, true);
+                        let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
+                        let ds = Matrix3::from_diagonal(&s.map(|e| ComplexField::from_real(e)));
+
+                        s.iter().all(|e| *e >= 0.0) &&
+                        relative_eq!(m, &u * ds * &v_t, epsilon = 1.0e-5) &&
+                        u.is_orthogonal(1.0e-5) &&
+                        v_t.is_orthogonal(1.0e-5)
+                    }
+
+                    fn svd_static_5_2(m: Matrix5x2<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let svd = m.svd(true, true);
+                        let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
+                        let ds = Matrix2::from_diagonal(&s.map(|e| ComplexField::from_real(e)));
+
+                        s.iter().all(|e| *e >= 0.0) &&
+                        relative_eq!(m, &u * ds * &v_t, epsilon = 1.0e-5) &&
+                        u.is_orthogonal(1.0e-5) &&
+                        v_t.is_orthogonal(1.0e-5)
+                    }
+
+                    fn svd_static_3_5(m: Matrix3x5<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let svd = m.svd(true, true);
+                        let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
+
+                        let ds = Matrix3::from_diagonal(&s.map(|e| ComplexField::from_real(e)));
+
+                        s.iter().all(|e| *e >= 0.0) &&
+                        relative_eq!(m, u * ds * v_t, epsilon = 1.0e-5)
+                    }
+
+                    fn svd_static_2_5(m: Matrix2x5<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let svd = m.svd(true, true);
+                        let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
+                        let ds = Matrix2::from_diagonal(&s.map(|e| ComplexField::from_real(e)));
+
+                        s.iter().all(|e| *e >= 0.0) &&
+                        relative_eq!(m, u * ds * v_t, epsilon = 1.0e-5)
+                    }
+
+                    fn svd_static_square(m: Matrix4<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let svd = m.svd(true, true);
+                        let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
+                        let ds = Matrix4::from_diagonal(&s.map(|e| ComplexField::from_real(e)));
+
+                        s.iter().all(|e| *e >= 0.0) &&
+                        relative_eq!(m, u * ds * v_t, epsilon = 1.0e-5) &&
+                        u.is_orthogonal(1.0e-5) &&
+                        v_t.is_orthogonal(1.0e-5)
+                    }
+
+                    fn svd_static_square_2x2(m: Matrix2<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+                        let svd = m.svd(true, true);
+                        let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
+                        let ds = Matrix2::from_diagonal(&s.map(|e| ComplexField::from_real(e)));
+
+                        s.iter().all(|e| *e >= 0.0) &&
+                        relative_eq!(m, u * ds * v_t, epsilon = 1.0e-5) &&
+                        u.is_orthogonal(1.0e-5) &&
+                        v_t.is_orthogonal(1.0e-5)
+                    }
+
+                    fn svd_pseudo_inverse(m: DMatrix<$scalar>) -> bool {
+                        let m = m.map(|e| e.0);
+
+                        if m.len() > 0 {
+                            let svd = m.clone().svd(true, true);
+                            let pinv = svd.pseudo_inverse(1.0e-10).unwrap();
+
+                            if m.nrows() > m.ncols() {
+                                (pinv * m).is_identity(1.0e-5)
+                            }
+                            else {
+                                (m * pinv).is_identity(1.0e-5)
+                            }
+                        }
+                        else {
+                            true
+                        }
+                    }
+
+                    fn svd_solve(n: usize, nb: usize) -> bool {
+                        let n = cmp::max(1, cmp::min(n, 10));
+                        let nb = cmp::min(nb, 10);
+                        let m  = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0);
+
+                        let svd = m.clone().svd(true, true);
+
+                        if svd.rank(1.0e-7) == n {
+                            let b1 = DVector::<$scalar>::new_random(n).map(|e| e.0);
+                            let b2 = DMatrix::<$scalar>::new_random(n, nb).map(|e| e.0);
+
+                            let sol1 = svd.solve(&b1, 1.0e-7).unwrap();
+                            let sol2 = svd.solve(&b2, 1.0e-7).unwrap();
+
+                            let recomp = svd.recompose().unwrap();
+                            if !relative_eq!(m, recomp, epsilon = 1.0e-6) {
+                                println!("{}{}", m, recomp);
+                            }
+
+                            if !relative_eq!(&m * &sol1, b1, epsilon = 1.0e-6) {
+                                println!("Problem 1: {:.6}{:.6}", b1, &m * sol1);
+                                return false;
+                            }
+                            if !relative_eq!(&m * &sol2, b2, epsilon = 1.0e-6) {
+                                println!("Problem 2: {:.6}{:.6}", b2, &m * sol2);
+                                return false;
+                            }
+                        }
+
+                        true
+                    }
                 }
             }
-            else {
-                true
-            }
         }
+    );
 
-        fn svd_solve(n: usize, nb: usize) -> bool {
-            let n = cmp::max(1, cmp::min(n, 10));
-            let nb = cmp::min(nb, 10);
-            let m  = DMatrix::<f64>::new_random(n, n);
-
-            let svd = m.clone().svd(true, true);
-
-            if svd.rank(1.0e-7) == n {
-                let b1 = DVector::new_random(n);
-                let b2 = DMatrix::new_random(n, nb);
-
-                let sol1 = svd.solve(&b1, 1.0e-7).unwrap();
-                let sol2 = svd.solve(&b2, 1.0e-7).unwrap();
-
-                let recomp = svd.recompose().unwrap();
-                if !relative_eq!(m, recomp, epsilon = 1.0e-6) {
-                    println!("{}{}", m, recomp);
-                }
-
-                if !relative_eq!(&m * &sol1, b1, epsilon = 1.0e-6) {
-                    println!("Problem 1: {:.6}{:.6}", b1, &m * sol1);
-                    return false;
-                }
-                if !relative_eq!(&m * &sol2, b2, epsilon = 1.0e-6) {
-                    println!("Problem 2: {:.6}{:.6}", b2, &m * sol2);
-                    return false;
-                }
-            }
-
-            true
-        }
-    }
+    gen_tests!(complex, RandComplex<f64>);
+    gen_tests!(f64, RandScalar<f64>);
 }
 
+
 // Test proposed on the issue #176 of rulinalg.
 #[test]
 fn svd_singular() {
@@ -176,12 +194,10 @@ fn svd_singular() {
     let (u, s, v_t) = (svd.u.unwrap(), svd.singular_values, svd.v_t.unwrap());
     let ds = DMatrix::from_diagonal(&s);
 
-    println!("{:.5}", &u * &ds * &v_t);
-
     assert!(s.iter().all(|e| *e >= 0.0));
     assert!(u.is_orthogonal(1.0e-5));
     assert!(v_t.is_orthogonal(1.0e-5));
-    assert!(relative_eq!(m, &u * ds * &v_t, epsilon = 1.0e-5));
+    assert_relative_eq!(m, &u * ds * &v_t, epsilon = 1.0e-5);
 }
 
 // Same as the previous test but with one additional row.
@@ -220,7 +236,7 @@ fn svd_singular_vertical() {
     let ds = DMatrix::from_diagonal(&s);
 
     assert!(s.iter().all(|e| *e >= 0.0));
-    assert!(relative_eq!(m, &u * ds * &v_t, epsilon = 1.0e-5));
+    assert_relative_eq!(m, &u * ds * &v_t, epsilon = 1.0e-5);
 }
 
 // Same as the previous test but with one additional column.
@@ -257,7 +273,7 @@ fn svd_singular_horizontal() {
     let ds = DMatrix::from_diagonal(&s);
 
     assert!(s.iter().all(|e| *e >= 0.0));
-    assert!(relative_eq!(m, &u * ds * &v_t, epsilon = 1.0e-5));
+    assert_relative_eq!(m, &u * ds * &v_t, epsilon = 1.0e-5);
 }
 
 #[test]
@@ -296,7 +312,7 @@ fn svd_with_delimited_subproblem() {
     m[(8,8)] = 16.0; m[(3,9)] = 17.0;
     m[(9,9)] = 18.0;
     let svd = m.clone().svd(true, true);
-    assert!(relative_eq!(m, svd.recompose().unwrap(), epsilon = 1.0e-7));
+    assert_relative_eq!(m, svd.recompose().unwrap(), epsilon = 1.0e-7);
 
     // Rectangular versions.
     let mut m = DMatrix::<f64>::from_element(15, 10, 0.0);
@@ -311,10 +327,10 @@ fn svd_with_delimited_subproblem() {
     m[(8,8)] = 16.0; m[(3,9)] = 17.0;
     m[(9,9)] = 18.0;
     let svd = m.clone().svd(true, true);
-    assert!(relative_eq!(m, svd.recompose().unwrap(), epsilon = 1.0e-7));
+    assert_relative_eq!(m, svd.recompose().unwrap(), epsilon = 1.0e-7);
 
     let svd = m.transpose().svd(true, true);
-    assert!(relative_eq!(m.transpose(), svd.recompose().unwrap(), epsilon = 1.0e-7));
+    assert_relative_eq!(m.transpose(), svd.recompose().unwrap(), epsilon = 1.0e-7);
 }
 
 #[test]
@@ -327,12 +343,8 @@ fn svd_fail() {
         0.12293810556077789,   0.6617084679545999,   0.9002240700227326, 0.027153062135304884,   0.3630189466989524,  0.18207502727558866,
         0.843196731466686,  0.08951878746549924,   0.7533450877576973, 0.009558876499740077,   0.9429679490873482,   0.9355764454129878);
     let svd = m.clone().svd(true, true);
-    println!("Singular values: {}", svd.singular_values);
-    println!("u: {:.5}", svd.u.unwrap());
-    println!("v: {:.5}", svd.v_t.unwrap());
     let recomp = svd.recompose().unwrap();
-    println!("{:.5}{:.5}", m, recomp);
-    assert!(relative_eq!(m, recomp, epsilon = 1.0e-5));
+    assert_relative_eq!(m, recomp, epsilon = 1.0e-5);
 }
 
 #[test]
@@ -341,4 +353,4 @@ fn svd_err() {
     let svd = m.clone().svd(false, false);
     assert_eq!(Err("SVD recomposition: U and V^t have not been computed."), svd.clone().recompose());
     assert_eq!(Err("SVD pseudo inverse: the epsilon must be non-negative."), svd.clone().pseudo_inverse(-1.0));
-}
+}
\ No newline at end of file
diff --git a/tests/linalg/tridiagonal.rs b/tests/linalg/tridiagonal.rs
index 6db86aefb..5d04587e0 100644
--- a/tests/linalg/tridiagonal.rs
+++ b/tests/linalg/tridiagonal.rs
@@ -1,35 +1,56 @@
 #![cfg(feature = "arbitrary")]
 
-use std::cmp;
 
-use na::{DMatrix, Matrix2, Matrix4};
-
-quickcheck! {
-    fn symm_tridiagonal(n: usize) -> bool {
-        let n = cmp::max(1, cmp::min(n, 50));
-        let m = DMatrix::<f64>::new_random(n, n);
-        let tri = m.clone().symmetric_tridiagonalize();
-        let recomp = tri.recompose();
-
-        println!("{}{}", m.lower_triangle(), recomp.lower_triangle());
-
-        relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-7)
-    }
-
-    fn symm_tridiagonal_static_square(m: Matrix4<f64>) -> bool {
-        let tri = m.symmetric_tridiagonalize();
-        println!("{}{}", tri.internal_tri(), tri.off_diagonal());
-        let recomp = tri.recompose();
-
-        println!("{}{}", m.lower_triangle(), recomp.lower_triangle());
-
-        relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-7)
+macro_rules! gen_tests(
+    ($module: ident, $scalar: ty) => {
+            mod $module {
+            use std::cmp;
+
+            use na::{DMatrix, Matrix2, Matrix4};
+            #[allow(unused_imports)]
+            use crate::core::helper::{RandScalar, RandComplex};
+
+            quickcheck! {
+                fn symm_tridiagonal(n: usize) -> bool {
+                    let n = cmp::max(1, cmp::min(n, 50));
+                    let m = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0).hermitian_part();
+                    let tri = m.clone().symmetric_tridiagonalize();
+                    let recomp = tri.recompose();
+
+                    relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-7)
+                }
+
+                fn symm_tridiagonal_singular(n: usize) -> bool {
+                    let n = cmp::max(1, cmp::min(n, 4));
+                    let mut m = DMatrix::<$scalar>::new_random(n, n).map(|e| e.0).hermitian_part();
+                    m.row_mut(n / 2).fill(na::zero());
+                    m.column_mut(n / 2).fill(na::zero());
+                    let tri = m.clone().symmetric_tridiagonalize();
+                    let recomp = tri.recompose();
+
+                    relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-7)
+                }
+
+                fn symm_tridiagonal_static_square(m: Matrix4<$scalar>) -> bool {
+                    let m = m.map(|e| e.0).hermitian_part();
+                    let tri = m.symmetric_tridiagonalize();
+                    let recomp = tri.recompose();
+
+                    relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-7)
+                }
+
+                fn symm_tridiagonal_static_square_2x2(m: Matrix2<$scalar>) -> bool {
+                    let m = m.map(|e| e.0).hermitian_part();
+                    let tri = m.symmetric_tridiagonalize();
+                    let recomp = tri.recompose();
+
+                    relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-7)
+                }
+            }
+        }
     }
+);
 
-    fn symm_tridiagonal_static_square_2x2(m: Matrix2<f64>) -> bool {
-        let tri = m.symmetric_tridiagonalize();
-        let recomp = tri.recompose();
 
-        relative_eq!(m.lower_triangle(), recomp.lower_triangle(), epsilon = 1.0e-7)
-    }
-}
+gen_tests!(complex, RandComplex<f64>);
+gen_tests!(f64, RandScalar<f64>);
diff --git a/tests/sparse/cs_cholesky.rs b/tests/sparse/cs_cholesky.rs
index 72a9a08fa..314e34f6e 100644
--- a/tests/sparse/cs_cholesky.rs
+++ b/tests/sparse/cs_cholesky.rs
@@ -35,12 +35,12 @@ fn cs_cholesky() {
         1.0, 1.0, 0.0, 0.0, 2.0
     );
     a.fill_upper_triangle_with_lower_triangle();
-    // Test ::new, left_looking, and up_looking implementations.
+    // Test crate::new, left_looking, and up_looking implementations.
     test_cholesky(a);
 }
 
 fn test_cholesky(a: Matrix5<f32>) {
-    // Test ::new
+    // Test crate::new
     test_cholesky_variant(a, 0);
     // Test up-looking
     test_cholesky_variant(a, 1);