diff --git a/nalgebra-lapack/Cargo.toml b/nalgebra-lapack/Cargo.toml
index 95153a2cc..ef9bea2b7 100644
--- a/nalgebra-lapack/Cargo.toml
+++ b/nalgebra-lapack/Cargo.toml
@@ -1,15 +1,15 @@
 [package]
-name    = "nalgebra-lapack"
+name = "nalgebra-lapack"
 version = "0.24.0"
-authors = [ "Sébastien Crozet <developer@crozet.re>", "Andrew Straw <strawman@astraw.com>" ]
+authors = ["Sébastien Crozet <developer@crozet.re>", "Andrew Straw <strawman@astraw.com>"]
 
-description   = "Matrix decompositions using nalgebra matrices and Lapack bindings."
+description = "Matrix decompositions using nalgebra matrices and Lapack bindings."
 documentation = "https://www.nalgebra.org/docs"
 homepage = "https://nalgebra.org"
 repository = "https://github.com/dimforge/nalgebra"
 readme = "../README.md"
-categories = [ "science", "mathematics" ]
-keywords = [ "linear", "algebra", "matrix", "vector", "lapack" ]
+categories = ["science", "mathematics"]
+keywords = ["linear", "algebra", "matrix", "vector", "lapack"]
 license = "MIT"
 edition = "2018"
 
@@ -17,31 +17,31 @@ edition = "2018"
 maintenance = { status = "actively-developed" }
 
 [features]
-serde-serialize  = [ "serde", "nalgebra/serde-serialize" ]
-proptest-support = [ "nalgebra/proptest-support" ]
-arbitrary        = [ "nalgebra/arbitrary" ]
+serde-serialize = ["serde", "nalgebra/serde-serialize"]
+proptest-support = ["nalgebra/proptest-support"]
+arbitrary = ["nalgebra/arbitrary"]
 
 # For BLAS/LAPACK
-default    = ["netlib"]
-openblas   = ["lapack-src/openblas"]
-netlib     = ["lapack-src/netlib"]
+default = ["openblas"]
+openblas = ["lapack-src/openblas"]
+netlib = ["lapack-src/netlib"]
 accelerate = ["lapack-src/accelerate"]
-intel-mkl  = ["lapack-src/intel-mkl"]
+intel-mkl = ["lapack-src/intel-mkl"]
 
 [dependencies]
-nalgebra      = { version = "0.32", path = ".." }
-num-traits    = "0.2"
-num-complex   = { version = "0.4", default-features = false }
-simba         = "0.8"
-serde         = { version = "1.0", features = [ "derive" ], optional = true }
-lapack        = { version = "0.19", default-features = false }
-lapack-src    = { version = "0.8", default-features = false }
+nalgebra = { version = "0.32", path = ".." }
+num-traits = "0.2"
+num-complex = { version = "0.4", default-features = false }
+simba = "0.8"
+serde = { version = "1.0", features = ["derive"], optional = true }
+lapack = { version = "0.19", default-features = false }
+lapack-src = { version = "0.8", default-features = false }
 # clippy = "*"
 
 [dev-dependencies]
-nalgebra   = { version = "0.32", features = [ "arbitrary", "rand" ], path = ".." }
-proptest   = { version = "1", default-features = false, features = ["std"] }
+nalgebra = { version = "0.32", features = ["arbitrary", "rand"], path = ".." }
+proptest = { version = "1", default-features = false, features = ["std"] }
 quickcheck = "1"
-approx     = "0.5"
-rand       = "0.8"
+approx = "0.5"
+rand = "0.8"
 
diff --git a/nalgebra-lapack/src/eigen.rs b/nalgebra-lapack/src/eigen.rs
index ceb405551..6ccf8804e 100644
--- a/nalgebra-lapack/src/eigen.rs
+++ b/nalgebra-lapack/src/eigen.rs
@@ -230,7 +230,7 @@ where
         Option<Vec<OVector<Complex<T>, D>>>,
     )
     where
-        DefaultAllocator: Allocator<Complex<T>, D>,
+        DefaultAllocator: Allocator<D>,
     {
         match self.eigenvalues_are_real() {
             true => (None, None, None),
diff --git a/nalgebra-lapack/src/generalized_eigenvalues.rs b/nalgebra-lapack/src/generalized_eigenvalues.rs
index 94a87c234..33312868f 100644
--- a/nalgebra-lapack/src/generalized_eigenvalues.rs
+++ b/nalgebra-lapack/src/generalized_eigenvalues.rs
@@ -158,8 +158,7 @@ where
     /// as columns.
     pub fn eigenvectors(&self) -> (OMatrix<Complex<T>, D, D>, OMatrix<Complex<T>, D, D>)
     where
-        DefaultAllocator:
-            Allocator<Complex<T>, D, D> + Allocator<Complex<T>, D> + Allocator<(Complex<T>, T), D>,
+        DefaultAllocator: Allocator<D, D> + Allocator<D>,
     {
         /*
          How the eigenvectors are built up:
@@ -226,7 +225,7 @@ where
     #[must_use]
     pub fn raw_eigenvalues(&self) -> OVector<(Complex<T>, T), D>
     where
-        DefaultAllocator: Allocator<(Complex<T>, T), D>,
+        DefaultAllocator: Allocator<D>,
     {
         let mut out = Matrix::from_element_generic(
             self.vsl.shape_generic().0,
diff --git a/nalgebra-lapack/src/lu.rs b/nalgebra-lapack/src/lu.rs
index e2d6ac00c..f38e675ca 100644
--- a/nalgebra-lapack/src/lu.rs
+++ b/nalgebra-lapack/src/lu.rs
@@ -21,21 +21,21 @@ use lapack;
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(serialize = "DefaultAllocator: Allocator<R, C> +
-                           Allocator<i32, DimMinimum<R, C>>,
+                           Allocator<DimMinimum<R, C>>,
          OMatrix<T, R, C>: Serialize,
          PermutationSequence<DimMinimum<R, C>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(bound(deserialize = "DefaultAllocator: Allocator<R, C> +
-                           Allocator<i32, DimMinimum<R, C>>,
+                           Allocator<DimMinimum<R, C>>,
          OMatrix<T, R, C>: Deserialize<'de>,
          PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
 pub struct LU<T: Scalar, R: DimMin<C>, C: Dim>
 where
-    DefaultAllocator: Allocator<i32, DimMinimum<R, C>> + Allocator<R, C>,
+    DefaultAllocator: Allocator<DimMinimum<R, C>> + Allocator<R, C>,
 {
     lu: OMatrix<T, R, C>,
     p: OVector<i32, DimMinimum<R, C>>,
@@ -43,7 +43,7 @@ where
 
 impl<T: Scalar + Copy, R: DimMin<C>, C: Dim> Copy for LU<T, R, C>
 where
-    DefaultAllocator: Allocator<R, C> + Allocator<i32, DimMinimum<R, C>>,
+    DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>>,
     OMatrix<T, R, C>: Copy,
     OVector<i32, DimMinimum<R, C>>: Copy,
 {
@@ -57,7 +57,7 @@ where
         + Allocator<R, R>
         + Allocator<R, DimMinimum<R, C>>
         + Allocator<DimMinimum<R, C>, C>
-        + Allocator<i32, DimMinimum<R, C>>,
+        + Allocator<DimMinimum<R, C>>,
 {
     /// Computes the LU decomposition with partial (row) pivoting of `matrix`.
     pub fn new(mut m: OMatrix<T, R, C>) -> Self {
@@ -153,7 +153,7 @@ where
 
     fn generic_solve_mut<R2: Dim, C2: Dim>(&self, trans: u8, b: &mut OMatrix<T, R2, C2>) -> bool
     where
-        DefaultAllocator: Allocator<R2, C2> + Allocator<i32, R2>,
+        DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
     {
         let dim = self.lu.nrows();
 
@@ -192,7 +192,7 @@ where
     ) -> Option<OMatrix<T, R2, C2>>
     where
         S2: Storage<T, R2, C2>,
-        DefaultAllocator: Allocator<R2, C2> + Allocator<i32, R2>,
+        DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
     {
         let mut res = b.clone_owned();
         if self.generic_solve_mut(b'T', &mut res) {
@@ -210,7 +210,7 @@ where
     ) -> Option<OMatrix<T, R2, C2>>
     where
         S2: Storage<T, R2, C2>,
-        DefaultAllocator: Allocator<R2, C2> + Allocator<i32, R2>,
+        DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
     {
         let mut res = b.clone_owned();
         if self.generic_solve_mut(b'T', &mut res) {
@@ -228,7 +228,7 @@ where
     ) -> Option<OMatrix<T, R2, C2>>
     where
         S2: Storage<T, R2, C2>,
-        DefaultAllocator: Allocator<R2, C2> + Allocator<i32, R2>,
+        DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
     {
         let mut res = b.clone_owned();
         if self.generic_solve_mut(b'T', &mut res) {
@@ -243,7 +243,7 @@ where
     /// Returns `false` if no solution was found (the decomposed matrix is singular).
     pub fn solve_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
     where
-        DefaultAllocator: Allocator<R2, C2> + Allocator<i32, R2>,
+        DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
     {
         self.generic_solve_mut(b'T', b)
     }
@@ -254,7 +254,7 @@ where
     /// Returns `false` if no solution was found (the decomposed matrix is singular).
     pub fn solve_transpose_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
     where
-        DefaultAllocator: Allocator<R2, C2> + Allocator<i32, R2>,
+        DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
     {
         self.generic_solve_mut(b'T', b)
     }
@@ -265,7 +265,7 @@ where
     /// Returns `false` if no solution was found (the decomposed matrix is singular).
     pub fn solve_adjoint_mut<R2: Dim, C2: Dim>(&self, b: &mut OMatrix<T, R2, C2>) -> bool
     where
-        DefaultAllocator: Allocator<R2, C2> + Allocator<i32, R2>,
+        DefaultAllocator: Allocator<R2, C2> + Allocator<R2>,
     {
         self.generic_solve_mut(b'T', b)
     }
@@ -275,7 +275,7 @@ impl<T: LUScalar, D: Dim> LU<T, D, D>
 where
     T: Zero + One,
     D: DimMin<D, Output = D>,
-    DefaultAllocator: Allocator<D, D> + Allocator<i32, D>,
+    DefaultAllocator: Allocator<D, D> + Allocator<D>,
 {
     /// Computes the inverse of the decomposed matrix.
     pub fn inverse(mut self) -> Option<OMatrix<T, D, D>> {
diff --git a/nalgebra-lapack/src/qz.rs b/nalgebra-lapack/src/qz.rs
index 950fc3aa2..ec113e970 100644
--- a/nalgebra-lapack/src/qz.rs
+++ b/nalgebra-lapack/src/qz.rs
@@ -178,7 +178,7 @@ where
     #[must_use]
     pub fn raw_eigenvalues(&self) -> OVector<(Complex<T>, T), D>
     where
-        DefaultAllocator: Allocator<(Complex<T>, T), D>,
+        DefaultAllocator: Allocator<D>,
     {
         let mut out = Matrix::from_element_generic(
             self.vsl.shape_generic().0,
diff --git a/nalgebra-lapack/src/schur.rs b/nalgebra-lapack/src/schur.rs
index c921694c8..1cc486f9b 100644
--- a/nalgebra-lapack/src/schur.rs
+++ b/nalgebra-lapack/src/schur.rs
@@ -146,7 +146,7 @@ where
     #[must_use]
     pub fn complex_eigenvalues(&self) -> OVector<Complex<T>, D>
     where
-        DefaultAllocator: Allocator<Complex<T>, D>,
+        DefaultAllocator: Allocator<D>,
     {
         let mut out = Matrix::zeros_generic(self.t.shape_generic().0, Const::<1>);
 
diff --git a/nalgebra-lapack/src/svd.rs b/nalgebra-lapack/src/svd.rs
index a4e37d322..1d2f2e248 100644
--- a/nalgebra-lapack/src/svd.rs
+++ b/nalgebra-lapack/src/svd.rs
@@ -56,10 +56,8 @@ where
 /// supported by the Singular Value Decompotition.
 pub trait SVDScalar<R: DimMin<C>, C: Dim>: Scalar
 where
-    DefaultAllocator: Allocator<Self, R, R>
-        + Allocator<Self, R, C>
-        + Allocator<Self, DimMinimum<R, C>>
-        + Allocator<Self, C, C>,
+    DefaultAllocator:
+        Allocator<R, R> + Allocator<R, C> + Allocator<DimMinimum<R, C>> + Allocator<C, C>,
 {
     /// Computes the SVD decomposition of `m`.
     fn compute(m: OMatrix<Self, R, C>) -> Option<SVD<Self, R, C>>;
@@ -80,10 +78,10 @@ macro_rules! svd_impl(
     ($t: ty, $lapack_func: path) => (
         impl<R: Dim, C: Dim> SVDScalar<R, C> for $t
                 where R: DimMin<C>,
-                      DefaultAllocator: Allocator<$t, R, C> +
-                                        Allocator<$t, R, R> +
-                                        Allocator<$t, C, C> +
-                                        Allocator<$t, DimMinimum<R, C>> {
+                      DefaultAllocator: Allocator<R, C> +
+                                        Allocator<R, R> +
+                                        Allocator<C, C> +
+                                        Allocator<DimMinimum<R, C>> {
 
             fn compute(mut m: OMatrix<$t, R, C>) -> Option<SVD<$t, R, C>> {
                 let (nrows, ncols) = m.shape_generic();
@@ -132,16 +130,16 @@ macro_rules! svd_impl(
 
         impl<R: DimMin<C>, C: Dim> SVD<$t, R, C>
             // TODO: All those bounds…
-            where DefaultAllocator: Allocator<$t, R, C>                 +
-                                    Allocator<$t, C, R>                 +
-                                    Allocator<$t, U1, R>                +
-                                    Allocator<$t, U1, C>                +
-                                    Allocator<$t, R, R>                 +
-                                    Allocator<$t, DimMinimum<R, C>> +
-                                    Allocator<$t, DimMinimum<R, C>, R>  +
-                                    Allocator<$t, DimMinimum<R, C>, C>  +
-                                    Allocator<$t, R, DimMinimum<R, C>>  +
-                                    Allocator<$t, C, C> {
+            where DefaultAllocator: Allocator<R, C>                 +
+                                    Allocator<C, R>                 +
+                                    Allocator<U1, R>                +
+                                    Allocator<U1, C>                +
+                                    Allocator<R, R>                 +
+                                    Allocator<DimMinimum<R, C>> +
+                                    Allocator<DimMinimum<R, C>, R>  +
+                                    Allocator<DimMinimum<R, C>, C>  +
+                                    Allocator<R, DimMinimum<R, C>>  +
+                                    Allocator<C, C> {
             /// Reconstructs the matrix from its decomposition.
             ///
             /// Useful if some components (e.g. some singular values) of this decomposition have
@@ -235,9 +233,9 @@ macro_rules! svd_complex_impl(
             where R: DimMin<C>,
                   S: ContiguousStorage<Complex<$t>, R, C>,
                   S::Alloc: OwnedAllocator<Complex<$t>, R, C, S> +
-                            Allocator<Complex<$t>, R, R>         +
-                            Allocator<Complex<$t>, C, C>         +
-                            Allocator<$t, DimMinimum<R, C>> {
+                            Allocator<R, R>         +
+                            Allocator<C, C>         +
+                            Allocator<DimMinimum<R, C>> {
             let (nrows, ncols) = m.shape_generic();
 
             if nrows.value() == 0 || ncols.value() == 0 {