Run rustfmt.

benches/core/matrix.rs

@@ -1,7 +1,7 @@
+use na::{DMatrix, DVector, Matrix2, Matrix3, Matrix4, MatrixN, Vector2, Vector3, Vector4, U10};
 use rand::{IsaacRng, Rng};
-use test::{self, Bencher};
-use na::{DMatrix, DVector, Matrix2, Matrix3, Matrix4, MatrixN, U10, Vector2, Vector3, Vector4};
 use std::ops::{Add, Div, Mul, Sub};
+use test::{self, Bencher};
 
 #[path = "../common/macros.rs"]
 mod macros;
@@ -189,18 +189,10 @@ fn mat_mul_mat(bench: &mut Bencher) {
 
 #[bench]
 fn mat100_from_fn(bench: &mut Bencher) {
-    bench.iter(|| {
-        DMatrix::from_fn(100, 100, |a, b| {
-            a + b
-        })
-    })
+    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.iter(|| DMatrix::from_fn(500, 500, |a, b| a + b))
 }

benches/core/vector.rs

@@ -1,8 +1,8 @@
+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;
-use na::{DVector, Vector2, Vector3, Vector4, VectorN};
-use std::ops::{Add, Div, Mul, Sub};
 
 #[path = "../common/macros.rs"]
 mod macros;

benches/geometry/quaternion.rs

@@ -1,7 +1,7 @@
-use rand::{IsaacRng, Rng};
-use test::{self, Bencher};
 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;

benches/lib.rs

@@ -6,12 +6,12 @@ extern crate rand;
 extern crate test;
 extern crate typenum;
 
-use rand::{IsaacRng, Rng};
 use na::DMatrix;
+use rand::{IsaacRng, Rng};
 
 mod core;
-mod linalg;
 mod geometry;
+mod linalg;
 
 fn reproductible_dmatrix(nrows: usize, ncols: usize) -> DMatrix<f64> {
     let mut rng = IsaacRng::new_unseeded();

benches/linalg/bidiagonal.rs

@@ -1,5 +1,5 @@
-use test::{self, Bencher};
 use na::{Bidiagonal, DMatrix, Matrix4};
+use test::{self, Bencher};
 
 #[path = "../common/macros.rs"]
 mod macros;

benches/linalg/cholesky.rs

@@ -1,5 +1,5 @@
-use test::{self, Bencher};
 use na::{Cholesky, DMatrix, DVector};
+use test::{self, Bencher};
 
 #[bench]
 fn cholesky_100x100(bh: &mut Bencher) {

benches/linalg/full_piv_lu.rs

@@ -1,5 +1,5 @@
-use test::{self, Bencher};
 use na::{DMatrix, DVector, FullPivLU};
+use test::{self, Bencher};
 
 // Without unpack.
 #[bench]

benches/linalg/hessenberg.rs

@@ -1,5 +1,5 @@
-use test::{self, Bencher};
 use na::{DMatrix, Hessenberg, Matrix4};
+use test::{self, Bencher};
 
 #[path = "../common/macros.rs"]
 mod macros;

benches/linalg/lu.rs

@@ -1,5 +1,5 @@
-use test::{self, Bencher};
 use na::{DMatrix, DVector, LU};
+use test::{self, Bencher};
 
 // Without unpack.
 #[bench]

benches/linalg/mod.rs

@@ -1,11 +1,11 @@
-mod solve;
-mod cholesky;
-mod qr;
-mod hessenberg;
 mod bidiagonal;
-mod lu;
+mod cholesky;
 mod full_piv_lu;
-mod svd;
+mod hessenberg;
+mod lu;
+mod qr;
 mod schur;
+mod solve;
+mod svd;
 mod symmetric_eigen;
 // mod eigen;

benches/linalg/qr.rs

@@ -1,5 +1,5 @@
-use test::{self, Bencher};
 use na::{DMatrix, DVector, Matrix4, QR};
+use test::{self, Bencher};
 
 #[path = "../common/macros.rs"]
 mod macros;

benches/linalg/schur.rs

@@ -1,5 +1,5 @@
-use test::{self, Bencher};
 use na::{Matrix4, RealSchur};
+use test::{self, Bencher};
 
 #[bench]
 fn schur_decompose_4x4(bh: &mut Bencher) {

benches/linalg/solve.rs

@@ -1,5 +1,5 @@
-use test::Bencher;
 use na::{DMatrix, DVector};
+use test::Bencher;
 
 #[bench]
 fn solve_l_triangular_100x100(bh: &mut Bencher) {

benches/linalg/svd.rs

@@ -1,5 +1,5 @@
-use test::{self, Bencher};
 use na::{Matrix4, SVD};
+use test::{self, Bencher};
 
 #[bench]
 fn svd_decompose_4x4(bh: &mut Bencher) {

benches/linalg/symmetric_eigen.rs

@@ -1,5 +1,5 @@
-use test::{self, Bencher};
 use na::{Matrix4, SymmetricEigen};
+use test::{self, Bencher};
 
 #[bench]
 fn symmetric_eigen_decompose_4x4(bh: &mut Bencher) {

examples/dimensional_genericity.rs

@@ -2,15 +2,13 @@ extern crate alga;
 extern crate nalgebra as na;
 
 use alga::linear::FiniteDimInnerSpace;
-use na::{DefaultAllocator, Real, Unit, Vector2, Vector3, VectorN};
 use na::allocator::Allocator;
 use na::dimension::Dim;
+use na::{DefaultAllocator, Real, 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
-where
-    V: FiniteDimInnerSpace + Copy,
-{
+where V: FiniteDimInnerSpace + Copy {
     let n = plane_normal.as_ref(); // Get the underlying vector of type `V`.
     *vector - *n * (n.dot(vector) * na::convert(2.0))
 }
@@ -31,9 +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: Real {
     let n = plane_normal.as_ref(); // Get the underlying Vector2
     vector - n * (n.dot(vector) * na::convert(2.0))
 }
@@ -41,9 +37,7 @@ where
 /// 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: Real {
     let n = plane_normal.as_ref(); // Get the underlying Vector3
     vector - n * (n.dot(vector) * na::convert(2.0))
 }

examples/homogeneous_coordinates.rs

@@ -2,8 +2,8 @@
 extern crate approx;
 extern crate nalgebra as na;
 
-use std::f32;
 use na::{Isometry2, Point2, Vector2};
+use std::f32;
 
 fn use_dedicated_types() {
     let iso = Isometry2::new(Vector2::new(1.0, 1.0), f32::consts::PI);

examples/identity.rs

@@ -9,9 +9,7 @@ use na::{Id, Isometry3, Point3, Vector3};
  * intermediate value.
  */
 fn complicated_algorithm<T>(v: &Vector3<f32>, t: &T, n: usize) -> Vector3<f32>
-where
-    T: Transformation<Point3<f32>>,
-{
+where T: Transformation<Point3<f32>> {
     let mut result = *v;
 
     // Do lots of operations involving t.

examples/matrix_construction.rs

@@ -48,12 +48,11 @@ fn main() {
         4,
         3,
         [
-        // Components listed column-by-column.
-        1.0, 0.0, 0.0, 0.0,
-        0.0, 1.0, 0.0, 0.0,
-        0.0, 0.0, 1.0, 0.0
-    ].iter()
-            .cloned(),
+            // Components listed column-by-column.
+            1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0,
+        ]
+        .iter()
+        .cloned(),
     );
 
     assert_eq!(dm, dm1);

examples/transform_vector_point.rs

@@ -2,8 +2,8 @@
 extern crate approx;
 extern crate nalgebra as na;
 
-use std::f32;
 use na::{Isometry2, Point2, Vector2};
+use std::f32;
 
 fn main() {
     let t = Isometry2::new(Vector2::new(1.0, 1.0), f32::consts::PI);

nalgebra-glm/src/aliases.rs

@@ -1,9 +1,7 @@
-use na::{MatrixMN, VectorN,
-         Matrix2, Matrix3, Matrix4,
-         Matrix2x3, Matrix3x2, Matrix4x2,
-         Matrix2x4, Matrix3x4, Matrix4x3,
-         Quaternion,
-         U1, U2, U3, U4};
+use na::{
+    Matrix2, Matrix2x3, Matrix2x4, Matrix3, Matrix3x2, Matrix3x4, Matrix4, Matrix4x2, Matrix4x3,
+    MatrixMN, Quaternion, VectorN, U1, U2, U3, U4,
+};
 
 /// A matrix with components of type `N`. It has `R` rows, and `C` columns.
 ///
@@ -194,13 +192,13 @@ pub type UVec3 = TVec3<u32>;
 /// A 4D vector with `u32` components.
 pub type UVec4 = TVec4<u32>;
 /// A 1D vector with `f32` components.
-pub type Vec1  = TVec1<f32>;
+pub type Vec1 = TVec1<f32>;
 /// A 2D vector with `f32` components.
-pub type Vec2  = TVec2<f32>;
+pub type Vec2 = TVec2<f32>;
 /// A 3D vector with `f32` components.
-pub type Vec3  = TVec3<f32>;
+pub type Vec3 = TVec3<f32>;
 /// A 4D vector with `f32` components.
-pub type Vec4  = TVec4<f32>;
+pub type Vec4 = TVec4<f32>;
 
 /// A 1D vector with `u64` components.
 pub type U64Vec1 = TVec1<u64>;
@@ -270,7 +268,6 @@ pub type I8Vec3 = TVec3<i8>;
 /// A 4D vector with `i8` components.
 pub type I8Vec4 = TVec4<i8>;
 
-
 /// A 2x2 matrix with components of type `N`.
 pub type TMat2<N> = Matrix2<N>;
 /// A 2x2 matrix with components of type `N`.

nalgebra-glm/src/common.rs

@@ -1,9 +1,9 @@
-use std::mem;
+use na::{self, DefaultAllocator, Real};
 use num::FromPrimitive;
-use na::{self, Real, DefaultAllocator};
+use std::mem;
 
-use aliases::{TVec, TMat};
-use traits::{Number, Dimension, Alloc};
+use aliases::{TMat, TVec};
+use traits::{Alloc, Dimension, Number};
 
 /// For each matrix or vector component `x` if `x >= 0`; otherwise, it returns `-x`.
 ///
@@ -22,8 +22,8 @@ use traits::{Number, Dimension, Alloc};
 ///
 /// * [`sign`](fn.sign.html)
 pub fn abs<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C>) -> TMat<N, R, C>
-    where DefaultAllocator: Alloc<N, R, C> {
-     x.abs()
+where DefaultAllocator: Alloc<N, R, C> {
+    x.abs()
 }
 
 /// For each matrix or vector component returns a value equal to the nearest integer that is greater than or equal to `x`.
@@ -44,7 +44,7 @@ pub fn abs<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C>) -> TMat<N,
 /// * [`round`](fn.round.html)
 /// * [`trunc`](fn.trunc.html)
 pub fn ceil<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.map(|x| x.ceil())
 }
 
@@ -94,7 +94,7 @@ pub fn clamp_scalar<N: Number>(x: N, min_val: N, max_val: N) -> N {
 /// * [`clamp_scalar`](fn.clamp_scalar.html)
 /// * [`clamp_vec`](fn.clamp_vec.html)
 pub fn clamp<N: Number, D: Dimension>(x: &TVec<N, D>, min_val: N, max_val: N) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.map(|x| na::clamp(x, min_val, max_val))
 }
 
@@ -125,8 +125,14 @@ pub fn clamp<N: Number, D: Dimension>(x: &TVec<N, D>, min_val: N, max_val: N) ->
 ///
 /// * [`clamp_scalar`](fn.clamp_scalar.html)
 /// * [`clamp`](fn.clamp.html)
-pub fn clamp_vec<N: Number, D: Dimension>(x: &TVec<N, D>, min_val: &TVec<N, D>, max_val: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn clamp_vec<N: Number, D: Dimension>(
+    x: &TVec<N, D>,
+    min_val: &TVec<N, D>,
+    max_val: &TVec<N, D>,
+) -> TVec<N, D>
+where
+    DefaultAllocator: Alloc<N, D>,
+{
     x.zip_zip_map(min_val, max_val, |a, min, max| na::clamp(a, min, max))
 }
 
@@ -161,7 +167,7 @@ pub fn float_bits_to_int(v: f32) -> i32 {
 /// * [`uint_bits_to_float`](fn.uint_bits_to_float.html)
 /// * [`uint_bits_to_float_scalar`](fn.uint_bits_to_float_scalar.html)
 pub fn float_bits_to_int_vec<D: Dimension>(v: &TVec<f32, D>) -> TVec<i32, D>
-    where DefaultAllocator: Alloc<f32, D> {
+where DefaultAllocator: Alloc<f32, D> {
     v.map(float_bits_to_int)
 }
 
@@ -196,7 +202,7 @@ pub fn float_bits_to_uint(v: f32) -> u32 {
 /// * [`uint_bits_to_float`](fn.uint_bits_to_float.html)
 /// * [`uint_bits_to_float_scalar`](fn.uint_bits_to_float_scalar.html)
 pub fn float_bits_to_uint_vec<D: Dimension>(v: &TVec<f32, D>) -> TVec<u32, D>
-    where DefaultAllocator: Alloc<f32, D> {
+where DefaultAllocator: Alloc<f32, D> {
     v.map(float_bits_to_uint)
 }
 
@@ -217,7 +223,7 @@ pub fn float_bits_to_uint_vec<D: Dimension>(v: &TVec<f32, D>) -> TVec<u32, D>
 /// * [`round`](fn.round.html)
 /// * [`trunc`](fn.trunc.html)
 pub fn floor<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.map(|x| x.floor())
 }
 
@@ -244,7 +250,7 @@ pub fn floor<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 /// * [`round`](fn.round.html)
 /// * [`trunc`](fn.trunc.html)
 pub fn fract<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.map(|x| x.fract())
 }
 
@@ -271,7 +277,6 @@ pub fn fract<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 /// * [`uint_bits_to_float_scalar`](fn.uint_bits_to_float_scalar.html)
 pub fn int_bits_to_float(v: i32) -> f32 {
     f32::from_bits(v as u32)
-
 }
 
 /// For each components of `v`, returns a floating-point value corresponding to a signed integer encoding of a floating-point value.
@@ -288,7 +293,7 @@ pub fn int_bits_to_float(v: i32) -> f32 {
 /// * [`uint_bits_to_float`](fn.uint_bits_to_float.html)
 /// * [`uint_bits_to_float_scalar`](fn.uint_bits_to_float_scalar.html)
 pub fn int_bits_to_float_vec<D: Dimension>(v: &TVec<i32, D>) -> TVec<f32, D>
-    where DefaultAllocator: Alloc<f32, D> {
+where DefaultAllocator: Alloc<f32, D> {
     v.map(int_bits_to_float)
 }
 
@@ -325,7 +330,7 @@ pub fn mix<N: Number>(x: N, y: N, a: N) -> N {
 ///
 /// * [`modf`](fn.modf.html)
 pub fn modf_vec<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.zip_map(y, |x, y| x % y)
 }
 
@@ -357,9 +362,8 @@ pub fn modf<N: Number>(x: N, i: N) -> N {
 /// * [`fract`](fn.fract.html)
 /// * [`trunc`](fn.trunc.html)
 pub fn round<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.map(|x| x.round())
-
 }
 
 //pub fn roundEven<N: Scalar, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
@@ -382,14 +386,8 @@ pub fn round<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 /// * [`abs`](fn.abs.html)
 ///
 pub fn sign<N: Number, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
-    x.map(|x| {
-        if x.is_zero() {
-            N::zero()
-        } else {
-            x.signum()
-        }
-    })
+where DefaultAllocator: Alloc<N, D> {
+    x.map(|x| if x.is_zero() { N::zero() } else { x.signum() })
 }
 
 /// Returns 0.0 if `x <= edge0` and `1.0 if x >= edge1` and performs smooth Hermite interpolation between 0 and 1 when `edge0 < x < edge1`.
@@ -414,13 +412,13 @@ pub fn step_scalar<N: Number>(edge: N, x: N) -> N {
 
 /// Returns 0.0 if `x[i] < edge`, otherwise it returns 1.0.
 pub fn step<N: Number, D: Dimension>(edge: N, x: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.map(|x| step_scalar(edge, x))
 }
 
 /// Returns 0.0 if `x[i] < edge[i]`, otherwise it returns 1.0.
 pub fn step_vec<N: Number, D: Dimension>(edge: &TVec<N, D>, x: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     edge.zip_map(x, step_scalar)
 }
 
@@ -441,7 +439,7 @@ pub fn step_vec<N: Number, D: Dimension>(edge: &TVec<N, D>, x: &TVec<N, D>) -> T
 /// * [`fract`](fn.fract.html)
 /// * [`round`](fn.round.html)
 pub fn trunc<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.map(|x| x.trunc())
 }
 
@@ -460,7 +458,6 @@ pub fn trunc<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
 /// * [`uint_bits_to_float`](fn.uint_bits_to_float.html)
 pub fn uint_bits_to_float_scalar(v: u32) -> f32 {
     f32::from_bits(v)
-
 }
 
 /// For each component of `v`, returns a floating-point value corresponding to a unsigned integer encoding of a floating-point value.
@@ -477,6 +474,6 @@ pub fn uint_bits_to_float_scalar(v: u32) -> f32 {
 /// * [`int_bits_to_float_vec`](fn.int_bits_to_float_vec.html)
 /// * [`uint_bits_to_float_scalar`](fn.uint_bits_to_float_scalar.html)
 pub fn uint_bits_to_float<D: Dimension>(v: &TVec<u32, D>) -> TVec<f32, D>
-    where DefaultAllocator: Alloc<f32, D> {
+where DefaultAllocator: Alloc<f32, D> {
     v.map(uint_bits_to_float_scalar)
 }

nalgebra-glm/src/constructors.rs

@@ -1,7 +1,8 @@
-use na::{Scalar, Real, U2, U3, U4};
-use aliases::{TMat, Qua, TVec1, TVec2, TVec3, TVec4, TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4,
-              TMat4, TMat4x2, TMat4x3};
-
+use aliases::{
+    Qua, TMat, TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4, TMat4, TMat4x2, TMat4x3, TVec1,
+    TVec2, TVec3, TVec4,
+};
+use na::{Real, Scalar, U2, U3, U4};
 
 /// Creates a new 1D vector.
 ///
@@ -32,112 +33,173 @@ pub fn vec4<N: Scalar>(x: N, y: N, z: N, w: N) -> TVec4<N> {
     TVec4::new(x, y, z, w)
 }
 
-
 /// Create a new 2x2 matrix.
 pub fn mat2<N: Scalar>(m11: N, m12: N, m21: N, m22: N) -> TMat2<N> {
-    TMat::<N, U2, U2>::new(
-        m11, m12,
-        m21, m22,
-    )
+    TMat::<N, U2, U2>::new(m11, m12, m21, m22)
 }
 
 /// Create a new 2x2 matrix.
 pub fn mat2x2<N: Scalar>(m11: N, m12: N, m21: N, m22: N) -> TMat2<N> {
-    TMat::<N, U2, U2>::new(
-        m11, m12,
-        m21, m22,
-    )
+    TMat::<N, U2, U2>::new(m11, m12, m21, m22)
 }
 
 /// Create a new 2x3 matrix.
 pub fn mat2x3<N: Scalar>(m11: N, m12: N, m13: N, m21: N, m22: N, m23: N) -> TMat2x3<N> {
-    TMat::<N, U2, U3>::new(
-        m11, m12, m13,
-        m21, m22, m23,
-    )
+    TMat::<N, U2, U3>::new(m11, m12, m13, m21, m22, m23)
 }
 
 /// Create a new 2x4 matrix.
-pub fn mat2x4<N: Scalar>(m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N) -> TMat2x4<N> {
-    TMat::<N, U2, U4>::new(
-        m11, m12, m13, m14,
-        m21, m22, m23, m24,
-    )
+pub fn mat2x4<N: Scalar>(
+    m11: N,
+    m12: N,
+    m13: N,
+    m14: N,
+    m21: N,
+    m22: N,
+    m23: N,
+    m24: N,
+) -> TMat2x4<N>
+{
+    TMat::<N, U2, U4>::new(m11, m12, m13, m14, m21, m22, m23, m24)
 }
 
 /// Create a new 3x3 matrix.
-pub fn mat3<N: Scalar>(m11: N, m12: N, m13: N, m21: N, m22: N, m23: N, m31: N, m32: N, m33: N) -> TMat3<N> {
-    TMat::<N, U3, U3>::new(
-        m11, m12, m13,
-        m21, m22, m23,
-        m31, m32, m33,
-    )
+pub fn mat3<N: Scalar>(
+    m11: N,
+    m12: N,
+    m13: N,
+    m21: N,
+    m22: N,
+    m23: N,
+    m31: N,
+    m32: N,
+    m33: N,
+) -> TMat3<N>
+{
+    TMat::<N, U3, U3>::new(m11, m12, m13, m21, m22, m23, m31, m32, m33)
 }
 
 /// Create a new 3x2 matrix.
 pub fn mat3x2<N: Scalar>(m11: N, m12: N, m21: N, m22: N, m31: N, m32: N) -> TMat3x2<N> {
-    TMat::<N, U3, U2>::new(
-        m11, m12,
-        m21, m22,
-        m31, m32,
-    )
+    TMat::<N, U3, U2>::new(m11, m12, m21, m22, m31, m32)
 }
 
 /// Create a new 3x3 matrix.
-pub fn mat3x3<N: Scalar>(m11: N, m12: N, m13: N, m21: N, m22: N, m23: N, m31: N, m32: N, m33: N) -> TMat3<N> {
-    TMat::<N, U3, U3>::new(
-        m11, m12, m13,
-        m31, m32, m33,
-        m21, m22, m23,
-    )
+pub fn mat3x3<N: Scalar>(
+    m11: N,
+    m12: N,
+    m13: N,
+    m21: N,
+    m22: N,
+    m23: N,
+    m31: N,
+    m32: N,
+    m33: N,
+) -> TMat3<N>
+{
+    TMat::<N, U3, U3>::new(m11, m12, m13, m31, m32, m33, m21, m22, m23)
 }
 
 /// Create a new 3x4 matrix.
-pub fn mat3x4<N: Scalar>(m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N, m31: N, m32: N, m33: N, m34: N) -> TMat3x4<N> {
-    TMat::<N, U3, U4>::new(
-        m11, m12, m13, m14,
-        m21, m22, m23, m24,
-        m31, m32, m33, m34,
-    )
+pub fn mat3x4<N: Scalar>(
+    m11: N,
+    m12: N,
+    m13: N,
+    m14: N,
+    m21: N,
+    m22: N,
+    m23: N,
+    m24: N,
+    m31: N,
+    m32: N,
+    m33: N,
+    m34: N,
+) -> TMat3x4<N>
+{
+    TMat::<N, U3, U4>::new(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34)
 }
 
 /// Create a new 4x2 matrix.
-pub fn mat4x2<N: Scalar>(m11: N, m12: N, m21: N, m22: N, m31: N, m32: N, m41: N, m42: N) -> TMat4x2<N> {
-    TMat::<N, U4, U2>::new(
-        m11, m12,
-        m21, m22,
-        m31, m32,
-        m41, m42,
-    )
+pub fn mat4x2<N: Scalar>(
+    m11: N,
+    m12: N,
+    m21: N,
+    m22: N,
+    m31: N,
+    m32: N,
+    m41: N,
+    m42: N,
+) -> TMat4x2<N>
+{
+    TMat::<N, U4, U2>::new(m11, m12, m21, m22, m31, m32, m41, m42)
 }
 
 /// Create a new 4x3 matrix.
-pub fn mat4x3<N: Scalar>(m11: N, m12: N, m13: N, m21: N, m22: N, m23: N, m31: N, m32: N, m33: N, m41: N, m42: N, m43: N) -> TMat4x3<N> {
-    TMat::<N, U4, U3>::new(
-        m11, m12, m13,
-        m21, m22, m23,
-        m31, m32, m33,
-        m41, m42, m43,
+pub fn mat4x3<N: Scalar>(
+    m11: N,
+    m12: N,
+    m13: N,
+    m21: N,
+    m22: N,
+    m23: N,
+    m31: N,
+    m32: N,
+    m33: N,
+    m41: N,
+    m42: N,
+    m43: N,
+) -> TMat4x3<N>
+{
+    TMat::<N, U4, U3>::new(m11, m12, m13, m21, m22, m23, m31, m32, m33, m41, m42, m43)
+}
+
+/// Create a new 4x4 matrix.
+pub fn mat4x4<N: Scalar>(
+    m11: N,
+    m12: N,
+    m13: N,
+    m14: N,
+    m21: N,
+    m22: N,
+    m23: N,
+    m24: N,
+    m31: N,
+    m32: N,
+    m33: N,
+    m34: N,
+    m41: N,
+    m42: N,
+    m43: N,
+    m44: N,
+) -> TMat4<N>
+{
+    TMat::<N, U4, U4>::new(
+        m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44,
     )
 }
 
 /// Create a new 4x4 matrix.
-pub fn mat4x4<N: Scalar>(m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N, m31: N, m32: N, m33: N, m34: N, m41: N, m42: N, m43: N, m44: N) -> TMat4<N> {
+pub fn mat4<N: Scalar>(
+    m11: N,
+    m12: N,
+    m13: N,
+    m14: N,
+    m21: N,
+    m22: N,
+    m23: N,
+    m24: N,
+    m31: N,
+    m32: N,
+    m33: N,
+    m34: N,
+    m41: N,
+    m42: N,
+    m43: N,
+    m44: N,
+) -> TMat4<N>
+{
     TMat::<N, U4, U4>::new(
-        m11, m12, m13, m14,
-        m21, m22, m23, m24,
-        m31, m32, m33, m34,
-        m41, m42, m43, m44,
-    )
-}
-
-/// Create a new 4x4 matrix.
-pub fn mat4<N: Scalar>(m11: N, m12: N, m13: N, m14: N, m21: N, m22: N, m23: N, m24: N, m31: N, m32: N, m33: N, m34: N, m41: N, m42: N, m43: N, m44: N) -> TMat4<N> {
-    TMat::<N, U4, U4>::new(
-        m11, m12, m13, m14,
-        m21, m22, m23, m24,
-        m31, m32, m33, m34,
-        m41, m42, m43, m44,
+        m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44,
     )
 }
 

nalgebra-glm/src/exponential.rs

@@ -1,5 +1,5 @@
-use na::{Real, DefaultAllocator};
 use aliases::TVec;
+use na::{DefaultAllocator, Real};
 use traits::{Alloc, Dimension};
 
 /// Component-wise exponential.
@@ -8,7 +8,7 @@ use traits::{Alloc, Dimension};
 ///
 /// * [`exp2`](fn.exp2.html)
 pub fn exp<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     v.map(|x| x.exp())
 }
 
@@ -18,7 +18,7 @@ pub fn exp<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
 ///
 /// * [`exp`](fn.exp.html)
 pub fn exp2<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     v.map(|x| x.exp2())
 }
 
@@ -28,9 +28,8 @@ pub fn exp2<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
 ///
 /// * [`sqrt`](fn.sqrt.html)
 pub fn inversesqrt<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     v.map(|x| N::one() / x.sqrt())
-
 }
 
 /// Component-wise logarithm.
@@ -39,7 +38,7 @@ pub fn inversesqrt<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
 ///
 /// * [`log2`](fn.log2.html)
 pub fn log<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     v.map(|x| x.ln())
 }
 
@@ -49,13 +48,13 @@ pub fn log<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
 ///
 /// * [`log`](fn.log.html)
 pub fn log2<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     base.zip_map(exponent, |b, e| b.powf(e))
 }
 
@@ -68,6 +67,6 @@ pub fn pow<N: Real, D: Dimension>(base: &TVec<N, D>, exponent: &TVec<N, D>) -> T
 /// * [`inversesqrt`](fn.inversesqrt.html)
 /// * [`pow`](fn.pow.html)
 pub fn sqrt<N: Real, D: Dimension>(v: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     v.map(|x| x.sqrt())
 }

nalgebra-glm/src/ext/matrix_clip_space.rs

@@ -1,5 +1,5 @@
-use na::{Real, Orthographic3, Perspective3};
 use aliases::TMat4;
+use na::{Orthographic3, Perspective3, Real};
 
 //pub fn frustum<N: Real>(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4<N> {
 //    unimplemented!()
@@ -90,7 +90,6 @@ pub fn ortho<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -
 //    unimplemented!()
 //}
 
-
 /// Creates a matrix for a perspective-view frustum based on the right handedness and OpenGL near and far clip planes definition.
 ///
 /// # Important note

nalgebra-glm/src/ext/matrix_projection.rs

@@ -1,6 +1,6 @@
 use na::{self, Real, U3};
 
-use aliases::{TVec2, TVec3, TVec4, TMat4};
+use aliases::{TMat4, TVec2, TVec3, TVec4};
 
 /// Define a picking region.
 ///
@@ -13,11 +13,15 @@ pub fn pick_matrix<N: Real>(center: &TVec2<N>, delta: &TVec2<N>, viewport: &TVec
     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,
-        N::zero()
+        N::zero(),
     );
 
     let result = TMat4::new_translation(&shift);
-    result.prepend_nonuniform_scaling(&TVec3::new(viewport.z / delta.x, viewport.w / delta.y, N::one()))
+    result.prepend_nonuniform_scaling(&TVec3::new(
+        viewport.z / delta.x,
+        viewport.w / delta.y,
+        N::one(),
+    ))
 }
 
 /// Map the specified object coordinates `(obj.x, obj.y, obj.z)` into window coordinates using OpenGL near and far clip planes definition.
@@ -36,7 +40,13 @@ 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>(obj: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>, viewport: TVec4<N>) -> TVec3<N> {
+pub fn project<N: Real>(
+    obj: &TVec3<N>,
+    model: &TMat4<N>,
+    proj: &TMat4<N>,
+    viewport: TVec4<N>,
+) -> TVec3<N>
+{
     project_no(obj, model, proj, viewport)
 }
 
@@ -58,7 +68,13 @@ pub fn project<N: Real>(obj: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>, viewp
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_no`](fn.unproject_no.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn project_no<N: Real>(obj: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>, viewport: TVec4<N>) -> TVec3<N> {
+pub fn project_no<N: Real>(
+    obj: &TVec3<N>,
+    model: &TMat4<N>,
+    proj: &TMat4<N>,
+    viewport: TVec4<N>,
+) -> TVec3<N>
+{
     let proj = project_zo(obj, model, proj, viewport);
     TVec3::new(proj.x, proj.y, proj.z * na::convert(0.5) + na::convert(0.5))
 }
@@ -81,7 +97,13 @@ pub fn project_no<N: Real>(obj: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>, vi
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_no`](fn.unproject_no.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn project_zo<N: Real>(obj: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>, viewport: TVec4<N>) -> TVec3<N> {
+pub fn project_zo<N: Real>(
+    obj: &TVec3<N>,
+    model: &TMat4<N>,
+    proj: &TMat4<N>,
+    viewport: TVec4<N>,
+) -> TVec3<N>
+{
     let normalized = proj * model * TVec4::new(obj.x, obj.y, obj.z, N::one());
     let scale = N::one() / normalized.w;
 
@@ -108,7 +130,13 @@ pub fn project_zo<N: Real>(obj: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>, vi
 /// * [`project_zo`](fn.project_zo.html)
 /// * [`unproject_no`](fn.unproject_no.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn unproject<N: Real>(win: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>, viewport: TVec4<N>) -> TVec3<N> {
+pub fn unproject<N: Real>(
+    win: &TVec3<N>,
+    model: &TMat4<N>,
+    proj: &TMat4<N>,
+    viewport: TVec4<N>,
+) -> TVec3<N>
+{
     unproject_no(win, model, proj, viewport)
 }
 
@@ -130,7 +158,13 @@ pub fn unproject<N: Real>(win: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>, vie
 /// * [`project_zo`](fn.project_zo.html)
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_zo`](fn.unproject_zo.html)
-pub fn unproject_no<N: Real>(win: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>, viewport: TVec4<N>) -> TVec3<N> {
+pub fn unproject_no<N: Real>(
+    win: &TVec3<N>,
+    model: &TMat4<N>,
+    proj: &TMat4<N>,
+    viewport: TVec4<N>,
+) -> TVec3<N>
+{
     let _2: N = na::convert(2.0);
     let transform = (proj * model).try_inverse().unwrap_or_else(TMat4::zeros);
     let pt = TVec4::new(
@@ -162,7 +196,13 @@ pub fn unproject_no<N: Real>(win: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>,
 /// * [`project_zo`](fn.project_zo.html)
 /// * [`unproject`](fn.unproject.html)
 /// * [`unproject_no`](fn.unproject_no.html)
-pub fn unproject_zo<N: Real>(win: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>, viewport: TVec4<N>) -> TVec3<N> {
+pub fn unproject_zo<N: Real>(
+    win: &TVec3<N>,
+    model: &TMat4<N>,
+    proj: &TMat4<N>,
+    viewport: TVec4<N>,
+) -> TVec3<N>
+{
     let _2: N = na::convert(2.0);
     let transform = (proj * model).try_inverse().unwrap_or_else(TMat4::zeros);
     let pt = TVec4::new(

nalgebra-glm/src/ext/matrix_relationnal.rs

@@ -1,13 +1,18 @@
 use na::DefaultAllocator;
 
-use aliases::{TVec, TMat};
-use traits::{Alloc, Number, Dimension};
+use aliases::{TMat, TVec};
+use traits::{Alloc, Dimension, Number};
 
 /// Perform a component-wise equal-to comparison of two matrices.
 ///
 /// Return a boolean vector which components value is True if this expression is satisfied per column of the matrices.
-pub fn equal_columns<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C>, y: &TMat<N, R, C>) -> TVec<bool, C>
-    where DefaultAllocator: Alloc<N, R, C> {
+pub fn equal_columns<N: Number, R: Dimension, C: Dimension>(
+    x: &TMat<N, R, C>,
+    y: &TMat<N, R, C>,
+) -> TVec<bool, C>
+where
+    DefaultAllocator: Alloc<N, R, C>,
+{
     let mut res = TVec::<_, C>::repeat(false);
 
     for i in 0..C::dim() {
@@ -20,16 +25,28 @@ pub fn equal_columns<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C>, y
 /// Returns the component-wise comparison of `|x - y| < epsilon`.
 ///
 /// True if this expression is satisfied.
-pub fn equal_columns_eps<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C>, y: &TMat<N, R, C>, epsilon: N) -> TVec<bool, C>
-    where DefaultAllocator: Alloc<N, R, C> {
+pub fn equal_columns_eps<N: Number, R: Dimension, C: Dimension>(
+    x: &TMat<N, R, C>,
+    y: &TMat<N, R, C>,
+    epsilon: N,
+) -> TVec<bool, C>
+where
+    DefaultAllocator: Alloc<N, R, C>,
+{
     equal_columns_eps_vec(x, y, &TVec::<_, C>::repeat(epsilon))
 }
 
 /// Returns the component-wise comparison on each matrix column `|x - y| < epsilon`.
 ///
 /// True if this expression is satisfied.
-pub fn equal_columns_eps_vec<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C>, y: &TMat<N, R, C>, epsilon: &TVec<N, C>) -> TVec<bool, C>
-    where DefaultAllocator: Alloc<N, R, C> {
+pub fn equal_columns_eps_vec<N: Number, R: Dimension, C: Dimension>(
+    x: &TMat<N, R, C>,
+    y: &TMat<N, R, C>,
+    epsilon: &TVec<N, C>,
+) -> TVec<bool, C>
+where
+    DefaultAllocator: Alloc<N, R, C>,
+{
     let mut res = TVec::<_, C>::repeat(false);
 
     for i in 0..C::dim() {
@@ -42,8 +59,13 @@ pub fn equal_columns_eps_vec<N: Number, R: Dimension, C: Dimension>(x: &TMat<N,
 /// Perform a component-wise not-equal-to comparison of two matrices.
 ///
 /// Return a boolean vector which components value is True if this expression is satisfied per column of the matrices.
-pub fn not_equal_columns<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C>, y: &TMat<N, R, C>) -> TVec<bool, C>
-    where DefaultAllocator: Alloc<N, R, C> {
+pub fn not_equal_columns<N: Number, R: Dimension, C: Dimension>(
+    x: &TMat<N, R, C>,
+    y: &TMat<N, R, C>,
+) -> TVec<bool, C>
+where
+    DefaultAllocator: Alloc<N, R, C>,
+{
     let mut res = TVec::<_, C>::repeat(false);
 
     for i in 0..C::dim() {
@@ -56,16 +78,28 @@ pub fn not_equal_columns<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C
 /// Returns the component-wise comparison of `|x - y| < epsilon`.
 ///
 /// True if this expression is not satisfied.
-pub fn not_equal_columns_eps<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C>, y: &TMat<N, R, C>, epsilon: N) -> TVec<bool, C>
-    where DefaultAllocator: Alloc<N, R, C> {
+pub fn not_equal_columns_eps<N: Number, R: Dimension, C: Dimension>(
+    x: &TMat<N, R, C>,
+    y: &TMat<N, R, C>,
+    epsilon: N,
+) -> TVec<bool, C>
+where
+    DefaultAllocator: Alloc<N, R, C>,
+{
     not_equal_columns_eps_vec(x, y, &TVec::<_, C>::repeat(epsilon))
 }
 
 /// Returns the component-wise comparison of `|x - y| >= epsilon`.
 ///
 /// True if this expression is not satisfied.
-pub fn not_equal_columns_eps_vec<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C>, y: &TMat<N, R, C>, epsilon: &TVec<N, C>) -> TVec<bool, C>
-    where DefaultAllocator: Alloc<N, R, C> {
+pub fn not_equal_columns_eps_vec<N: Number, R: Dimension, C: Dimension>(
+    x: &TMat<N, R, C>,
+    y: &TMat<N, R, C>,
+    epsilon: &TVec<N, C>,
+) -> TVec<bool, C>
+where
+    DefaultAllocator: Alloc<N, R, C>,
+{
     let mut res = TVec::<_, C>::repeat(false);
 
     for i in 0..C::dim() {

nalgebra-glm/src/ext/matrix_transform.rs

@@ -1,11 +1,11 @@
-use na::{DefaultAllocator, Real, Unit, Rotation3, Point3};
+use na::{DefaultAllocator, Point3, Real, Rotation3, Unit};
 
-use traits::{Dimension, Number, Alloc};
-use aliases::{TMat, TVec, TVec3, TMat4};
+use aliases::{TMat, TMat4, TVec, TVec3};
+use traits::{Alloc, Dimension, Number};
 
 /// The identity matrix.
 pub fn identity<N: Number, D: Dimension>() -> TMat<N, D, D>
-    where DefaultAllocator: Alloc<N, D, D> {
+where DefaultAllocator: Alloc<N, D, D> {
     TMat::<N, D, D>::identity()
 }
 
@@ -38,7 +38,11 @@ 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> {
-    TMat::look_at_lh(&Point3::from_coordinates(*eye), &Point3::from_coordinates(*center), up)
+    TMat::look_at_lh(
+        &Point3::from_coordinates(*eye),
+        &Point3::from_coordinates(*center),
+        up,
+    )
 }
 
 /// Build a right handed look at view matrix.
@@ -54,7 +58,11 @@ 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> {
-    TMat::look_at_rh(&Point3::from_coordinates(*eye), &Point3::from_coordinates(*center), up)
+    TMat::look_at_rh(
+        &Point3::from_coordinates(*eye),
+        &Point3::from_coordinates(*center),
+        up,
+    )
 }
 
 /// Builds a rotation 4 * 4 matrix created from an axis vector and an angle and right-multiply it to `m`.

nalgebra-glm/src/ext/mod.rs

@@ -1,30 +1,41 @@
 //! (Reexported) Additional features not specified by GLSL specification
 
 pub use self::matrix_clip_space::{ortho, perspective};
-pub use self::matrix_projection::{pick_matrix, project, project_no, project_zo, unproject, unproject_no, unproject_zo};
-pub use self::matrix_relationnal::{equal_columns, equal_columns_eps, equal_columns_eps_vec, not_equal_columns, not_equal_columns_eps, not_equal_columns_eps_vec};
-pub use self::matrix_transform::{identity, look_at, look_at_lh, rotate, scale, look_at_rh, translate, rotate_x, rotate_y, rotate_z};
+pub use self::matrix_projection::{
+    pick_matrix, project, project_no, project_zo, unproject, unproject_no, unproject_zo,
+};
+pub use self::matrix_relationnal::{
+    equal_columns, equal_columns_eps, equal_columns_eps_vec, not_equal_columns,
+    not_equal_columns_eps, not_equal_columns_eps_vec,
+};
+pub use self::matrix_transform::{
+    identity, look_at, look_at_lh, look_at_rh, rotate, rotate_x, rotate_y, rotate_z, scale,
+    translate,
+};
+pub use self::quaternion_common::{quat_conjugate, quat_inverse, quat_lerp, quat_slerp};
+pub use self::quaternion_geometric::{
+    quat_cross, quat_dot, quat_length, quat_magnitude, quat_normalize,
+};
+pub use self::quaternion_relational::{
+    quat_equal, quat_equal_eps, quat_not_equal, quat_not_equal_eps,
+};
+pub use self::quaternion_transform::{quat_exp, quat_log, quat_pow, quat_rotate};
+pub use self::quaternion_trigonometric::{quat_angle, quat_angle_axis, quat_axis};
 pub use self::scalar_common::{max3_scalar, max4_scalar, min3_scalar, min4_scalar};
 pub use self::scalar_constants::{epsilon, pi};
 pub use self::vector_common::{max, max2, max3, max4, min, min2, min3, min4};
 pub use self::vector_relational::{equal_eps, equal_eps_vec, not_equal_eps, not_equal_eps_vec};
-pub use self::quaternion_common::{quat_conjugate, quat_inverse, quat_lerp, quat_slerp};
-pub use self::quaternion_geometric::{quat_cross, quat_dot, quat_length, quat_magnitude, quat_normalize};
-pub use self::quaternion_relational::{quat_equal, quat_equal_eps, quat_not_equal, quat_not_equal_eps};
-pub use self::quaternion_transform::{quat_exp, quat_log, quat_pow, quat_rotate};
-pub use self::quaternion_trigonometric::{quat_angle, quat_angle_axis, quat_axis};
-
 
 mod matrix_clip_space;
 mod matrix_projection;
 mod matrix_relationnal;
 mod matrix_transform;
-mod scalar_common;
-mod scalar_constants;
-mod vector_common;
-mod vector_relational;
 mod quaternion_common;
 mod quaternion_geometric;
 mod quaternion_relational;
 mod quaternion_transform;
-mod quaternion_trigonometric;
+mod quaternion_trigonometric;
+mod scalar_common;
+mod scalar_constants;
+mod vector_common;
+mod vector_relational;

nalgebra-glm/src/ext/quaternion_common.rs

@@ -31,5 +31,7 @@ pub fn quat_lerp<N: Real>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
 
 /// Interpolate spherically between `x` and `y`.
 pub fn quat_slerp<N: Real>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
-    Unit::new_normalize(*x).slerp(&Unit::new_normalize(*y), a).unwrap()
+    Unit::new_normalize(*x)
+        .slerp(&Unit::new_normalize(*y), a)
+        .unwrap()
 }

nalgebra-glm/src/ext/quaternion_geometric.rs

@@ -25,4 +25,4 @@ pub fn quat_magnitude<N: Real>(q: &Qua<N>) -> N {
 /// Normalizes the quaternion `q`.
 pub fn quat_normalize<N: Real>(q: &Qua<N>) -> Qua<N> {
     q.normalize()
-}
+}

nalgebra-glm/src/ext/quaternion_relational.rs

@@ -1,6 +1,5 @@
 use na::{Real, U4};
 
-
 use aliases::{Qua, TVec};
 
 /// Component-wise equality comparison between two quaternions.

nalgebra-glm/src/ext/quaternion_transform.rs

@@ -1,4 +1,4 @@
-use na::{Real, UnitQuaternion, Unit};
+use na::{Real, Unit, UnitQuaternion};
 
 use aliases::{Qua, TVec3};
 
@@ -24,4 +24,4 @@ pub fn quat_rotate<N: Real>(q: &Qua<N>, angle: N, axis: &TVec3<N>) -> Qua<N> {
 
 //pub fn quat_sqrt<N: Real>(q: &Qua<N>) -> Qua<N> {
 //    unimplemented!()
-//}
+//}

nalgebra-glm/src/ext/quaternion_trigonometric.rs

@@ -19,4 +19,4 @@ pub fn quat_axis<N: Real>(x: &Qua<N>) -> TVec3<N> {
     } else {
         TVec3::zeros()
     }
-}
+}

nalgebra-glm/src/ext/vector_common.rs

@@ -1,7 +1,7 @@
 use na::{self, DefaultAllocator};
 
-use traits::{Alloc, Number, Dimension};
 use aliases::TVec;
+use traits::{Alloc, Dimension, Number};
 
 /// Component-wise maximum between a vector and a scalar.
 ///
@@ -17,7 +17,7 @@ use aliases::TVec;
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
 pub fn max<N: Number, D: Dimension>(a: &TVec<N, D>, b: N) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     a.map(|a| na::sup(&a, &b))
 }
 
@@ -35,7 +35,7 @@ pub fn max<N: Number, D: Dimension>(a: &TVec<N, D>, b: N) -> TVec<N, D>
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
 pub fn max2<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     na::sup(a, b)
 }
 
@@ -53,7 +53,7 @@ pub fn max2<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>) -> TVec<N,
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
 pub fn max3<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>, c: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     max2(&max2(a, b), c)
 }
 
@@ -70,8 +70,15 @@ pub fn max3<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>, c: &TVec<N,
 /// * [`min2`](fn.min2.html)
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
-pub fn max4<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>, c: &TVec<N, D>, d: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn max4<N: Number, D: Dimension>(
+    a: &TVec<N, D>,
+    b: &TVec<N, D>,
+    c: &TVec<N, D>,
+    d: &TVec<N, D>,
+) -> TVec<N, D>
+where
+    DefaultAllocator: Alloc<N, D>,
+{
     max2(&max2(a, b), &max2(c, d))
 }
 
@@ -89,7 +96,7 @@ pub fn max4<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>, c: &TVec<N,
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
 pub fn min<N: Number, D: Dimension>(x: &TVec<N, D>, y: N) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.map(|x| na::inf(&x, &y))
 }
 
@@ -107,7 +114,7 @@ pub fn min<N: Number, D: Dimension>(x: &TVec<N, D>, y: N) -> TVec<N, D>
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
 pub fn min2<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     na::inf(x, y)
 }
 
@@ -125,7 +132,7 @@ pub fn min2<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<N,
 /// * [`min2`](fn.min2.html)
 /// * [`min4`](fn.min4.html)
 pub fn min3<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>, c: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     min2(&min2(a, b), c)
 }
 
@@ -142,7 +149,14 @@ pub fn min3<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>, c: &TVec<N,
 /// * [`min`](fn.min.html)
 /// * [`min2`](fn.min2.html)
 /// * [`min3`](fn.min3.html)
-pub fn min4<N: Number, D: Dimension>(a: &TVec<N, D>, b: &TVec<N, D>, c: &TVec<N, D>, d: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn min4<N: Number, D: Dimension>(
+    a: &TVec<N, D>,
+    b: &TVec<N, D>,
+    c: &TVec<N, D>,
+    d: &TVec<N, D>,
+) -> TVec<N, D>
+where
+    DefaultAllocator: Alloc<N, D>,
+{
     min2(&min2(a, b), &min2(c, d))
 }

nalgebra-glm/src/ext/vector_relational.rs

@@ -1,7 +1,7 @@
-use na::{DefaultAllocator};
+use na::DefaultAllocator;
 
-use traits::{Alloc, Number, Dimension};
 use aliases::TVec;
+use traits::{Alloc, Dimension, Number};
 
 /// Component-wise approximate equality of two vectors, using a scalar epsilon.
 ///
@@ -10,8 +10,14 @@ use aliases::TVec;
 /// * [`equal_eps_vec`](fn.equal_eps_vec.html)
 /// * [`not_equal_eps`](fn.not_equal_eps.html)
 /// * [`not_equal_eps_vec`](fn.not_equal_eps_vec.html)
-pub fn equal_eps<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, epsilon: N) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn equal_eps<N: Number, D: Dimension>(
+    x: &TVec<N, D>,
+    y: &TVec<N, D>,
+    epsilon: N,
+) -> TVec<bool, D>
+where
+    DefaultAllocator: Alloc<N, D>,
+{
     x.zip_map(y, |x, y| abs_diff_eq!(x, y, epsilon = epsilon))
 }
 
@@ -22,8 +28,14 @@ pub fn equal_eps<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, epsilo
 /// * [`equal_eps`](fn.equal_eps.html)
 /// * [`not_equal_eps`](fn.not_equal_eps.html)
 /// * [`not_equal_eps_vec`](fn.not_equal_eps_vec.html)
-pub fn equal_eps_vec<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, epsilon: &TVec<N, D>) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn equal_eps_vec<N: Number, D: Dimension>(
+    x: &TVec<N, D>,
+    y: &TVec<N, D>,
+    epsilon: &TVec<N, D>,
+) -> TVec<bool, D>
+where
+    DefaultAllocator: Alloc<N, D>,
+{
     x.zip_zip_map(y, epsilon, |x, y, eps| abs_diff_eq!(x, y, epsilon = eps))
 }
 
@@ -34,8 +46,14 @@ pub fn equal_eps_vec<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, ep
 /// * [`equal_eps`](fn.equal_eps.html)
 /// * [`equal_eps_vec`](fn.equal_eps_vec.html)
 /// * [`not_equal_eps_vec`](fn.not_equal_eps_vec.html)
-pub fn not_equal_eps<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, epsilon: N) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn not_equal_eps<N: Number, D: Dimension>(
+    x: &TVec<N, D>,
+    y: &TVec<N, D>,
+    epsilon: N,
+) -> TVec<bool, D>
+where
+    DefaultAllocator: Alloc<N, D>,
+{
     x.zip_map(y, |x, y| abs_diff_ne!(x, y, epsilon = epsilon))
 }
 
@@ -46,7 +64,13 @@ pub fn not_equal_eps<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, ep
 /// * [`equal_eps`](fn.equal_eps.html)
 /// * [`equal_eps_vec`](fn.equal_eps_vec.html)
 /// * [`not_equal_eps`](fn.not_equal_eps.html)
-pub fn not_equal_eps_vec<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>, epsilon: &TVec<N, D>) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn not_equal_eps_vec<N: Number, D: Dimension>(
+    x: &TVec<N, D>,
+    y: &TVec<N, D>,
+    epsilon: &TVec<N, D>,
+) -> TVec<bool, D>
+where
+    DefaultAllocator: Alloc<N, D>,
+{
     x.zip_zip_map(y, epsilon, |x, y, eps| abs_diff_ne!(x, y, epsilon = eps))
 }

nalgebra-glm/src/geometric.rs

@@ -1,7 +1,7 @@
-use na::{Real, DefaultAllocator};
+use na::{DefaultAllocator, Real};
 
-use traits::{Number, Alloc, Dimension};
 use aliases::{TVec, TVec3};
+use 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> {
@@ -14,19 +14,25 @@ pub fn cross<N: Number, D: Dimension>(x: &TVec3<N>, y: &TVec3<N>) -> TVec3<N> {
 ///
 /// * [`distance2`](fn.distance2.html)
 pub fn distance<N: Real, D: Dimension>(p0: &TVec<N, D>, p1: &TVec<N, D>) -> N
-    where DefaultAllocator: Alloc<N, D> {
-   (p1 - p0).norm()
+where DefaultAllocator: Alloc<N, D> {
+    (p1 - p0).norm()
 }
 
 /// The dot product of two vectors.
 pub fn dot<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.dot(y)
 }
 
 /// If `dot(nref, i) < 0.0`, return `n`, otherwise, return `-n`.
-pub fn faceforward<N: Number, D: Dimension>(n: &TVec<N, D>, i: &TVec<N, D>, nref: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn faceforward<N: Number, D: Dimension>(
+    n: &TVec<N, D>,
+    i: &TVec<N, D>,
+    nref: &TVec<N, D>,
+) -> TVec<N, D>
+where
+    DefaultAllocator: Alloc<N, D>,
+{
     if nref.dot(i) < N::zero() {
         n.clone()
     } else {
@@ -44,7 +50,7 @@ pub fn faceforward<N: Number, D: Dimension>(n: &TVec<N, D>, i: &TVec<N, D>, nref
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`magnitude2`](fn.magnitude2.html)
 pub fn length<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.norm()
 }
 
@@ -58,34 +64,32 @@ pub fn length<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
 /// * [`magnitude2`](fn.magnitude2.html)
 /// * [`nalgebra::norm`](../nalgebra/fn.norm.html)
 pub fn magnitude<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.norm()
 }
 
 /// Normalizes a vector.
 pub fn normalize<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.normalize()
 }
 
 /// For the incident vector `i` and surface orientation `n`, returns the reflection direction : `result = i - 2.0 * dot(n, i) * n`.
 pub fn reflect_vec<N: Number, D: Dimension>(i: &TVec<N, D>, n: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     let _2 = N::one() + N::one();
     i - n * (n.dot(i) * _2)
 }
 
 /// 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>
-    where DefaultAllocator: Alloc<N, D> {
-
+where DefaultAllocator: Alloc<N, D> {
     let ni = n.dot(i);
     let k = N::one() - eta * eta * (N::one() - ni * ni);
 
     if k < N::zero() {
         TVec::<_, D>::zeros()
-    }
-    else {
+    } else {
         i * eta - n * (eta * dot(n, i) + k.sqrt())
     }
 }

nalgebra-glm/src/gtc/epsilon.rs

@@ -28,4 +28,4 @@ pub fn epsilon_not_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>
 pub fn epsilon_not_equal2<N: AbsDiffEq<Epsilon = N>>(x: N, y: N, epsilon: N) -> bool {
     abs_diff_ne!(x, y, epsilon = epsilon)
 }
-*/
+*/

nalgebra-glm/src/gtc/matrix_access.rs

@@ -1,7 +1,7 @@
-use na::{Scalar, DefaultAllocator};
+use na::{DefaultAllocator, Scalar};
 
+use aliases::{TMat, TVec};
 use traits::{Alloc, Dimension};
-use aliases::{TVec, TMat};
 
 /// The `index`-th column of the matrix `m`.
 ///
@@ -10,8 +10,13 @@ use aliases::{TVec, TMat};
 /// * [`row`](fn.row.html)
 /// * [`set_column`](fn.set_column.html)
 /// * [`set_row`](fn.set_row.html)
-pub fn column<N: Scalar, R: Dimension, C: Dimension>(m: &TMat<N, R, C>, index: usize) -> TVec<N, R>
-    where DefaultAllocator: Alloc<N, R, C> {
+pub fn column<N: Scalar, R: Dimension, C: Dimension>(
+    m: &TMat<N, R, C>,
+    index: usize,
+) -> TVec<N, R>
+where
+    DefaultAllocator: Alloc<N, R, C>,
+{
     m.column(index).into_owned()
 }
 
@@ -22,8 +27,14 @@ pub fn column<N: Scalar, R: Dimension, C: Dimension>(m: &TMat<N, R, C>, index: u
 /// * [`column`](fn.column.html)
 /// * [`row`](fn.row.html)
 /// * [`set_row`](fn.set_row.html)
-pub fn set_column<N: Scalar, R: Dimension, C: Dimension>(m: &TMat<N, R, C>, index: usize, x: &TVec<N, R>) -> TMat<N, R, C>
-    where DefaultAllocator: Alloc<N, R, C> {
+pub fn set_column<N: Scalar, R: Dimension, C: Dimension>(
+    m: &TMat<N, R, C>,
+    index: usize,
+    x: &TVec<N, R>,
+) -> TMat<N, R, C>
+where
+    DefaultAllocator: Alloc<N, R, C>,
+{
     let mut res = m.clone();
     res.set_column(index, x);
     res
@@ -37,7 +48,7 @@ pub fn set_column<N: Scalar, R: Dimension, C: Dimension>(m: &TMat<N, R, C>, inde
 /// * [`set_column`](fn.set_column.html)
 /// * [`set_row`](fn.set_row.html)
 pub fn row<N: Scalar, R: Dimension, C: Dimension>(m: &TMat<N, R, C>, index: usize) -> TVec<N, C>
-    where DefaultAllocator: Alloc<N, R, C> {
+where DefaultAllocator: Alloc<N, R, C> {
     m.row(index).into_owned().transpose()
 }
 
@@ -48,8 +59,14 @@ pub fn row<N: Scalar, R: Dimension, C: Dimension>(m: &TMat<N, R, C>, index: usiz
 /// * [`column`](fn.column.html)
 /// * [`row`](fn.row.html)
 /// * [`set_column`](fn.set_column.html)
-pub fn set_row<N: Scalar, R: Dimension, C: Dimension>(m: &TMat<N, R, C>, index: usize, x: &TVec<N, C>) -> TMat<N, R, C>
-    where DefaultAllocator: Alloc<N, R, C> {
+pub fn set_row<N: Scalar, R: Dimension, C: Dimension>(
+    m: &TMat<N, R, C>,
+    index: usize,
+    x: &TVec<N, C>,
+) -> TMat<N, R, C>
+where
+    DefaultAllocator: Alloc<N, R, C>,
+{
     let mut res = m.clone();
     res.set_row(index, &x.transpose());
     res

nalgebra-glm/src/gtc/matrix_inverse.rs

@@ -1,17 +1,19 @@
-use na::{Real, DefaultAllocator};
+use na::{DefaultAllocator, Real};
 
-use traits::{Alloc, Dimension};
 use aliases::TMat;
+use 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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<N, D, D> {
-    m.try_inverse().unwrap_or_else(TMat::<_, D, D>::zeros).transpose()
+where DefaultAllocator: Alloc<N, D, D> {
+    m.try_inverse()
+        .unwrap_or_else(TMat::<_, D, D>::zeros)
+        .transpose()
 }

nalgebra-glm/src/gtc/mod.rs

@@ -1,17 +1,32 @@
 //! (Reexported) Recommended features not specified by GLSL specification
 
 //pub use self::bitfield::*;
-pub use self::constants::{e, two_pi, euler, four_over_pi, golden_ratio, half_pi, ln_ln_two, ln_ten, ln_two, one, one_over_pi, one_over_root_two, one_over_two_pi, quarter_pi, root_five, root_half_pi, root_ln_four, root_pi, root_three, root_two, root_two_pi, third, three_over_two_pi, two_over_pi, two_over_root_pi, two_thirds, zero};
+pub use self::constants::{
+    e, euler, four_over_pi, golden_ratio, half_pi, ln_ln_two, ln_ten, ln_two, one, one_over_pi,
+    one_over_root_two, one_over_two_pi, quarter_pi, root_five, root_half_pi, root_ln_four, root_pi,
+    root_three, root_two, root_two_pi, third, three_over_two_pi, two_over_pi, two_over_root_pi,
+    two_pi, two_thirds, zero,
+};
 //pub use self::integer::*;
 pub use self::matrix_access::{column, row, set_column, set_row};
 pub use self::matrix_inverse::{affine_inverse, inverse_transpose};
 //pub use self::packing::*;
 //pub use self::reciprocal::*;
 //pub use self::round::*;
-pub use self::type_ptr::{make_mat2, make_mat2x2, make_mat2x3, make_mat2x4, make_mat3, make_mat3x2, make_mat3x3, make_mat3x4, make_mat4, make_mat4x2, make_mat4x3, make_mat4x4, make_quat, make_vec1, make_vec2, make_vec3, make_vec4, value_ptr, value_ptr_mut, vec1_to_vec2, vec1_to_vec3, vec1_to_vec4, vec2_to_vec1, vec2_to_vec2, vec2_to_vec3, vec2_to_vec4, vec3_to_vec1, vec3_to_vec2, vec3_to_vec3, vec3_to_vec4, vec4_to_vec1, vec4_to_vec2, vec4_to_vec3, vec4_to_vec4, mat2_to_mat3, mat2_to_mat4, mat3_to_mat2, mat3_to_mat4, mat4_to_mat2, mat4_to_mat3};
+pub use self::type_ptr::{
+    make_mat2, make_mat2x2, make_mat2x3, make_mat2x4, make_mat3, make_mat3x2, make_mat3x3,
+    make_mat3x4, make_mat4, make_mat4x2, make_mat4x3, make_mat4x4, make_quat, make_vec1, make_vec2,
+    make_vec3, make_vec4, mat2_to_mat3, mat2_to_mat4, mat3_to_mat2, mat3_to_mat4, mat4_to_mat2,
+    mat4_to_mat3, value_ptr, value_ptr_mut, vec1_to_vec2, vec1_to_vec3, vec1_to_vec4, vec2_to_vec1,
+    vec2_to_vec2, vec2_to_vec3, vec2_to_vec4, vec3_to_vec1, vec3_to_vec2, vec3_to_vec3,
+    vec3_to_vec4, vec4_to_vec1, vec4_to_vec2, vec4_to_vec3, vec4_to_vec4,
+};
 //pub use self::ulp::*;
-pub use self::quaternion::{quat_cast, quat_euler_angles, quat_greater_than, quat_greater_than_equal, quat_less_than, quat_less_than_equal, quat_look_at, quat_look_at_lh, quat_look_at_rh, quat_pitch, quat_roll, quat_yaw};
-
+pub use self::quaternion::{
+    quat_cast, quat_euler_angles, quat_greater_than, quat_greater_than_equal, quat_less_than,
+    quat_less_than_equal, quat_look_at, quat_look_at_lh, quat_look_at_rh, quat_pitch, quat_roll,
+    quat_yaw,
+};
 
 //mod bitfield;
 mod constants;
@@ -24,4 +39,4 @@ mod matrix_inverse;
 //mod round;
 mod type_ptr;
 //mod ulp;
-mod quaternion;
+mod quaternion;

nalgebra-glm/src/gtc/quaternion.rs

@@ -1,7 +1,6 @@
-use na::{Real, U4, UnitQuaternion};
-
-use aliases::{Qua, TVec, TVec3, TMat4};
+use na::{Real, UnitQuaternion, U4};
 
+use 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> {

nalgebra-glm/src/gtc/type_ptr.rs

@@ -1,8 +1,10 @@
-use na::{Scalar, Real, DefaultAllocator, Quaternion};
+use na::{DefaultAllocator, Quaternion, Real, Scalar};
 
-use traits::{Number, Alloc, Dimension};
-use aliases::{Qua, TMat, TMat2, TMat3, TMat4, TVec1, TVec2, TVec3, TVec4,
-              TMat2x3, TMat2x4, TMat3x2, TMat3x4, TMat4x2, TMat4x3};
+use aliases::{
+    Qua, TMat, TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4, TMat4, TMat4x2, TMat4x3, TVec1,
+    TVec2, TVec3, TVec4,
+};
+use 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> {
@@ -69,19 +71,12 @@ pub fn mat2_to_mat3<N: Number>(m: &TMat2<N>) -> TMat3<N> {
     let _0 = N::zero();
     let _1 = N::one();
 
-    TMat3::new(
-        m.m11, m.m12, _0,
-        m.m21, m.m22, _0,
-        _0, _0, _1
-    )
+    TMat3::new(m.m11, m.m12, _0, m.m21, m.m22, _0, _0, _0, _1)
 }
 
 /// Converts a 3x3 matrix to a 2x2 matrix.
 pub fn mat3_to_mat2<N: Scalar>(m: &TMat3<N>) -> TMat2<N> {
-    TMat2::new(
-        m.m11, m.m12,
-        m.m21, m.m22
-    )
+    TMat2::new(m.m11, m.m12, m.m21, m.m22)
 }
 
 /// Converts a 3x3 matrix to a 4x4 matrix.
@@ -90,19 +85,14 @@ pub fn mat3_to_mat4<N: Number>(m: &TMat3<N>) -> TMat4<N> {
     let _1 = N::one();
 
     TMat4::new(
-        m.m11, m.m12, m.m13, _0,
-        m.m21, m.m22, m.m23, _0,
-        m.m31, m.m32, m.m33, _0,
-        _0, _0, _0, _1,
+        m.m11, m.m12, m.m13, _0, m.m21, m.m22, m.m23, _0, m.m31, m.m32, m.m33, _0, _0, _0, _0, _1,
     )
 }
 
 /// Converts a 4x4 matrix to a 3x3 matrix.
 pub fn mat4_to_mat3<N: Scalar>(m: &TMat4<N>) -> TMat3<N> {
     TMat3::new(
-        m.m11, m.m12, m.m13,
-        m.m21, m.m22, m.m23,
-        m.m31, m.m32, m.m33,
+        m.m11, m.m12, m.m13, m.m21, m.m22, m.m23, m.m31, m.m32, m.m33,
     )
 }
 
@@ -112,19 +102,13 @@ pub fn mat2_to_mat4<N: Number>(m: &TMat2<N>) -> TMat4<N> {
     let _1 = N::one();
 
     TMat4::new(
-        m.m11, m.m12, _0, _0,
-        m.m21, m.m22, _0, _0,
-        _0, _0, _1, _0,
-        _0, _0, _0, _1,
+        m.m11, m.m12, _0, _0, m.m21, m.m22, _0, _0, _0, _0, _1, _0, _0, _0, _0, _1,
     )
 }
 
 /// Converts a 4x4 matrix to a 2x2 matrix.
 pub fn mat4_to_mat2<N: Scalar>(m: &TMat4<N>) -> TMat2<N> {
-    TMat2::new(
-        m.m11, m.m12,
-        m.m21, m.m22,
-    )
+    TMat2::new(m.m11, m.m12, m.m21, m.m22)
 }
 
 /// Creates a quaternion from a slice arranged as `[x, y, z, w]`.
@@ -400,13 +384,12 @@ pub fn make_vec4<N: Scalar>(ptr: &[N]) -> TVec4<N> {
 
 /// Converts a matrix or vector to a slice arranged in column-major order.
 pub fn value_ptr<N: Scalar, R: Dimension, C: Dimension>(x: &TMat<N, R, C>) -> &[N]
-    where DefaultAllocator: Alloc<N, R, C> {
+where DefaultAllocator: Alloc<N, R, C> {
     x.as_slice()
 }
 
 /// Converts a matrix or vector to a mutable slice arranged in column-major order.
 pub fn value_ptr_mut<N: Scalar, R: Dimension, C: Dimension>(x: &mut TMat<N, R, C>) -> &mut [N]
-    where DefaultAllocator: Alloc<N, R, C> {
+where DefaultAllocator: Alloc<N, R, C> {
     x.as_mut_slice()
 }
-

nalgebra-glm/src/gtx/component_wise.rs

@@ -1,7 +1,7 @@
 use na::{self, DefaultAllocator};
 
-use traits::{Number, Alloc, Dimension};
 use aliases::TMat;
+use traits::{Alloc, Dimension, Number};
 
 /// The sum of every component of the given matrix or vector.
 ///
@@ -22,7 +22,7 @@ use aliases::TMat;
 /// * [`comp_min`](fn.comp_min.html)
 /// * [`comp_mul`](fn.comp_mul.html)
 pub fn comp_add<N: Number, R: Dimension, C: Dimension>(m: &TMat<N, R, C>) -> N
-    where DefaultAllocator: Alloc<N, R, C> {
+where DefaultAllocator: Alloc<N, R, C> {
     m.iter().fold(N::zero(), |x, y| x + *y)
 }
 
@@ -49,7 +49,7 @@ pub fn comp_add<N: Number, R: Dimension, C: Dimension>(m: &TMat<N, R, C>) -> N
 /// * [`max3`](fn.max3.html)
 /// * [`max4`](fn.max4.html)
 pub fn comp_max<N: Number, R: Dimension, C: Dimension>(m: &TMat<N, R, C>) -> N
-    where DefaultAllocator: Alloc<N, R, C> {
+where DefaultAllocator: Alloc<N, R, C> {
     m.iter().fold(N::min_value(), |x, y| na::sup(&x, y))
 }
 
@@ -76,7 +76,7 @@ pub fn comp_max<N: Number, R: Dimension, C: Dimension>(m: &TMat<N, R, C>) -> N
 /// * [`min3`](fn.min3.html)
 /// * [`min4`](fn.min4.html)
 pub fn comp_min<N: Number, R: Dimension, C: Dimension>(m: &TMat<N, R, C>) -> N
-    where DefaultAllocator: Alloc<N, R, C> {
+where DefaultAllocator: Alloc<N, R, C> {
     m.iter().fold(N::max_value(), |x, y| na::inf(&x, y))
 }
 
@@ -99,7 +99,7 @@ pub fn comp_min<N: Number, R: Dimension, C: Dimension>(m: &TMat<N, R, C>) -> N
 /// * [`comp_max`](fn.comp_max.html)
 /// * [`comp_min`](fn.comp_min.html)
 pub fn comp_mul<N: Number, R: Dimension, C: Dimension>(m: &TMat<N, R, C>) -> N
-    where DefaultAllocator: Alloc<N, R, C> {
+where DefaultAllocator: Alloc<N, R, C> {
     m.iter().fold(N::one(), |x, y| x * *y)
 }
 

nalgebra-glm/src/gtx/exterior_product.rs

@@ -1,7 +1,7 @@
-use traits::Number;
 use aliases::TVec2;
+use traits::Number;
 
 /// The 2D perpendicular product between two vectors.
 pub fn cross2d<N: Number>(v: &TVec2<N>, u: &TVec2<N>) -> N {
     v.perp(u)
-}
+}

nalgebra-glm/src/gtx/handed_coordinate_space.rs

@@ -1,5 +1,5 @@
-use traits::Number;
 use aliases::TVec3;
+use traits::Number;
 
 /// Returns `true` if `{a, b, c}` forms a left-handed trihedron.
 ///

nalgebra-glm/src/gtx/matrix_operation.rs

@@ -1,5 +1,7 @@
+use aliases::{
+    TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4, TMat4, TMat4x2, TMat4x3, TVec2, TVec3, TVec4,
+};
 use traits::Number;
-use aliases::{TVec2, TVec3, TVec4, TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4, TMat4, TMat4x2, TMat4x3};
 
 /// Builds a 2x2 diagonal matrix.
 ///

nalgebra-glm/src/gtx/mod.rs

@@ -1,25 +1,37 @@
 //! (Reexported) Experimental features not specified by GLSL specification.
 
-
 pub use self::component_wise::{comp_add, comp_max, comp_min, comp_mul};
 //pub use self::euler_angles::*;
-pub use self::exterior_product::{cross2d};
+pub use self::exterior_product::cross2d;
 pub use self::handed_coordinate_space::{left_handed, right_handed};
 pub use self::matrix_cross_product::{matrix_cross, matrix_cross3};
-pub use self::matrix_operation::{diagonal2x2, diagonal2x3, diagonal2x4, diagonal3x2, diagonal3x3, diagonal3x4, diagonal4x2, diagonal4x3, diagonal4x4};
+pub use self::matrix_operation::{
+    diagonal2x2, diagonal2x3, diagonal2x4, diagonal3x2, diagonal3x3, diagonal3x4, diagonal4x2,
+    diagonal4x3, diagonal4x4,
+};
 pub use self::norm::{distance2, l1_distance, l1_norm, l2_distance, l2_norm, length2, magnitude2};
-pub use self::normal::{triangle_normal};
+pub use self::normal::triangle_normal;
 pub use self::normalize_dot::{fast_normalize_dot, normalize_dot};
+pub use self::quaternion::{
+    mat3_to_quat, quat_cross_vec, quat_extract_real_component, quat_fast_mix, quat_identity,
+    quat_inv_cross_vec, quat_length2, quat_magnitude2, quat_rotate_vec, quat_rotate_vec3,
+    quat_rotation, quat_short_mix, quat_to_mat3, quat_to_mat4, to_quat,
+};
 pub use self::rotate_normalized_axis::{quat_rotate_normalized_axis, rotate_normalized_axis};
-pub use self::rotate_vector::{orientation, rotate_vec2, rotate_vec3, rotate_vec4, rotate_x_vec4, rotate_x_vec3, rotate_y_vec4, rotate_y_vec3, rotate_z_vec4, rotate_z_vec3, slerp};
-pub use self::transform::{rotation, scaling, translation, rotation2d, scaling2d, translation2d};
-pub use self::transform2::{proj, proj2d, reflect, reflect2d, scale_bias, scale_bias_matrix, shear2d_x, shear_x, shear_y, shear2d_y, shear_z};
+pub use self::rotate_vector::{
+    orientation, rotate_vec2, rotate_vec3, rotate_vec4, rotate_x_vec3, rotate_x_vec4,
+    rotate_y_vec3, rotate_y_vec4, rotate_z_vec3, rotate_z_vec4, slerp,
+};
+pub use self::transform::{rotation, rotation2d, scaling, scaling2d, translation, translation2d};
+pub use self::transform2::{
+    proj, proj2d, reflect, reflect2d, scale_bias, scale_bias_matrix, shear2d_x, shear2d_y, shear_x,
+    shear_y, shear_z,
+};
 pub use self::transform2d::{rotate2d, scale2d, translate2d};
-pub use self::vector_angle::{angle};
-pub use self::vector_query::{are_collinear, are_collinear2d, are_orthogonal, is_comp_null, is_normalized, is_null};
-pub use self::quaternion::{quat_to_mat3, quat_rotate_vec, quat_cross_vec, mat3_to_quat, quat_extract_real_component, quat_fast_mix, quat_inv_cross_vec, quat_length2, quat_magnitude2, quat_identity, quat_rotate_vec3, quat_rotation, quat_short_mix, quat_to_mat4, to_quat};
-
-
+pub use self::vector_angle::angle;
+pub use self::vector_query::{
+    are_collinear, are_collinear2d, are_orthogonal, is_comp_null, is_normalized, is_null,
+};
 
 mod component_wise;
 //mod euler_angles;
@@ -30,6 +42,7 @@ mod matrix_operation;
 mod norm;
 mod normal;
 mod normalize_dot;
+mod quaternion;
 mod rotate_normalized_axis;
 mod rotate_vector;
 mod transform;
@@ -37,4 +50,3 @@ mod transform2;
 mod transform2d;
 mod vector_angle;
 mod vector_query;
-mod quaternion;

nalgebra-glm/src/gtx/norm.rs

@@ -1,7 +1,7 @@
-use na::{Real, DefaultAllocator};
+use na::{DefaultAllocator, Real};
 
-use traits::{Alloc, Dimension};
 use aliases::TVec;
+use traits::{Alloc, Dimension};
 
 /// The squared distance between two points.
 ///
@@ -9,7 +9,7 @@ use aliases::TVec;
 ///
 /// * [`distance`](fn.distance.html)
 pub fn distance2<N: Real, D: Dimension>(p0: &TVec<N, D>, p1: &TVec<N, D>) -> N
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     (p1 - p0).norm_squared()
 }
 
@@ -21,7 +21,7 @@ pub fn distance2<N: Real, D: Dimension>(p0: &TVec<N, D>, p1: &TVec<N, D>) -> N
 /// * [`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
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     l1_norm(&(y - x))
 }
 
@@ -36,7 +36,7 @@ pub fn l1_distance<N: Real, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
 /// * [`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
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     ::comp_add(&v.abs())
 }
 
@@ -55,7 +55,7 @@ pub fn l1_norm<N: Real, D: Dimension>(v: &TVec<N, D>) -> N
 /// * [`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
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     l2_norm(&(y - x))
 }
 
@@ -76,7 +76,7 @@ pub fn l2_distance<N: Real, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`magnitude2`](fn.magnitude2.html)
 pub fn l2_norm<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.norm()
 }
 
@@ -92,7 +92,7 @@ pub fn l2_norm<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`magnitude2`](fn.magnitude2.html)
 pub fn length2<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.norm_squared()
 }
 
@@ -108,7 +108,7 @@ pub fn length2<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
 /// * [`magnitude`](fn.magnitude.html)
 /// * [`nalgebra::norm_squared`](../nalgebra/fn.norm_squared.html)
 pub fn magnitude2<N: Real, D: Dimension>(x: &TVec<N, D>) -> N
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.norm_squared()
 }
 

nalgebra-glm/src/gtx/normal.rs

@@ -7,4 +7,4 @@ use aliases::TVec3;
 /// 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> {
     (p2 - p1).cross(&(p3 - p1)).normalize()
-}
+}

nalgebra-glm/src/gtx/normalize_dot.rs

@@ -1,7 +1,7 @@
-use na::{Real, DefaultAllocator};
+use na::{DefaultAllocator, Real};
 
-use traits::{Dimension, Alloc};
 use aliases::TVec;
+use traits::{Alloc, Dimension};
 
 /// The dot product of the normalized version of `x` and `y`.
 ///
@@ -11,7 +11,7 @@ use aliases::TVec;
 ///
 /// * [`normalize_dot`](fn.normalize_dot.html`)
 pub fn fast_normalize_dot<N: Real, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     // XXX: improve those.
     x.normalize().dot(&y.normalize())
 }
@@ -22,7 +22,7 @@ pub fn fast_normalize_dot<N: Real, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>)
 ///
 /// * [`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
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     // XXX: improve those.
     x.normalize().dot(&y.normalize())
 }

nalgebra-glm/src/gtx/quaternion.rs

@@ -1,4 +1,4 @@
-use na::{Real, Unit, Rotation3, UnitQuaternion, U3};
+use na::{Real, Rotation3, Unit, UnitQuaternion, U3};
 
 use aliases::{Qua, TMat3, TMat4, TVec3, TVec4};
 
@@ -19,7 +19,9 @@ pub fn quat_extract_real_component<N: Real>(q: &Qua<N>) -> N {
 
 /// Normalized linear interpolation between two quaternions.
 pub fn quat_fast_mix<N: Real>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
-    Unit::new_unchecked(*x).nlerp(&Unit::new_unchecked(*y), a).unwrap()
+    Unit::new_unchecked(*x)
+        .nlerp(&Unit::new_unchecked(*y), a)
+        .unwrap()
 }
 
 //pub fn quat_intermediate<N: Real>(prev: &Qua<N>, curr: &Qua<N>, next: &Qua<N>) -> Qua<N> {
@@ -54,12 +56,16 @@ pub fn quat_rotate_vec<N: Real>(q: &Qua<N>, v: &TVec4<N>) -> TVec4<N> {
 
 /// The rotation required to align `orig` to `dest`.
 pub fn quat_rotation<N: Real>(orig: &TVec3<N>, dest: &TVec3<N>) -> Qua<N> {
-    UnitQuaternion::rotation_between(orig, dest).unwrap_or_else(UnitQuaternion::identity).unwrap()
+    UnitQuaternion::rotation_between(orig, dest)
+        .unwrap_or_else(UnitQuaternion::identity)
+        .unwrap()
 }
 
 /// The spherical linear interpolation between two quaternions.
 pub fn quat_short_mix<N: Real>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
-    Unit::new_normalize(*x).slerp(&Unit::new_normalize(*y), a).unwrap()
+    Unit::new_normalize(*x)
+        .slerp(&Unit::new_normalize(*y), a)
+        .unwrap()
 }
 
 //pub fn quat_squad<N: Real>(q1: &Qua<N>, q2: &Qua<N>, s1: &Qua<N>, s2: &Qua<N>, h: N) -> Qua<N> {
@@ -68,7 +74,9 @@ pub fn quat_short_mix<N: Real>(x: &Qua<N>, y: &Qua<N>, a: N) -> Qua<N> {
 
 /// Converts a quaternion to a rotation matrix.
 pub fn quat_to_mat3<N: Real>(x: &Qua<N>) -> TMat3<N> {
-    UnitQuaternion::new_unchecked(*x).to_rotation_matrix().unwrap()
+    UnitQuaternion::new_unchecked(*x)
+        .to_rotation_matrix()
+        .unwrap()
 }
 
 /// Converts a quaternion to a rotation matrix in homogenous coordinates.
@@ -87,4 +95,3 @@ pub fn to_quat<N: Real>(x: &TMat4<N>) -> Qua<N> {
     let rot = x.fixed_slice::<U3, U3>(0, 0).into_owned();
     mat3_to_quat(&rot)
 }
-

nalgebra-glm/src/gtx/rotate_vector.rs

@@ -1,6 +1,6 @@
 use na::{Real, Rotation3, Unit, UnitComplex};
 
-use aliases::{TVec2, TVec3, TVec4, TMat4};
+use 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> {
@@ -58,5 +58,7 @@ pub fn rotate_z_vec4<N: Real>(v: &TVec4<N>, angle: N) -> TVec4<N> {
 
 /// 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> {
-    Unit::new_unchecked(*x).slerp(&Unit::new_unchecked(*y), a).unwrap()
+    Unit::new_unchecked(*x)
+        .slerp(&Unit::new_unchecked(*y), a)
+        .unwrap()
 }

nalgebra-glm/src/gtx/transform.rs

@@ -1,7 +1,7 @@
-use na::{Real, Unit, Rotation2, Rotation3};
+use na::{Real, Rotation2, Rotation3, Unit};
 
+use aliases::{TMat3, TMat4, TVec2, TVec3};
 use traits::Number;
-use aliases::{TVec3, TVec2, TMat3, TMat4};
 
 /// A rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in radians.
 ///
@@ -42,7 +42,6 @@ pub fn translation<N: Number>(v: &TVec3<N>) -> TMat4<N> {
     TMat4::new_translation(v)
 }
 
-
 /// A rotation 3 * 3 matrix created from an angle expressed in radians.
 ///
 /// # See also:

nalgebra-glm/src/gtx/transform2.rs

@@ -1,7 +1,7 @@
 use na::{U2, U3};
 
+use aliases::{TMat3, TMat4, TVec2, TVec3};
 use traits::Number;
-use aliases::{TVec2, TVec3, TMat3, TMat4};
 
 /// 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> {
@@ -57,10 +57,7 @@ pub fn scale_bias_matrix<N: Number>(scale: N, bias: N) -> TMat4<N> {
     let _1 = N::one();
 
     TMat4::new(
-        scale, _0, _0, bias,
-        _0, scale, _0, bias,
-        _0, _0, scale, bias,
-        _0, _0, _0, _1,
+        scale, _0, _0, bias, _0, scale, _0, bias, _0, _0, scale, bias, _0, _0, _0, _1,
     )
 }
 
@@ -74,11 +71,7 @@ pub fn shear2d_x<N: Number>(m: &TMat3<N>, y: N) -> TMat3<N> {
     let _0 = N::zero();
     let _1 = N::one();
 
-    let shear = TMat3::new(
-        _1,  y, _0,
-        _0, _1, _0,
-        _0, _0, _1
-    );
+    let shear = TMat3::new(_1, y, _0, _0, _1, _0, _0, _0, _1);
     m * shear
 }
 
@@ -86,12 +79,7 @@ pub fn shear2d_x<N: Number>(m: &TMat3<N>, y: N) -> TMat3<N> {
 pub fn shear_x<N: Number>(m: &TMat4<N>, y: N, z: N) -> TMat4<N> {
     let _0 = N::zero();
     let _1 = N::one();
-    let shear = TMat4::new(
-        _1, _0, _0, _0,
-         y, _1, _0, _0,
-         z, _0, _1, _0,
-        _0, _0, _0, _1,
-    );
+    let shear = TMat4::new(_1, _0, _0, _0, y, _1, _0, _0, z, _0, _1, _0, _0, _0, _0, _1);
 
     m * shear
 }
@@ -101,11 +89,7 @@ pub fn shear2d_y<N: Number>(m: &TMat3<N>, x: N) -> TMat3<N> {
     let _0 = N::zero();
     let _1 = N::one();
 
-    let shear = TMat3::new(
-        _1, _0, _0,
-        x, _1, _0,
-        _0, _0, _1
-    );
+    let shear = TMat3::new(_1, _0, _0, x, _1, _0, _0, _0, _1);
     m * shear
 }
 
@@ -113,12 +97,7 @@ pub fn shear2d_y<N: Number>(m: &TMat3<N>, x: N) -> TMat3<N> {
 pub fn shear_y<N: Number>(m: &TMat4<N>, x: N, z: N) -> TMat4<N> {
     let _0 = N::zero();
     let _1 = N::one();
-    let shear = TMat4::new(
-        _1,  x, _0, _0,
-        _0, _1, _0, _0,
-        _0,  z, _1, _0,
-        _0, _0, _0, _1,
-    );
+    let shear = TMat4::new(_1, x, _0, _0, _0, _1, _0, _0, _0, z, _1, _0, _0, _0, _0, _1);
 
     m * shear
 }
@@ -127,12 +106,7 @@ pub fn shear_y<N: Number>(m: &TMat4<N>, x: N, z: N) -> TMat4<N> {
 pub fn shear_z<N: Number>(m: &TMat4<N>, x: N, y: N) -> TMat4<N> {
     let _0 = N::zero();
     let _1 = N::one();
-    let shear = TMat4::new(
-        _1, _0,  x, _0,
-        _0, _1,  y, _0,
-        _0, _0, _1, _0,
-        _0, _0, _0, _1,
-    );
+    let shear = TMat4::new(_1, _0, x, _0, _0, _1, y, _0, _0, _0, _1, _0, _0, _0, _0, _1);
 
     m * shear
 }

nalgebra-glm/src/gtx/transform2d.rs

@@ -1,7 +1,7 @@
 use na::{Real, UnitComplex};
 
-use traits::Number;
 use aliases::{TMat3, TVec2};
+use traits::Number;
 
 /// Builds a 2D rotation matrix from an angle and right-multiply it to `m`.
 ///

nalgebra-glm/src/gtx/vector_angle.rs

@@ -1,12 +1,11 @@
 use na::{DefaultAllocator, Real};
 
-use traits::{Dimension, Alloc};
 use aliases::TVec;
-
+use traits::{Alloc, Dimension};
 
 /// The angle between two vectors.
 pub fn angle<N: Real, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> N
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.angle(y)
 }
 

nalgebra-glm/src/gtx/vector_query.rs

@@ -1,7 +1,7 @@
-use na::{Real, DefaultAllocator};
+use na::{DefaultAllocator, Real};
 
-use traits::{Number, Dimension, Alloc};
 use aliases::{TVec, TVec2, TVec3};
+use traits::{Alloc, Dimension, Number};
 
 /// Returns `true` if two vectors are collinear (up to an epsilon).
 ///
@@ -22,8 +22,14 @@ pub fn are_collinear2d<N: Number>(v0: &TVec2<N>, v1: &TVec2<N>, epsilon: N) -> b
 }
 
 /// Returns `true` if two vectors are orthogonal (up to an epsilon).
-pub fn are_orthogonal<N: Number, D: Dimension>(v0: &TVec<N, D>, v1: &TVec<N, D>, epsilon: N) -> bool
-    where DefaultAllocator: Alloc<N, D> {
+pub fn are_orthogonal<N: Number, D: Dimension>(
+    v0: &TVec<N, D>,
+    v1: &TVec<N, D>,
+    epsilon: N,
+) -> bool
+where
+    DefaultAllocator: Alloc<N, D>,
+{
     abs_diff_eq!(v0.dot(v1), N::zero(), epsilon = epsilon)
 }
 
@@ -34,18 +40,18 @@ pub fn are_orthogonal<N: Number, D: Dimension>(v0: &TVec<N, D>, v1: &TVec<N, D>,
 
 /// Returns `true` if all the components of `v` are zero (up to an epsilon).
 pub fn is_comp_null<N: Number, D: Dimension>(v: &TVec<N, D>, epsilon: N) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     v.map(|x| abs_diff_eq!(x, N::zero(), epsilon = epsilon))
 }
 
 /// 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
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     abs_diff_eq!(v.norm_squared(), N::one(), epsilon = epsilon * epsilon)
 }
 
 /// Returns `true` if `v` is zero (up to an epsilon).
 pub fn is_null<N: Number, D: Dimension>(v: &TVec<N, D>, epsilon: N) -> bool
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     abs_diff_eq!(*v, TVec::<N, D>::zeros(), epsilon = epsilon)
 }

nalgebra-glm/src/lib.rs

@@ -1,114 +1,114 @@
 /*! # nalgebra-glm − nalgebra in _easy mode_
-    **nalgebra-glm** is a GLM-like interface for the **nalgebra** general-purpose linear algebra library.
-    [GLM](https://glm.g-truc.net) itself is a popular C++ linear algebra library essentially targeting computer graphics. Therefore
-    **nalgebra-glm** draws inspiration from GLM to define a nice and easy-to-use API for simple graphics application.
+   **nalgebra-glm** is a GLM-like interface for the **nalgebra** general-purpose linear algebra library.
+   [GLM](https://glm.g-truc.net) itself is a popular C++ linear algebra library essentially targeting computer graphics. Therefore
+   **nalgebra-glm** draws inspiration from GLM to define a nice and easy-to-use API for simple graphics application.
 
-    All the types of **nalgebra-glm** are aliases of types from **nalgebra**. Therefore there is a complete and
-    seamless inter-operability between both.
+   All the types of **nalgebra-glm** are aliases of types from **nalgebra**. Therefore there is a complete and
+   seamless inter-operability between both.
 
-    ## Getting started
-    First of all, you should start by taking a look at the official [GLM API documentation](http://glm.g-truc.net/0.9.9/api/index.html)
-    since **nalgebra-glm** implements a large subset of it. To use **nalgebra-glm** to your project, you
-    should add it as a dependency to your `Crates.toml`:
+   ## Getting started
+   First of all, you should start by taking a look at the official [GLM API documentation](http://glm.g-truc.net/0.9.9/api/index.html)
+   since **nalgebra-glm** implements a large subset of it. To use **nalgebra-glm** to your project, you
+   should add it as a dependency to your `Crates.toml`:
 
-    ```toml
-    [dependencies]
-    nalgebra-glm = "0.1"
-    ```
+   ```toml
+   [dependencies]
+   nalgebra-glm = "0.1"
+   ```
 
-    Then, you should add an `extern crate` statement to your `lib.rs` or `main.rs` file. It is **strongly
-    recommended** to add a crate alias to `glm` as well so that you will be able to call functions of
-    **nalgebra-glm** using the module prefix `glm::`. For example you will write `glm::rotate(...)` instead
-    of the more verbose `nalgebra_glm::rotate(...)`:
+   Then, you should add an `extern crate` statement to your `lib.rs` or `main.rs` file. It is **strongly
+   recommended** to add a crate alias to `glm` as well so that you will be able to call functions of
+   **nalgebra-glm** using the module prefix `glm::`. For example you will write `glm::rotate(...)` instead
+   of the more verbose `nalgebra_glm::rotate(...)`:
 
-    ```rust
-    extern crate nalgebra_glm as glm;
-    ```
+   ```rust
+   extern crate nalgebra_glm as glm;
+   ```
 
-    ## Features overview
-    **nalgebra-glm** supports most linear-algebra related features of the C++ GLM library. Mathematically
-    speaking, it supports all the common transformations like rotations, translations, scaling, shearing,
-    and projections but operating in homogeneous coordinates. This means all the 2D transformations are
-    expressed as 3x3 matrices, and all the 3D transformations as 4x4 matrices. This is less computationally-efficient
-    and memory-efficient than nalgebra's [transformation types](https://www.nalgebra.org/points_and_transformations/#transformations),
-    but this has the benefit of being simpler to use.
-    ### Main differences compared to GLM
-    While **nalgebra-glm** follows the feature line of the C++ GLM library, quite a few differences
-    remain and they are mostly syntactic. The main ones are:
-    * All function names use `snake_case`, which is the Rust convention.
-    * All type names use `CamelCase`, which is the Rust convention.
-    * All function arguments, except for scalars, are all passed by-reference.
-    * The most generic vector and matrix types are [`TMat`](type.TMat.html) and [`TVec`](type.TVec.html) instead of `mat` and `vec`.
-    * Some feature are not yet implemented and should be added in the future. In particular, no packing
-    functions are available.
-    * A few features are not implemented and will never be. This includes functions related to color
-    spaces, and closest points computations. Other crates should be used for those. For example, closest
-    points computation can be handled by the [ncollide](https://ncollide.org) project.
+   ## Features overview
+   **nalgebra-glm** supports most linear-algebra related features of the C++ GLM library. Mathematically
+   speaking, it supports all the common transformations like rotations, translations, scaling, shearing,
+   and projections but operating in homogeneous coordinates. This means all the 2D transformations are
+   expressed as 3x3 matrices, and all the 3D transformations as 4x4 matrices. This is less computationally-efficient
+   and memory-efficient than nalgebra's [transformation types](https://www.nalgebra.org/points_and_transformations/#transformations),
+   but this has the benefit of being simpler to use.
+   ### Main differences compared to GLM
+   While **nalgebra-glm** follows the feature line of the C++ GLM library, quite a few differences
+   remain and they are mostly syntactic. The main ones are:
+   * All function names use `snake_case`, which is the Rust convention.
+   * All type names use `CamelCase`, which is the Rust convention.
+   * All function arguments, except for scalars, are all passed by-reference.
+   * The most generic vector and matrix types are [`TMat`](type.TMat.html) and [`TVec`](type.TVec.html) instead of `mat` and `vec`.
+   * Some feature are not yet implemented and should be added in the future. In particular, no packing
+   functions are available.
+   * A few features are not implemented and will never be. This includes functions related to color
+   spaces, and closest points computations. Other crates should be used for those. For example, closest
+   points computation can be handled by the [ncollide](https://ncollide.org) project.
 
-    In addition, because Rust does not allows function overloading, all functions must be given a unique name.
-    Here are a few rules chosen arbitrarily for **nalgebra-glm**:
-    * Functions operating in 2d will usually end with the `2d` suffix, e.g., [`glm::rotate2d`](fn.rotate2d.html) is for 2D while [`glm::rotate`](fn.rotate.html) is for 3D.
-    * Functions operating on vectors will often end with the `_vec` suffix, possibly followed by the dimension of vector, e.g., [`glm::rotate_vec2`](fn.rotate_vec2.html).
-    * Every function related to quaternions start with the `quat_` prefix, e.g., [`glm::quat_dot(q1, q2)`](fn.quat_dot.html).
-    * All the conversion functions have unique names as described [below](#conversions).
-    ### Vector and matrix construction
-    Vectors, matrices, and quaternions can be constructed using several approaches:
-    * Using functions with the same name as their type in lower-case. For example [`glm::vec3(x, y, z)`](fn.vec3.html) will create a 3D vector.
-    * Using the `::new` constructor. For example [`Vec3::new(x, y, z)`](../nalgebra/base/type.MatrixMN.html#method.new-27) will create a 3D vector.
-    * Using the functions prefixed by `make_` to build a vector a matrix from a slice. For example [`glm::make_vec3(&[x, y, z])`](fn.make_vec3.html) will create a 3D vector.
-    Keep in mind that constructing a matrix using this type of functions require its components to be arranged in column-major order on the slice.
-    * Using a geometric construction function. For example [`glm::rotation(angle, axis)`](fn.rotation.html) will build a 4x4 homogeneous rotation matrix from an angle (in radians) and an axis.
-    * Using swizzling and conversions as described in the next sections.
-    ### Swizzling
-    Vector swizzling is a native feature of **nalgebra** itself. Therefore, you can use it with all
-    the vectors of **nalgebra-glm** as well. Swizzling is supported as methods and works only up to
-    dimension 3, i.e., you can only refer to the components `x`, `y` and `z` and can only create a
-    2D or 3D vector using this technique. Here is some examples, assuming `v` is a vector with float
-    components here:
-    * `v.xx()` is equivalent to `glm::vec2(v.x, v.x)` and to `Vec2::new(v.x, v.x)`.
-    * `v.zx()` is equivalent to `glm::vec2(v.z, v.x)` and to `Vec2::new(v.z, v.x)`.
-    * `v.yxz()` is equivalent to `glm::vec3(v.y, v.x, v.z)` and to `Vec3::new(v.y, v.x, v.z)`.
-    * `v.zzy()` is equivalent to `glm::vec3(v.z, v.z, v.y)` and to `Vec3::new(v.z, v.z, v.y)`.
+   In addition, because Rust does not allows function overloading, all functions must be given a unique name.
+   Here are a few rules chosen arbitrarily for **nalgebra-glm**:
+   * Functions operating in 2d will usually end with the `2d` suffix, e.g., [`glm::rotate2d`](fn.rotate2d.html) is for 2D while [`glm::rotate`](fn.rotate.html) is for 3D.
+   * Functions operating on vectors will often end with the `_vec` suffix, possibly followed by the dimension of vector, e.g., [`glm::rotate_vec2`](fn.rotate_vec2.html).
+   * Every function related to quaternions start with the `quat_` prefix, e.g., [`glm::quat_dot(q1, q2)`](fn.quat_dot.html).
+   * All the conversion functions have unique names as described [below](#conversions).
+   ### Vector and matrix construction
+   Vectors, matrices, and quaternions can be constructed using several approaches:
+   * Using functions with the same name as their type in lower-case. For example [`glm::vec3(x, y, z)`](fn.vec3.html) will create a 3D vector.
+   * Using the `::new` constructor. For example [`Vec3::new(x, y, z)`](../nalgebra/base/type.MatrixMN.html#method.new-27) will create a 3D vector.
+   * Using the functions prefixed by `make_` to build a vector a matrix from a slice. For example [`glm::make_vec3(&[x, y, z])`](fn.make_vec3.html) will create a 3D vector.
+   Keep in mind that constructing a matrix using this type of functions require its components to be arranged in column-major order on the slice.
+   * Using a geometric construction function. For example [`glm::rotation(angle, axis)`](fn.rotation.html) will build a 4x4 homogeneous rotation matrix from an angle (in radians) and an axis.
+   * Using swizzling and conversions as described in the next sections.
+   ### Swizzling
+   Vector swizzling is a native feature of **nalgebra** itself. Therefore, you can use it with all
+   the vectors of **nalgebra-glm** as well. Swizzling is supported as methods and works only up to
+   dimension 3, i.e., you can only refer to the components `x`, `y` and `z` and can only create a
+   2D or 3D vector using this technique. Here is some examples, assuming `v` is a vector with float
+   components here:
+   * `v.xx()` is equivalent to `glm::vec2(v.x, v.x)` and to `Vec2::new(v.x, v.x)`.
+   * `v.zx()` is equivalent to `glm::vec2(v.z, v.x)` and to `Vec2::new(v.z, v.x)`.
+   * `v.yxz()` is equivalent to `glm::vec3(v.y, v.x, v.z)` and to `Vec3::new(v.y, v.x, v.z)`.
+   * `v.zzy()` is equivalent to `glm::vec3(v.z, v.z, v.y)` and to `Vec3::new(v.z, v.z, v.y)`.
 
-    Any combination of two or three components picked among `x`, `y`, and `z` will work.
-    ### Conversions
-    It is often useful to convert one algebraic type to another. There are two main approaches for converting
-    between types in `nalgebra-glm`:
-    * Using function with the form `type1_to_type2` in order to convert an instance of `type1` into an instance of `type2`.
-    For example [`glm::mat3_to_mat4(m)`](fn.mat3_to_mat4.html) will convert the 3x3 matrix `m` to a 4x4 matrix by appending one column on the right
-    and one row on the left. Those now row and columns are filled with 0 except for the diagonal element which is set to 1.
-    * Using one of the [`convert`](fn.convert.html), [`try_convert`](fn.try_convert.html), or [`convert_unchecked`](fn.convert_unchecked.html) functions.
-    These functions are directly re-exported from nalgebra and are extremely versatile:
-        1. The `convert` function can convert any type (especially geometric types from nalgebra like `Isometry3`) into another algebraic type which is equivalent but more general. For example,
-    `let sim: Similarity3<_> = na::convert(isometry)` will convert an `Isometry3` into a `Similarity3`.
-    In addition, `let mat: Mat4 = glm::convert(isometry)` will convert an `Isometry3` to a 4x4 matrix. This will also convert the scalar types,
-    therefore: `let mat: DMat4 = glm::convert(m)` where `m: Mat4` will work. However, conversion will not work the other way round: you
-    can't convert a `Matrix4` to an `Isometry3` using `glm::convert` because that could cause unexpected results if the matrix does
-    not complies to the requirements of the isometry.
-        2. If you need this kind of conversions anyway, you can use `try_convert` which will test if the object being converted complies with the algebraic requirements of the target type.
-        This will return `None` if the requirements are not satisfied.
-        3. The `convert_unchecked` will ignore those tests and always perform the conversion, even if that breaks the invariants of the target type.
-        This must be used with care! This is actually the recommended method to convert between homogeneous transformations generated by `nalgebra-glm` and
-        specific transformation types from **nalgebra** like `Isometry3`. Just be careful you know your conversions make sense.
+   Any combination of two or three components picked among `x`, `y`, and `z` will work.
+   ### Conversions
+   It is often useful to convert one algebraic type to another. There are two main approaches for converting
+   between types in `nalgebra-glm`:
+   * Using function with the form `type1_to_type2` in order to convert an instance of `type1` into an instance of `type2`.
+   For example [`glm::mat3_to_mat4(m)`](fn.mat3_to_mat4.html) will convert the 3x3 matrix `m` to a 4x4 matrix by appending one column on the right
+   and one row on the left. Those now row and columns are filled with 0 except for the diagonal element which is set to 1.
+   * Using one of the [`convert`](fn.convert.html), [`try_convert`](fn.try_convert.html), or [`convert_unchecked`](fn.convert_unchecked.html) functions.
+   These functions are directly re-exported from nalgebra and are extremely versatile:
+       1. The `convert` function can convert any type (especially geometric types from nalgebra like `Isometry3`) into another algebraic type which is equivalent but more general. For example,
+   `let sim: Similarity3<_> = na::convert(isometry)` will convert an `Isometry3` into a `Similarity3`.
+   In addition, `let mat: Mat4 = glm::convert(isometry)` will convert an `Isometry3` to a 4x4 matrix. This will also convert the scalar types,
+   therefore: `let mat: DMat4 = glm::convert(m)` where `m: Mat4` will work. However, conversion will not work the other way round: you
+   can't convert a `Matrix4` to an `Isometry3` using `glm::convert` because that could cause unexpected results if the matrix does
+   not complies to the requirements of the isometry.
+       2. If you need this kind of conversions anyway, you can use `try_convert` which will test if the object being converted complies with the algebraic requirements of the target type.
+       This will return `None` if the requirements are not satisfied.
+       3. The `convert_unchecked` will ignore those tests and always perform the conversion, even if that breaks the invariants of the target type.
+       This must be used with care! This is actually the recommended method to convert between homogeneous transformations generated by `nalgebra-glm` and
+       specific transformation types from **nalgebra** like `Isometry3`. Just be careful you know your conversions make sense.
 
-    ### Should I use nalgebra or nalgebra-glm?
-    Well that depends on your tastes and your background. **nalgebra** is more powerful overall since it allows stronger typing,
-    and goes much further than simple computer graphics math. However, has a bit of a learning curve for
-    those not used to the abstract mathematical concepts for transformations. **nalgebra-glm** however
-    have more straightforward functions and benefit from the various tutorials existing on the internet
-    for the original C++ GLM library.
+   ### Should I use nalgebra or nalgebra-glm?
+   Well that depends on your tastes and your background. **nalgebra** is more powerful overall since it allows stronger typing,
+   and goes much further than simple computer graphics math. However, has a bit of a learning curve for
+   those not used to the abstract mathematical concepts for transformations. **nalgebra-glm** however
+   have more straightforward functions and benefit from the various tutorials existing on the internet
+   for the original C++ GLM library.
 
-    Overall, if you are already used to the C++ GLM library, or to working with homogeneous coordinates (like 4D
-    matrices for 3D transformations), then you will have more success with **nalgebra-glm**. If on the other
-    hand you prefer more rigorous treatments of transformations, with type-level restrictions, then go for **nalgebra**.
-    If you need dynamically-sized matrices, you should go for **nalgebra** as well.
+   Overall, if you are already used to the C++ GLM library, or to working with homogeneous coordinates (like 4D
+   matrices for 3D transformations), then you will have more success with **nalgebra-glm**. If on the other
+   hand you prefer more rigorous treatments of transformations, with type-level restrictions, then go for **nalgebra**.
+   If you need dynamically-sized matrices, you should go for **nalgebra** as well.
 
-    Keep in mind that **nalgebra-glm** is just a different API for **nalgebra**. So you can very well use both
-    and benefit from both their advantages: use **nalgebra-glm** when mathematical rigor is not that important,
-    and **nalgebra** itself when you need more expressive types, and more powerful linear algebra operations like
-    matrix factorizations and slicing. Just remember that all the **nalgebra-glm** types are just aliases to **nalgebra** types,
-    and keep in mind it is possible to convert, e.g., an `Isometry3` to a `Mat4` and vice-versa (see the [conversions section](#conversions)).
- */
+   Keep in mind that **nalgebra-glm** is just a different API for **nalgebra**. So you can very well use both
+   and benefit from both their advantages: use **nalgebra-glm** when mathematical rigor is not that important,
+   and **nalgebra** itself when you need more expressive types, and more powerful linear algebra operations like
+   matrix factorizations and slicing. Just remember that all the **nalgebra-glm** types are just aliases to **nalgebra** types,
+   and keep in mind it is possible to convert, e.g., an `Isometry3` to a `Mat4` and vice-versa (see the [conversions section](#conversions)).
+*/
 
 #![doc(html_favicon_url = "http://nalgebra.org/img/favicon.ico")]
 
@@ -119,68 +119,82 @@ extern crate alga;
 extern crate nalgebra as na;
 
 pub use 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,
+    int_bits_to_float_vec, mix, modf, modf_vec, round, sign, smoothstep, step, step_scalar,
+    step_vec, trunc, uint_bits_to_float, uint_bits_to_float_scalar,
+};
 pub use constructors::*;
-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, int_bits_to_float_vec, mix, modf, modf_vec, round, sign, smoothstep, step, step_scalar, step_vec, trunc, uint_bits_to_float, uint_bits_to_float_scalar};
-pub use geometric::{reflect_vec, cross, distance, dot, faceforward, length, magnitude, normalize, refract_vec};
-pub use matrix::{transpose, determinant, inverse, matrix_comp_mult, outer_product};
-pub use traits::{Dimension, Number, Alloc};
-pub use trigonometric::{acos, acosh, asin, asinh, atan, atan2, atanh, cos, cosh, degrees, radians, sin, sinh, tan, tanh};
-pub use vector_relational::{all, any, equal, greater_than, greater_than_equal, less_than, less_than_equal, not, not_equal};
 pub use exponential::{exp, exp2, inversesqrt, log, log2, pow, sqrt};
+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 trigonometric::{
+    acos, acosh, asin, asinh, atan, atan2, atanh, cos, cosh, degrees, radians, sin, sinh, tan, tanh,
+};
+pub use vector_relational::{
+    all, any, equal, greater_than, greater_than_equal, less_than, less_than_equal, not, not_equal,
+};
 
-pub use gtx::{
-    comp_add, comp_max, comp_min, comp_mul,
-    cross2d,
-    left_handed, right_handed,
-    matrix_cross, matrix_cross3,
-    diagonal2x2, diagonal2x3, diagonal2x4, diagonal3x2, diagonal3x3, diagonal3x4, diagonal4x2, diagonal4x3, diagonal4x4,
-    distance2, l1_distance, l1_norm, l2_distance, l2_norm, length2, magnitude2,
-    triangle_normal,
-    fast_normalize_dot, normalize_dot,
-    quat_rotate_normalized_axis, rotate_normalized_axis,
-    orientation, rotate_vec2, rotate_vec3, rotate_vec4, rotate_x_vec4, rotate_x_vec3, rotate_y_vec4, rotate_y_vec3, rotate_z_vec4, rotate_z_vec3, slerp,
-    rotation, scaling, translation, rotation2d, scaling2d, translation2d,
-    proj, proj2d, reflect, reflect2d, scale_bias, scale_bias_matrix, shear2d_x, shear_x, shear_y, shear2d_y, shear_z,
-    rotate2d, scale2d, translate2d,
-    angle,
-    are_collinear, are_collinear2d, are_orthogonal, is_comp_null, is_normalized, is_null,
-    quat_to_mat3, quat_rotate_vec, quat_cross_vec, mat3_to_quat, quat_extract_real_component, quat_fast_mix, quat_inv_cross_vec, quat_length2, quat_magnitude2, quat_identity, quat_rotate_vec3, quat_rotation, quat_short_mix, quat_to_mat4, to_quat
+pub use ext::{
+    epsilon, equal_columns, equal_columns_eps, equal_columns_eps_vec, equal_eps, equal_eps_vec,
+    identity, look_at, look_at_lh, look_at_rh, max, max2, max3, max3_scalar, max4, max4_scalar,
+    min, min2, min3, min3_scalar, min4, min4_scalar, not_equal_columns, not_equal_columns_eps,
+    not_equal_columns_eps_vec, not_equal_eps, not_equal_eps_vec, ortho, perspective, pi,
+    pick_matrix, project, project_no, project_zo, quat_angle, quat_angle_axis, quat_axis,
+    quat_conjugate, quat_cross, quat_dot, quat_equal, quat_equal_eps, quat_exp, quat_inverse,
+    quat_length, quat_lerp, quat_log, quat_magnitude, quat_normalize, quat_not_equal,
+    quat_not_equal_eps, quat_pow, quat_rotate, quat_slerp, rotate, rotate_x, rotate_y, rotate_z,
+    scale, translate, unproject, unproject_no, unproject_zo,
 };
 pub use gtc::{
-    e, two_pi, euler, four_over_pi, golden_ratio, half_pi, ln_ln_two, ln_ten, ln_two, one, one_over_pi, one_over_root_two, one_over_two_pi, quarter_pi, root_five, root_half_pi, root_ln_four, root_pi, root_three, root_two, root_two_pi, third, three_over_two_pi, two_over_pi, two_over_root_pi, two_thirds, zero,
-    column, row, set_column, set_row,
-    affine_inverse, inverse_transpose,
-    make_mat2, make_mat2x2, make_mat2x3, make_mat2x4, make_mat3, make_mat3x2, make_mat3x3, make_mat3x4, make_mat4, make_mat4x2, make_mat4x3, make_mat4x4, make_quat, make_vec1, make_vec2, make_vec3, make_vec4, value_ptr, value_ptr_mut, vec1_to_vec2, vec1_to_vec3, vec1_to_vec4, vec2_to_vec1, vec2_to_vec2, vec2_to_vec3, vec2_to_vec4, vec3_to_vec1, vec3_to_vec2, vec3_to_vec3, vec3_to_vec4, vec4_to_vec1, vec4_to_vec2, vec4_to_vec3, vec4_to_vec4, mat2_to_mat3, mat2_to_mat4, mat3_to_mat2, mat3_to_mat4, mat4_to_mat2, mat4_to_mat3,
-    quat_cast, quat_euler_angles, quat_greater_than, quat_greater_than_equal, quat_less_than, quat_less_than_equal, quat_look_at, quat_look_at_lh, quat_look_at_rh, quat_pitch, quat_roll, quat_yaw
+    affine_inverse, column, e, euler, four_over_pi, golden_ratio, half_pi, inverse_transpose,
+    ln_ln_two, ln_ten, ln_two, make_mat2, make_mat2x2, make_mat2x3, make_mat2x4, make_mat3,
+    make_mat3x2, make_mat3x3, make_mat3x4, make_mat4, make_mat4x2, make_mat4x3, make_mat4x4,
+    make_quat, make_vec1, make_vec2, make_vec3, make_vec4, mat2_to_mat3, mat2_to_mat4,
+    mat3_to_mat2, mat3_to_mat4, mat4_to_mat2, mat4_to_mat3, one, one_over_pi, one_over_root_two,
+    one_over_two_pi, quarter_pi, quat_cast, quat_euler_angles, quat_greater_than,
+    quat_greater_than_equal, quat_less_than, quat_less_than_equal, quat_look_at, quat_look_at_lh,
+    quat_look_at_rh, quat_pitch, quat_roll, quat_yaw, root_five, root_half_pi, root_ln_four,
+    root_pi, root_three, root_two, root_two_pi, row, set_column, set_row, third, three_over_two_pi,
+    two_over_pi, two_over_root_pi, two_pi, two_thirds, value_ptr, value_ptr_mut, vec1_to_vec2,
+    vec1_to_vec3, vec1_to_vec4, vec2_to_vec1, vec2_to_vec2, vec2_to_vec3, vec2_to_vec4,
+    vec3_to_vec1, vec3_to_vec2, vec3_to_vec3, vec3_to_vec4, vec4_to_vec1, vec4_to_vec2,
+    vec4_to_vec3, vec4_to_vec4, zero,
 };
-pub use ext::{
-    ortho, perspective,
-    pick_matrix, project, project_no, project_zo, unproject, unproject_no, unproject_zo,
-    equal_columns, equal_columns_eps, equal_columns_eps_vec, not_equal_columns, not_equal_columns_eps, not_equal_columns_eps_vec,
-    identity, look_at, look_at_lh, rotate, scale, look_at_rh, translate, rotate_x, rotate_y, rotate_z,
-    max3_scalar, max4_scalar, min3_scalar, min4_scalar,
-    epsilon, pi,
-    max, max2, max3, max4, min, min2, min3, min4,
-    equal_eps, equal_eps_vec, not_equal_eps, not_equal_eps_vec,
-    quat_conjugate, quat_inverse, quat_lerp, quat_slerp,
-    quat_cross, quat_dot, quat_length, quat_magnitude, quat_normalize,
-    quat_equal, quat_equal_eps, quat_not_equal, quat_not_equal_eps,
-    quat_exp, quat_log, quat_pow, quat_rotate,
-    quat_angle, quat_angle_axis, quat_axis
+pub use gtx::{
+    angle, are_collinear, are_collinear2d, are_orthogonal, comp_add, comp_max, comp_min, comp_mul,
+    cross2d, diagonal2x2, diagonal2x3, diagonal2x4, diagonal3x2, diagonal3x3, diagonal3x4,
+    diagonal4x2, diagonal4x3, diagonal4x4, distance2, fast_normalize_dot, is_comp_null,
+    is_normalized, is_null, l1_distance, l1_norm, l2_distance, l2_norm, left_handed, length2,
+    magnitude2, mat3_to_quat, matrix_cross, matrix_cross3, normalize_dot, orientation, proj,
+    proj2d, quat_cross_vec, quat_extract_real_component, quat_fast_mix, quat_identity,
+    quat_inv_cross_vec, quat_length2, quat_magnitude2, quat_rotate_normalized_axis,
+    quat_rotate_vec, quat_rotate_vec3, quat_rotation, quat_short_mix, quat_to_mat3, quat_to_mat4,
+    reflect, reflect2d, right_handed, rotate2d, rotate_normalized_axis, rotate_vec2, rotate_vec3,
+    rotate_vec4, rotate_x_vec3, rotate_x_vec4, rotate_y_vec3, rotate_y_vec4, rotate_z_vec3,
+    rotate_z_vec4, rotation, rotation2d, scale2d, scale_bias, scale_bias_matrix, scaling,
+    scaling2d, shear2d_x, shear2d_y, shear_x, shear_y, shear_z, slerp, to_quat, translate2d,
+    translation, translation2d, triangle_normal,
 };
 
-pub use na::{convert, convert_ref, convert_unchecked, convert_ref_unchecked, try_convert, try_convert_ref};
-pub use na::{Scalar, Real, DefaultAllocator, U1, U2, U3, U4};
+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};
 
 mod aliases;
-mod constructors;
 mod common;
-mod matrix;
+mod constructors;
+mod exponential;
 mod geometric;
+mod matrix;
 mod traits;
 mod trigonometric;
 mod vector_relational;
-mod exponential;
 //mod integer;
 //mod packing;
 

nalgebra-glm/src/matrix.rs

@@ -1,34 +1,46 @@
-use na::{Scalar, Real, DefaultAllocator};
+use na::{DefaultAllocator, Real, Scalar};
 
-use traits::{Alloc, Dimension, Number};
 use aliases::{TMat, TVec};
+use traits::{Alloc, Dimension, Number};
 
 /// The determinant of the matrix `m`.
 pub fn determinant<N: Real, D: Dimension>(m: &TMat<N, D, D>) -> N
-    where DefaultAllocator: Alloc<N, D, D> {
+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>
-    where DefaultAllocator: Alloc<N, D, D> {
-    m.clone().try_inverse().unwrap_or_else(TMat::<N, D, D>::zeros)
+where DefaultAllocator: Alloc<N, D, D> {
+    m.clone()
+        .try_inverse()
+        .unwrap_or_else(TMat::<N, D, D>::zeros)
 }
 
 /// Component-wise multiplication of two matrices.
-pub fn matrix_comp_mult<N: Number, R: Dimension, C: Dimension>(x: &TMat<N, R, C>, y: &TMat<N, R, C>) -> TMat<N, R, C>
-    where DefaultAllocator: Alloc<N, R, C> {
+pub fn matrix_comp_mult<N: Number, R: Dimension, C: Dimension>(
+    x: &TMat<N, R, C>,
+    y: &TMat<N, R, C>,
+) -> TMat<N, R, C>
+where
+    DefaultAllocator: Alloc<N, R, C>,
+{
     x.component_mul(y)
 }
 
 /// Treats the first parameter `c` as a column vector and the second parameter `r` as a row vector and does a linear algebraic matrix multiply `c * r`.
-pub fn outer_product<N: Number, R: Dimension, C: Dimension>(c: &TVec<N, R>, r: &TVec<N, C>) -> TMat<N, R, C>
-    where DefaultAllocator: Alloc<N, R, C> {
+pub fn outer_product<N: Number, R: Dimension, C: Dimension>(
+    c: &TVec<N, R>,
+    r: &TVec<N, C>,
+) -> TMat<N, R, C>
+where
+    DefaultAllocator: Alloc<N, R, C>,
+{
     c * r.transpose()
 }
 
 /// The transpose of the matrix `m`.
 pub fn transpose<N: Scalar, R: Dimension, C: Dimension>(x: &TMat<N, R, C>) -> TMat<N, C, R>
-    where DefaultAllocator: Alloc<N, R, C> {
+where DefaultAllocator: Alloc<N, R, C> {
     x.transpose()
 }

nalgebra-glm/src/traits.rs

@@ -1,48 +1,81 @@
-use num::{Signed, FromPrimitive, Bounded};
 use approx::AbsDiffEq;
+use num::{Bounded, FromPrimitive, Signed};
 
-use alga::general::{Ring, Lattice};
-use na::{Scalar, DimName, DimMin, U1};
+use alga::general::{Lattice, Ring};
 use na::allocator::Allocator;
+use na::{DimMin, DimName, Scalar, U1};
 
 /// A type-level number representing a vector, matrix row, or matrix column, dimension.
 pub trait Dimension: DimName + DimMin<Self, Output = Self> {}
 impl<D: DimName + DimMin<D, Output = Self>> Dimension for D {}
 
-
 /// A number that can either be an integer or a float.
-pub trait Number: Scalar + Ring + Lattice + AbsDiffEq<Epsilon = Self> + Signed + FromPrimitive + Bounded {
+pub trait Number:
+    Scalar + Ring + Lattice + AbsDiffEq<Epsilon = Self> + Signed + FromPrimitive + Bounded
+{
 }
 
-impl<T: Scalar + Ring + Lattice + AbsDiffEq<Epsilon = Self> + Signed + FromPrimitive + Bounded> Number for T {
+impl<T: Scalar + Ring + Lattice + AbsDiffEq<Epsilon = Self> + Signed + FromPrimitive + Bounded>
+    Number for T
+{
 }
 
 #[doc(hidden)]
 pub trait Alloc<N: Scalar, R: Dimension, C: Dimension = U1>:
-Allocator<N, R> + Allocator<N, C> + Allocator<N, U1, R> + Allocator<N, U1, C> + Allocator<N, R, C> + Allocator<N, C, R> + Allocator<N, R, R> + Allocator<N, C, C> +
-Allocator<bool, R> + Allocator<bool, C> +
-Allocator<f32, R> + Allocator<f32, C> +
-Allocator<u32, R> + Allocator<u32, C> +
-Allocator<i32, R> + Allocator<i32, C> +
-Allocator<f64, R> + Allocator<f64, C> +
-Allocator<u64, R> + Allocator<u64, C> +
-Allocator<i64, R> + Allocator<i64, C> +
-Allocator<i16, R> + Allocator<i16, C> +
-Allocator<(usize, usize), R> + Allocator<(usize, usize), C>
+    Allocator<N, R>
+    + Allocator<N, C>
+    + Allocator<N, U1, R>
+    + Allocator<N, U1, C>
+    + Allocator<N, R, C>
+    + Allocator<N, C, R>
+    + Allocator<N, R, R>
+    + Allocator<N, C, C>
+    + Allocator<bool, R>
+    + Allocator<bool, C>
+    + Allocator<f32, R>
+    + Allocator<f32, C>
+    + Allocator<u32, R>
+    + Allocator<u32, C>
+    + Allocator<i32, R>
+    + Allocator<i32, C>
+    + Allocator<f64, R>
+    + Allocator<f64, C>
+    + Allocator<u64, R>
+    + Allocator<u64, C>
+    + Allocator<i64, R>
+    + Allocator<i64, C>
+    + Allocator<i16, R>
+    + Allocator<i16, C>
+    + Allocator<(usize, usize), R>
+    + Allocator<(usize, usize), C>
 {
 }
 
-impl<N: Scalar, R: Dimension, C: Dimension, T>
-    Alloc<N, R, C> for T
-where T: Allocator<N, R> + Allocator<N, C> + Allocator<N, U1, R> + Allocator<N, U1, C> + Allocator<N, R, C> + Allocator<N, C, R> + Allocator<N, R, R> + Allocator<N, C, C> +
-         Allocator<bool, R> + Allocator<bool, C> +
-         Allocator<f32, R> + Allocator<f32, C> +
-         Allocator<u32, R> + Allocator<u32, C> +
-         Allocator<i32, R> + Allocator<i32, C> +
-         Allocator<f64, R> + Allocator<f64, C> +
-         Allocator<u64, R> + Allocator<u64, C> +
-         Allocator<i64, R> + Allocator<i64, C> +
-         Allocator<i16, R> + Allocator<i16, C> +
-         Allocator<(usize, usize), R> + Allocator<(usize, usize), C>
+impl<N: Scalar, R: Dimension, C: Dimension, T> Alloc<N, R, C> for T where T: Allocator<N, R>
+        + Allocator<N, C>
+        + Allocator<N, U1, R>
+        + Allocator<N, U1, C>
+        + Allocator<N, R, C>
+        + Allocator<N, C, R>
+        + Allocator<N, R, R>
+        + Allocator<N, C, C>
+        + Allocator<bool, R>
+        + Allocator<bool, C>
+        + Allocator<f32, R>
+        + Allocator<f32, C>
+        + Allocator<u32, R>
+        + Allocator<u32, C>
+        + Allocator<i32, R>
+        + Allocator<i32, C>
+        + Allocator<f64, R>
+        + Allocator<f64, C>
+        + Allocator<u64, R>
+        + Allocator<u64, C>
+        + Allocator<i64, R>
+        + Allocator<i64, C>
+        + Allocator<i16, R>
+        + Allocator<i16, C>
+        + Allocator<(usize, usize), R>
+        + Allocator<(usize, usize), C>
 {
-}
+}

nalgebra-glm/src/trigonometric.rs

@@ -1,95 +1,94 @@
-use na::{self, Real, DefaultAllocator};
+use na::{self, DefaultAllocator, Real};
 
 use aliases::TVec;
 use traits::{Alloc, Dimension};
 
-
 /// Component-wise arc-cosinus.
 pub fn acos<N: Real, D: Dimension>(x: &TVec<N, D>) -> TVec<N, D>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<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>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     angle.map(|e| e.tanh())
 }

nalgebra-glm/src/vector_relational.rs

@@ -1,7 +1,7 @@
-use na::{DefaultAllocator};
+use na::DefaultAllocator;
 
 use aliases::TVec;
-use traits::{Number, Alloc, Dimension};
+use traits::{Alloc, Dimension, Number};
 
 /// Checks that all the vector components are `true`.
 ///
@@ -21,7 +21,7 @@ use traits::{Number, Alloc, Dimension};
 /// * [`any`](fn.any.html)
 /// * [`not`](fn.not.html)
 pub fn all<D: Dimension>(v: &TVec<bool, D>) -> bool
-    where DefaultAllocator: Alloc<bool, D> {
+where DefaultAllocator: Alloc<bool, D> {
     v.iter().all(|x| *x)
 }
 
@@ -46,7 +46,7 @@ pub fn all<D: Dimension>(v: &TVec<bool, D>) -> bool
 /// * [`all`](fn.all.html)
 /// * [`not`](fn.not.html)
 pub fn any<D: Dimension>(v: &TVec<bool, D>) -> bool
-    where DefaultAllocator: Alloc<bool, D> {
+where DefaultAllocator: Alloc<bool, D> {
     v.iter().any(|x| *x)
 }
 
@@ -70,7 +70,7 @@ pub fn any<D: Dimension>(v: &TVec<bool, D>) -> bool
 /// * [`not`](fn.not.html)
 /// * [`not_equal`](fn.not_equal.html)
 pub fn equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.zip_map(y, |x, y| x == y)
 }
 
@@ -94,7 +94,7 @@ pub fn equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bo
 /// * [`not`](fn.not.html)
 /// * [`not_equal`](fn.not_equal.html)
 pub fn greater_than<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.zip_map(y, |x, y| x > y)
 }
 
@@ -117,8 +117,13 @@ pub fn greater_than<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) ->
 /// * [`less_than_equal`](fn.less_than_equal.html)
 /// * [`not`](fn.not.html)
 /// * [`not_equal`](fn.not_equal.html)
-pub fn greater_than_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+pub fn greater_than_equal<N: Number, D: Dimension>(
+    x: &TVec<N, D>,
+    y: &TVec<N, D>,
+) -> TVec<bool, D>
+where
+    DefaultAllocator: Alloc<N, D>,
+{
     x.zip_map(y, |x, y| x >= y)
 }
 
@@ -142,7 +147,7 @@ pub fn greater_than_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D
 /// * [`not`](fn.not.html)
 /// * [`not_equal`](fn.not_equal.html)
 pub fn less_than<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.zip_map(y, |x, y| x < y)
 }
 
@@ -166,7 +171,7 @@ pub fn less_than<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVe
 /// * [`not`](fn.not.html)
 /// * [`not_equal`](fn.not_equal.html)
 pub fn less_than_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.zip_map(y, |x, y| x <= y)
 }
 
@@ -191,7 +196,7 @@ pub fn less_than_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>)
 /// * [`less_than_equal`](fn.less_than_equal.html)
 /// * [`not_equal`](fn.not_equal.html)
 pub fn not<D: Dimension>(v: &TVec<bool, D>) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<bool, D> {
+where DefaultAllocator: Alloc<bool, D> {
     v.map(|x| !x)
 }
 
@@ -215,6 +220,6 @@ pub fn not<D: Dimension>(v: &TVec<bool, D>) -> TVec<bool, D>
 /// * [`less_than_equal`](fn.less_than_equal.html)
 /// * [`not`](fn.not.html)
 pub fn not_equal<N: Number, D: Dimension>(x: &TVec<N, D>, y: &TVec<N, D>) -> TVec<bool, D>
-    where DefaultAllocator: Alloc<N, D> {
+where DefaultAllocator: Alloc<N, D> {
     x.zip_map(y, |x, y| x != y)
 }

nalgebra-lapack/benches/linalg/hessenberg.rs

@@ -1,6 +1,6 @@
-use test::{self, Bencher};
 use na::{DMatrix, Matrix4};
 use nl::Hessenberg;
+use test::{self, Bencher};
 
 #[bench]
 fn hessenberg_decompose_100x100(bh: &mut Bencher) {

nalgebra-lapack/benches/linalg/lu.rs

@@ -1,6 +1,6 @@
-use test::{self, Bencher};
 use na::{DMatrix, Matrix4};
 use nl::LU;
+use test::{self, Bencher};
 
 #[bench]
 fn lu_decompose_100x100(bh: &mut Bencher) {

nalgebra-lapack/benches/linalg/mod.rs

@@ -1,3 +1,3 @@
-mod qr;
-mod lu;
 mod hessenberg;
+mod lu;
+mod qr;

nalgebra-lapack/benches/linalg/qr.rs

@@ -1,6 +1,6 @@
-use test::{self, Bencher};
 use na::{DMatrix, Matrix4};
 use nl::QR;
+use test::{self, Bencher};
 
 #[bench]
 fn qr_decompose_100x100(bh: &mut Bencher) {

nalgebra-lapack/src/cholesky.rs

@@ -1,5 +1,5 @@
 #[cfg(feature = "serde-serialize")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 use num::Zero;
 use num_complex::Complex;
@@ -15,26 +15,17 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            serialize = "DefaultAllocator: Allocator<N, D>,
-         MatrixN<N, D>: Serialize"
-        )
-    )
+    serde(bound(serialize = "DefaultAllocator: Allocator<N, D>,
+         MatrixN<N, D>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            deserialize = "DefaultAllocator: Allocator<N, D>,
-         MatrixN<N, D>: Deserialize<'de>"
-        )
-    )
+    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D>,
+         MatrixN<N, D>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
 pub struct Cholesky<N: Scalar, D: Dim>
-where
-    DefaultAllocator: Allocator<N, D, D>,
+where DefaultAllocator: Allocator<N, D, D>
 {
     l: MatrixN<N, D>,
 }
@@ -47,8 +38,7 @@ where
 }
 
 impl<N: CholeskyScalar + Zero, D: Dim> Cholesky<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>,
+where DefaultAllocator: Allocator<N, D, D>
 {
     /// Computes the cholesky decomposition of the given symmetric-definite-positive square
     /// matrix.
@@ -124,9 +114,7 @@ where
     /// Solves in-place the symmetric-definite-positive linear system `self * x = b`, where `x` is
     /// the unknown to be determined.
     pub fn solve_mut<R2: Dim, C2: Dim>(&self, b: &mut MatrixMN<N, R2, C2>) -> bool
-    where
-        DefaultAllocator: Allocator<N, R2, C2>,
-    {
+    where DefaultAllocator: Allocator<N, R2, C2> {
         let dim = self.l.nrows();
 
         assert!(

nalgebra-lapack/src/eigen.rs

@@ -1,5 +1,5 @@
 #[cfg(feature = "serde-serialize")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 use num::Zero;
 use num_complex::Complex;
@@ -19,27 +19,22 @@ use lapack;
 #[cfg_attr(
     feature = "serde-serialize",
     serde(
-        bound(
-            serialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+        bound(serialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
          VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Serialize"
-        )
+         MatrixN<N, D>: Serialize")
     )
 )]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(
-        bound(
-            deserialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+        bound(deserialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
          VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Deserialize<'de>"
-        )
+         MatrixN<N, D>: Deserialize<'de>")
     )
 )]
 #[derive(Clone, Debug)]
 pub struct Eigen<N: Scalar, D: Dim>
-where
-    DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>,
+where DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>
 {
     /// The eigenvalues of the decomposed matrix.
     pub eigenvalues: VectorN<N, D>,
@@ -58,8 +53,7 @@ where
 }
 
 impl<N: EigenScalar + Real, D: Dim> Eigen<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     /// Computes the eigenvalues and eigenvectors of the square matrix `m`.
     ///
@@ -68,7 +62,8 @@ where
         mut m: MatrixN<N, D>,
         left_eigenvectors: bool,
         eigenvectors: bool,
-    ) -> Option<Eigen<N, D>> {
+    ) -> Option<Eigen<N, D>>
+    {
         assert!(
             m.is_square(),
             "Unable to compute the eigenvalue decomposition of a non-square matrix."
@@ -234,9 +229,7 @@ where
     ///
     /// Panics if the eigenvalue computation does not converge.
     pub fn complex_eigenvalues(mut m: MatrixN<N, D>) -> VectorN<Complex<N>, D>
-    where
-        DefaultAllocator: Allocator<Complex<N>, D>,
-    {
+    where DefaultAllocator: Allocator<Complex<N>, D> {
         assert!(
             m.is_square(),
             "Unable to compute the eigenvalue decomposition of a non-square matrix."

nalgebra-lapack/src/hessenberg.rs

@@ -13,30 +13,21 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            serialize = "DefaultAllocator: Allocator<N, D, D> +
+    serde(bound(serialize = "DefaultAllocator: Allocator<N, D, D> +
                            Allocator<N, DimDiff<D, U1>>,
          MatrixN<N, D>: Serialize,
-         VectorN<N, DimDiff<D, U1>>: Serialize"
-        )
-    )
+         VectorN<N, DimDiff<D, U1>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            deserialize = "DefaultAllocator: Allocator<N, D, D> +
+    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D, D> +
                            Allocator<N, DimDiff<D, U1>>,
          MatrixN<N, D>: Deserialize<'de>,
-         VectorN<N, DimDiff<D, U1>>: Deserialize<'de>"
-        )
-    )
+         VectorN<N, DimDiff<D, U1>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
 pub struct Hessenberg<N: Scalar, D: DimSub<U1>>
-where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
+where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>
 {
     h: MatrixN<N, D>,
     tau: VectorN<N, DimDiff<D, U1>>,
@@ -51,8 +42,7 @@ where
 }
 
 impl<N: HessenbergScalar + Zero, D: DimSub<U1>> Hessenberg<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
+where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>
 {
     /// Computes the hessenberg decomposition of the matrix `m`.
     pub fn new(mut m: MatrixN<N, D>) -> Hessenberg<N, D> {
@@ -104,8 +94,7 @@ where
 }
 
 impl<N: HessenbergReal + Zero, D: DimSub<U1>> Hessenberg<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>,
+where DefaultAllocator: Allocator<N, D, D> + Allocator<N, DimDiff<D, U1>>
 {
     /// Computes the matrices `(Q, H)` of this decomposition.
     #[inline]

nalgebra-lapack/src/lib.rs

@@ -68,8 +68,10 @@
 #![deny(unused_qualifications)]
 #![deny(unused_results)]
 #![deny(missing_docs)]
-#![doc(html_favicon_url = "http://nalgebra.org/img/favicon.ico",
-       html_root_url = "http://nalgebra.org/rustdoc")]
+#![doc(
+    html_favicon_url = "http://nalgebra.org/img/favicon.ico",
+    html_root_url = "http://nalgebra.org/rustdoc"
+)]
 
 extern crate alga;
 extern crate lapack;

nalgebra-lapack/src/lu.rs

@@ -20,30 +20,21 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            serialize = "DefaultAllocator: Allocator<N, R, C> +
+    serde(bound(serialize = "DefaultAllocator: Allocator<N, R, C> +
                            Allocator<i32, DimMinimum<R, C>>,
          MatrixMN<N, R, C>: Serialize,
-         PermutationSequence<DimMinimum<R, C>>: Serialize"
-        )
-    )
+         PermutationSequence<DimMinimum<R, C>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            deserialize = "DefaultAllocator: Allocator<N, R, C> +
+    serde(bound(deserialize = "DefaultAllocator: Allocator<N, R, C> +
                            Allocator<i32, DimMinimum<R, C>>,
          MatrixMN<N, R, C>: Deserialize<'de>,
-         PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"
-        )
-    )
+         PermutationSequence<DimMinimum<R, C>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
 pub struct LU<N: Scalar, R: DimMin<C>, C: Dim>
-where
-    DefaultAllocator: Allocator<i32, DimMinimum<R, C>> + Allocator<N, R, C>,
+where DefaultAllocator: Allocator<i32, DimMinimum<R, C>> + Allocator<N, R, C>
 {
     lu: MatrixMN<N, R, C>,
     p: VectorN<i32, DimMinimum<R, C>>,
@@ -139,9 +130,7 @@ where
     /// Applies the permutation matrix to a given matrix or vector in-place.
     #[inline]
     pub fn permute<C2: Dim>(&self, rhs: &mut MatrixMN<N, R, C2>)
-    where
-        DefaultAllocator: Allocator<N, R, C2>,
-    {
+    where DefaultAllocator: Allocator<N, R, C2> {
         let (nrows, ncols) = rhs.shape();
 
         N::xlaswp(
@@ -156,9 +145,7 @@ where
     }
 
     fn generic_solve_mut<R2: Dim, C2: Dim>(&self, trans: u8, b: &mut MatrixMN<N, R2, C2>) -> bool
-    where
-        DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2>,
-    {
+    where DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2> {
         let dim = self.lu.nrows();
 
         assert!(
@@ -246,9 +233,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 MatrixMN<N, R2, C2>) -> bool
-    where
-        DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2>,
-    {
+    where DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2> {
         self.generic_solve_mut(b'N', b)
     }
 
@@ -257,9 +242,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 MatrixMN<N, R2, C2>) -> bool
-    where
-        DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2>,
-    {
+    where DefaultAllocator: Allocator<N, R2, C2> + Allocator<i32, R2> {
         self.generic_solve_mut(b'T', b)
     }
 

nalgebra-lapack/src/qr.rs

@@ -1,5 +1,5 @@
 #[cfg(feature = "serde-serialize")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 use num::Zero;
 use num_complex::Complex;
@@ -16,30 +16,21 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            serialize = "DefaultAllocator: Allocator<N, R, C> +
+    serde(bound(serialize = "DefaultAllocator: Allocator<N, R, C> +
                            Allocator<N, DimMinimum<R, C>>,
          MatrixMN<N, R, C>: Serialize,
-         VectorN<N, DimMinimum<R, C>>: Serialize"
-        )
-    )
+         VectorN<N, DimMinimum<R, C>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            deserialize = "DefaultAllocator: Allocator<N, R, C> +
+    serde(bound(deserialize = "DefaultAllocator: Allocator<N, R, C> +
                            Allocator<N, DimMinimum<R, C>>,
          MatrixMN<N, R, C>: Deserialize<'de>,
-         VectorN<N, DimMinimum<R, C>>: Deserialize<'de>"
-        )
-    )
+         VectorN<N, DimMinimum<R, C>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
 pub struct QR<N: Scalar, R: DimMin<C>, C: Dim>
-where
-    DefaultAllocator: Allocator<N, R, C> + Allocator<N, DimMinimum<R, C>>,
+where DefaultAllocator: Allocator<N, R, C> + Allocator<N, DimMinimum<R, C>>
 {
     qr: MatrixMN<N, R, C>,
     tau: VectorN<N, DimMinimum<R, C>>,
@@ -54,11 +45,10 @@ where
 }
 
 impl<N: QRScalar + Zero, R: DimMin<C>, C: Dim> QR<N, R, C>
-where
-    DefaultAllocator: Allocator<N, R, C>
+where DefaultAllocator: Allocator<N, R, C>
         + Allocator<N, R, DimMinimum<R, C>>
         + Allocator<N, DimMinimum<R, C>, C>
-        + Allocator<N, DimMinimum<R, C>>,
+        + Allocator<N, DimMinimum<R, C>>
 {
     /// Computes the QR decomposition of the matrix `m`.
     pub fn new(mut m: MatrixMN<N, R, C>) -> QR<N, R, C> {
@@ -105,11 +95,10 @@ where
 }
 
 impl<N: QRReal + Zero, R: DimMin<C>, C: Dim> QR<N, R, C>
-where
-    DefaultAllocator: Allocator<N, R, C>
+where DefaultAllocator: Allocator<N, R, C>
         + Allocator<N, R, DimMinimum<R, C>>
         + Allocator<N, DimMinimum<R, C>, C>
-        + Allocator<N, DimMinimum<R, C>>,
+        + Allocator<N, DimMinimum<R, C>>
 {
     /// Retrieves the matrices `(Q, R)` of this decompositions.
     pub fn unpack(
@@ -131,7 +120,8 @@ where
             return MatrixMN::from_element_generic(nrows, min_nrows_ncols, N::zero());
         }
 
-        let mut q = self.qr
+        let mut q = self
+            .qr
             .generic_slice((0, 0), (nrows, min_nrows_ncols))
             .into_owned();
 

nalgebra-lapack/src/schur.rs

@@ -1,5 +1,5 @@
 #[cfg(feature = "serde-serialize")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 use num::Zero;
 use num_complex::Complex;
@@ -19,27 +19,22 @@ use lapack;
 #[cfg_attr(
     feature = "serde-serialize",
     serde(
-        bound(
-            serialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+        bound(serialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
          VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Serialize"
-        )
+         MatrixN<N, D>: Serialize")
     )
 )]
 #[cfg_attr(
     feature = "serde-serialize",
     serde(
-        bound(
-            deserialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+        bound(deserialize = "DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
          VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Deserialize<'de>"
-        )
+         MatrixN<N, D>: Deserialize<'de>")
     )
 )]
 #[derive(Clone, Debug)]
 pub struct RealSchur<N: Scalar, D: Dim>
-where
-    DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>,
+where DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>
 {
     re: VectorN<N, D>,
     im: VectorN<N, D>,
@@ -56,8 +51,7 @@ where
 }
 
 impl<N: RealSchurScalar + Real, D: Dim> RealSchur<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     /// Computes the eigenvalues and real Schur form of the matrix `m`.
     ///
@@ -152,9 +146,7 @@ where
 
     /// Computes the complex eigenvalues of the decomposed matrix.
     pub fn complex_eigenvalues(&self) -> VectorN<Complex<N>, D>
-    where
-        DefaultAllocator: Allocator<Complex<N>, D>,
-    {
+    where DefaultAllocator: Allocator<Complex<N>, D> {
         let mut out = unsafe { VectorN::new_uninitialized_generic(self.t.data.shape().0, U1) };
 
         for i in 0..out.len() {

nalgebra-lapack/src/svd.rs

@@ -1,5 +1,5 @@
 #[cfg(feature = "serde-serialize")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 use num::Signed;
 use std::cmp;
@@ -15,34 +15,25 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            serialize = "DefaultAllocator: Allocator<N, DimMinimum<R, C>> +
+    serde(bound(serialize = "DefaultAllocator: Allocator<N, DimMinimum<R, C>> +
                            Allocator<N, R, R> +
                            Allocator<N, C, C>,
          MatrixN<N, R>: Serialize,
          MatrixN<N, C>: Serialize,
-         VectorN<N, DimMinimum<R, C>>: Serialize"
-        )
-    )
+         VectorN<N, DimMinimum<R, C>>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            serialize = "DefaultAllocator: Allocator<N, DimMinimum<R, C>> +
+    serde(bound(serialize = "DefaultAllocator: Allocator<N, DimMinimum<R, C>> +
                            Allocator<N, R, R> +
                            Allocator<N, C, C>,
          MatrixN<N, R>: Deserialize<'de>,
          MatrixN<N, C>: Deserialize<'de>,
-         VectorN<N, DimMinimum<R, C>>: Deserialize<'de>"
-        )
-    )
+         VectorN<N, DimMinimum<R, C>>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
 pub struct SVD<N: Scalar, R: DimMin<C>, C: Dim>
-where
-    DefaultAllocator: Allocator<N, R, R> + Allocator<N, DimMinimum<R, C>> + Allocator<N, C, C>,
+where DefaultAllocator: Allocator<N, R, R> + Allocator<N, DimMinimum<R, C>> + Allocator<N, C, C>
 {
     /// The left-singular vectors `U` of this SVD.
     pub u: MatrixN<N, R>, // FIXME: should be MatrixMN<N, R, DimMinimum<R, C>>
@@ -64,22 +55,20 @@ where
 /// Trait implemented by floats (`f32`, `f64`) and complex floats (`Complex<f32>`, `Complex<f64>`)
 /// supported by the Singular Value Decompotition.
 pub trait SVDScalar<R: DimMin<C>, C: Dim>: Scalar
-where
-    DefaultAllocator: Allocator<Self, R, R>
+where DefaultAllocator: Allocator<Self, R, R>
         + Allocator<Self, R, C>
         + Allocator<Self, DimMinimum<R, C>>
-        + Allocator<Self, C, C>,
+        + Allocator<Self, C, C>
 {
     /// Computes the SVD decomposition of `m`.
     fn compute(m: MatrixMN<Self, R, C>) -> Option<SVD<Self, R, C>>;
 }
 
 impl<N: SVDScalar<R, C>, R: DimMin<C>, C: Dim> SVD<N, R, C>
-where
-    DefaultAllocator: Allocator<N, R, R>
+where DefaultAllocator: Allocator<N, R, R>
         + Allocator<N, R, C>
         + Allocator<N, DimMinimum<R, C>>
-        + Allocator<N, C, C>,
+        + Allocator<N, C, C>
 {
     /// Computes the Singular Value Decomposition of `matrix`.
     pub fn new(m: MatrixMN<N, R, C>) -> Option<Self> {

nalgebra-lapack/src/symmetric_eigen.rs

@@ -1,5 +1,5 @@
 #[cfg(feature = "serde-serialize")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 use num::Zero;
 use std::ops::MulAssign;
@@ -18,30 +18,21 @@ use lapack;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            serialize = "DefaultAllocator: Allocator<N, D, D> +
+    serde(bound(serialize = "DefaultAllocator: Allocator<N, D, D> +
                            Allocator<N, D>,
          VectorN<N, D>: Serialize,
-         MatrixN<N, D>: Serialize"
-        )
-    )
+         MatrixN<N, D>: Serialize"))
 )]
 #[cfg_attr(
     feature = "serde-serialize",
-    serde(
-        bound(
-            deserialize = "DefaultAllocator: Allocator<N, D, D> +
+    serde(bound(deserialize = "DefaultAllocator: Allocator<N, D, D> +
                            Allocator<N, D>,
          VectorN<N, D>: Deserialize<'de>,
-         MatrixN<N, D>: Deserialize<'de>"
-        )
-    )
+         MatrixN<N, D>: Deserialize<'de>"))
 )]
 #[derive(Clone, Debug)]
 pub struct SymmetricEigen<N: Scalar, D: Dim>
-where
-    DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>,
+where DefaultAllocator: Allocator<N, D> + Allocator<N, D, D>
 {
     /// The eigenvectors of the decomposed matrix.
     pub eigenvectors: MatrixN<N, D>,
@@ -59,8 +50,7 @@ where
 }
 
 impl<N: SymmetricEigenScalar + Real, D: Dim> SymmetricEigen<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
+where DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>
 {
     /// Computes the eigenvalues and eigenvectors of the symmetric matrix `m`.
     ///
@@ -89,7 +79,8 @@ where
     fn do_decompose(
         mut m: MatrixN<N, D>,
         eigenvectors: bool,
-    ) -> Option<(VectorN<N, D>, Option<MatrixN<N, D>>)> {
+    ) -> Option<(VectorN<N, D>, Option<MatrixN<N, D>>)>
+    {
         assert!(
             m.is_square(),
             "Unable to compute the eigenvalue decomposition of a non-square matrix."

nalgebra-lapack/tests/linalg/cholesky.rs

@@ -1,7 +1,7 @@
 use std::cmp;
 
-use nl::Cholesky;
 use na::{DMatrix, DVector, Matrix3, Matrix4, Matrix4x3, Vector4};
+use nl::Cholesky;
 
 quickcheck!{
     fn cholesky(m: DMatrix<f64>) -> bool {

nalgebra-lapack/tests/linalg/lu.rs

@@ -1,7 +1,7 @@
 use std::cmp;
 
-use nl::LU;
 use na::{DMatrix, DVector, Matrix3x4, Matrix4, Matrix4x3, Vector4};
+use nl::LU;
 
 quickcheck!{
     fn lup(m: DMatrix<f64>) -> bool {

nalgebra-lapack/tests/linalg/mod.rs

@@ -1,7 +1,7 @@
-mod real_eigensystem;
-mod symmetric_eigen;
 mod cholesky;
 mod lu;
 mod qr;
-mod svd;
+mod real_eigensystem;
 mod real_schur;
+mod svd;
+mod symmetric_eigen;

nalgebra-lapack/tests/linalg/qr.rs

@@ -1,5 +1,5 @@
-use nl::QR;
 use na::{DMatrix, Matrix4x3};
+use nl::QR;
 
 quickcheck!{
     fn qr(m: DMatrix<f64>) -> bool {

nalgebra-lapack/tests/linalg/real_eigensystem.rs

@@ -1,7 +1,7 @@
 use std::cmp;
 
-use nl::Eigen;
 use na::{DMatrix, Matrix4};
+use nl::Eigen;
 
 quickcheck!{
     fn eigensystem(n: usize) -> bool {

nalgebra-lapack/tests/linalg/real_schur.rs

@@ -1,6 +1,6 @@
-use std::cmp;
-use nl::RealSchur;
 use na::{DMatrix, Matrix4};
+use nl::RealSchur;
+use std::cmp;
 
 quickcheck! {
     fn schur(n: usize) -> bool {

nalgebra-lapack/tests/linalg/svd.rs

@@ -1,5 +1,5 @@
-use nl::SVD;
 use na::{DMatrix, Matrix3x4};
+use nl::SVD;
 
 quickcheck!{
     fn svd(m: DMatrix<f64>) -> bool {

nalgebra-lapack/tests/linalg/symmetric_eigen.rs

@@ -1,7 +1,7 @@
 use std::cmp;
 
-use nl::SymmetricEigen;
 use na::{DMatrix, Matrix4};
+use nl::SymmetricEigen;
 
 quickcheck!{
     fn symmetric_eigen(n: usize) -> bool {

src/base/allocator.rs

@@ -79,7 +79,8 @@ where
     N: Scalar,
     DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, SameShapeR<R1, R2>, SameShapeC<C1, C2>>,
     ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
-{}
+{
+}
 
 // XXX: Bad name.
 /// Restricts the given number of rows to be equal.
@@ -100,4 +101,5 @@ where
     N: Scalar,
     DefaultAllocator: Allocator<N, R1, U1> + Allocator<N, SameShapeR<R1, R2>>,
     ShapeConstraint: SameNumberOfRows<R1, R2>,
-{}
+{
+}

src/base/blas.rs

@@ -161,8 +161,7 @@ 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,
+where N: Scalar + Zero + ClosedAdd + ClosedMul
 {
     /// The dot product between two vectors or matrices (seen as vectors).
     ///
@@ -324,9 +323,7 @@ where
 }
 
 fn array_axpy<N>(y: &mut [N], a: N, x: &[N], beta: N, stride1: usize, stride2: usize, len: usize)
-where
-    N: Scalar + Zero + ClosedAdd + ClosedMul,
-{
+where N: Scalar + Zero + ClosedAdd + ClosedMul {
     for i in 0..len {
         unsafe {
             let y = y.get_unchecked_mut(i * stride1);
@@ -336,9 +333,7 @@ where
 }
 
 fn array_ax<N>(y: &mut [N], a: N, x: &[N], stride1: usize, stride2: usize, len: usize)
-where
-    N: Scalar + Zero + ClosedAdd + ClosedMul,
-{
+where N: Scalar + Zero + ClosedAdd + ClosedMul {
     for i in 0..len {
         unsafe {
             *y.get_unchecked_mut(i * stride1) = a * *x.get_unchecked(i * stride2);
@@ -576,8 +571,7 @@ where
 }
 
 impl<N, R1: Dim, C1: Dim, S: StorageMut<N, R1, C1>> Matrix<N, R1, C1, S>
-where
-    N: Scalar + Zero + ClosedAdd + ClosedMul,
+where N: Scalar + Zero + ClosedAdd + ClosedMul
 {
     /// Computes `self = alpha * x * y.transpose() + beta * self`.
     ///
@@ -817,8 +811,7 @@ where
 }
 
 impl<N, R1: Dim, C1: Dim, S: StorageMut<N, R1, C1>> Matrix<N, R1, C1, S>
-where
-    N: Scalar + Zero + ClosedAdd + ClosedMul,
+where N: Scalar + Zero + ClosedAdd + ClosedMul
 {
     /// Computes `self = alpha * x * y.transpose() + beta * self`, where `self` is a **symmetric**
     /// matrix.
@@ -876,8 +869,7 @@ where
 }
 
 impl<N, D1: Dim, S: StorageMut<N, D1, D1>> SquareMatrix<N, D1, S>
-where
-    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
+where N: Scalar + Zero + One + ClosedAdd + ClosedMul
 {
     /// Computes the quadratic form `self = alpha * lhs * mid * lhs.transpose() + beta * self`.
     ///

src/base/cg.rs

@@ -238,9 +238,7 @@ impl<N: Scalar + Ring, D: DimName, S: StorageMut<N, D, D>> SquareMatrix<N, D, S>
     /// Computes in-place the transformation equal to `self` followed by an uniform scaling factor.
     #[inline]
     pub fn append_scaling_mut(&mut self, scaling: N)
-    where
-        D: DimNameSub<U1>,
-    {
+    where D: DimNameSub<U1> {
         let mut to_scale = self.fixed_rows_mut::<DimNameDiff<D, U1>>(0);
         to_scale *= scaling;
     }
@@ -248,9 +246,7 @@ impl<N: Scalar + Ring, D: DimName, S: StorageMut<N, D, D>> SquareMatrix<N, D, S>
     /// Computes in-place the transformation equal to an uniform scaling factor followed by `self`.
     #[inline]
     pub fn prepend_scaling_mut(&mut self, scaling: N)
-    where
-        D: DimNameSub<U1>,
-    {
+    where D: DimNameSub<U1> {
         let mut to_scale = self.fixed_columns_mut::<DimNameDiff<D, U1>>(0);
         to_scale *= scaling;
     }
@@ -319,16 +315,16 @@ impl<N: Scalar + Ring, D: DimName, S: StorageMut<N, D, D>> SquareMatrix<N, D, S>
 }
 
 impl<N: Real, D: DimNameSub<U1>> Transformation<Point<N, DimNameDiff<D, U1>>> for MatrixN<N, D>
-where
-    DefaultAllocator: Allocator<N, D, D>
+where DefaultAllocator: Allocator<N, D, D>
         + Allocator<N, DimNameDiff<D, U1>>
-        + Allocator<N, DimNameDiff<D, U1>, DimNameDiff<D, U1>>,
+        + Allocator<N, DimNameDiff<D, U1>, DimNameDiff<D, U1>>
 {
     #[inline]
     fn transform_vector(
         &self,
         v: &VectorN<N, DimNameDiff<D, U1>>,
-    ) -> VectorN<N, DimNameDiff<D, U1>> {
+    ) -> VectorN<N, DimNameDiff<D, U1>>
+    {
         let transform = self.fixed_slice::<DimNameDiff<D, U1>, DimNameDiff<D, U1>>(0, 0);
         let normalizer = self.fixed_slice::<U1, DimNameDiff<D, U1>>(D::dim() - 1, 0);
         let n = normalizer.tr_dot(&v);

src/base/constraint.rs

@@ -8,8 +8,7 @@ pub struct ShapeConstraint;
 /// Constraints `C1` and `R2` to be equivalent.
 pub trait AreMultipliable<R1: Dim, C1: Dim, R2: Dim, C2: Dim>: DimEq<C1, R2> {}
 
-impl<R1: Dim, C1: Dim, R2: Dim, C2: Dim> AreMultipliable<R1, C1, R2, C2> for ShapeConstraint where
-    ShapeConstraint: DimEq<C1, R2>
+impl<R1: Dim, C1: Dim, R2: Dim, C2: Dim> AreMultipliable<R1, C1, R2, C2> for ShapeConstraint where ShapeConstraint: DimEq<C1, R2>
 {}
 
 /// Constraints `D1` and `D2` to be equivalent.

src/base/construction.rs

@@ -26,8 +26,7 @@ use base::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar, Unit, Vector, Ve
  *
  */
 impl<N: Scalar, R: Dim, C: Dim> MatrixMN<N, R, C>
-where
-    DefaultAllocator: Allocator<N, R, C>,
+where DefaultAllocator: Allocator<N, R, C>
 {
     /// Creates a new uninitialized matrix. If the matrix has a compile-time dimension, this panics
     /// if `nrows != R::to_usize()` or `ncols != C::to_usize()`.
@@ -55,18 +54,14 @@ where
     /// Creates a matrix with all its elements set to 0.
     #[inline]
     pub fn zeros_generic(nrows: R, ncols: C) -> Self
-    where
-        N: Zero,
-    {
+    where N: Zero {
         Self::from_element_generic(nrows, ncols, N::zero())
     }
 
     /// Creates a matrix with all its elements filled by an iterator.
     #[inline]
     pub fn from_iterator_generic<I>(nrows: R, ncols: C, iter: I) -> Self
-    where
-        I: IntoIterator<Item = N>,
-    {
+    where I: IntoIterator<Item = N> {
         Self::from_data(DefaultAllocator::allocate_from_iterator(nrows, ncols, iter))
     }
 
@@ -105,9 +100,7 @@ where
     /// coordinates.
     #[inline]
     pub fn from_fn_generic<F>(nrows: R, ncols: C, mut f: F) -> Self
-    where
-        F: FnMut(usize, usize) -> N,
-    {
+    where F: FnMut(usize, usize) -> N {
         let mut res = unsafe { Self::new_uninitialized_generic(nrows, ncols) };
 
         for j in 0..ncols.value() {
@@ -125,9 +118,7 @@ where
     /// to the identity matrix. All other entries are set to zero.
     #[inline]
     pub fn identity_generic(nrows: R, ncols: C) -> Self
-    where
-        N: Zero + One,
-    {
+    where N: Zero + One {
         Self::from_diagonal_element_generic(nrows, ncols, N::one())
     }
 
@@ -137,9 +128,7 @@ where
     /// to the identity matrix. All other entries are set to zero.
     #[inline]
     pub fn from_diagonal_element_generic(nrows: R, ncols: C, elt: N) -> Self
-    where
-        N: Zero + One,
-    {
+    where N: Zero + One {
         let mut res = Self::zeros_generic(nrows, ncols);
 
         for i in 0..::min(nrows.value(), ncols.value()) {
@@ -155,9 +144,7 @@ where
     /// Panics if `elts.len()` is larger than the minimum among `nrows` and `ncols`.
     #[inline]
     pub fn from_partial_diagonal_generic(nrows: R, ncols: C, elts: &[N]) -> Self
-    where
-        N: Zero,
-    {
+    where N: Zero {
         let mut res = Self::zeros_generic(nrows, ncols);
         assert!(
             elts.len() <= ::min(nrows.value(), ncols.value()),
@@ -177,9 +164,7 @@ where
     /// not have the same dimensions.
     #[inline]
     pub fn from_rows<SB>(rows: &[Matrix<N, U1, C, SB>]) -> Self
-    where
-        SB: Storage<N, U1, C>,
-    {
+    where SB: Storage<N, U1, C> {
         assert!(rows.len() > 0, "At least one row must be given.");
         let nrows = R::try_to_usize().unwrap_or(rows.len());
         let ncols = rows[0].len();
@@ -207,9 +192,7 @@ where
     /// columns do not have the same dimensions.
     #[inline]
     pub fn from_columns<SB>(columns: &[Vector<N, R, SB>]) -> Self
-    where
-        SB: Storage<N, R>,
-    {
+    where SB: Storage<N, R> {
         assert!(columns.len() > 0, "At least one column must be given.");
         let ncols = C::try_to_usize().unwrap_or(columns.len());
         let nrows = columns[0].len();
@@ -235,9 +218,7 @@ where
     #[inline]
     #[cfg(feature = "std")]
     pub fn new_random_generic(nrows: R, ncols: C) -> Self
-    where
-        Standard: Distribution<N>,
-    {
+    where Standard: Distribution<N> {
         Self::from_fn_generic(nrows, ncols, |_, _| rand::random())
     }
 
@@ -248,7 +229,8 @@ where
         ncols: C,
         distribution: &mut Distr,
         rng: &mut G,
-    ) -> Self {
+    ) -> Self
+    {
         Self::from_fn_generic(nrows, ncols, |_, _| distribution.sample(rng))
     }
 }
@@ -261,9 +243,7 @@ where
     /// Creates a square matrix with its diagonal set to `diag` and all other entries set to 0.
     #[inline]
     pub fn from_diagonal<SB: Storage<N, D>>(diag: &Vector<N, D, SB>) -> Self
-    where
-        N: Zero,
-    {
+    where N: Zero {
         let (dim, _) = diag.data.shape();
         let mut res = Self::zeros_generic(dim, dim);
 
@@ -703,9 +683,7 @@ where
     /// The column vector with a 1 as its first component, and zero elsewhere.
     #[inline]
     pub fn x() -> Self
-    where
-        R::Value: Cmp<typenum::U0, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U0, Output = Greater> {
         let mut res = Self::zeros();
         unsafe {
             *res.vget_unchecked_mut(0) = N::one();
@@ -717,9 +695,7 @@ where
     /// The column vector with a 1 as its second component, and zero elsewhere.
     #[inline]
     pub fn y() -> Self
-    where
-        R::Value: Cmp<typenum::U1, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U1, Output = Greater> {
         let mut res = Self::zeros();
         unsafe {
             *res.vget_unchecked_mut(1) = N::one();
@@ -731,9 +707,7 @@ where
     /// The column vector with a 1 as its third component, and zero elsewhere.
     #[inline]
     pub fn z() -> Self
-    where
-        R::Value: Cmp<typenum::U2, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U2, Output = Greater> {
         let mut res = Self::zeros();
         unsafe {
             *res.vget_unchecked_mut(2) = N::one();
@@ -745,9 +719,7 @@ where
     /// The column vector with a 1 as its fourth component, and zero elsewhere.
     #[inline]
     pub fn w() -> Self
-    where
-        R::Value: Cmp<typenum::U3, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U3, Output = Greater> {
         let mut res = Self::zeros();
         unsafe {
             *res.vget_unchecked_mut(3) = N::one();
@@ -759,9 +731,7 @@ where
     /// The column vector with a 1 as its fifth component, and zero elsewhere.
     #[inline]
     pub fn a() -> Self
-    where
-        R::Value: Cmp<typenum::U4, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U4, Output = Greater> {
         let mut res = Self::zeros();
         unsafe {
             *res.vget_unchecked_mut(4) = N::one();
@@ -773,9 +743,7 @@ where
     /// The column vector with a 1 as its sixth component, and zero elsewhere.
     #[inline]
     pub fn b() -> Self
-    where
-        R::Value: Cmp<typenum::U5, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U5, Output = Greater> {
         let mut res = Self::zeros();
         unsafe {
             *res.vget_unchecked_mut(5) = N::one();
@@ -787,54 +755,42 @@ where
     /// The unit column vector with a 1 as its first component, and zero elsewhere.
     #[inline]
     pub fn x_axis() -> Unit<Self>
-    where
-        R::Value: Cmp<typenum::U0, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U0, Output = Greater> {
         Unit::new_unchecked(Self::x())
     }
 
     /// The unit column vector with a 1 as its second component, and zero elsewhere.
     #[inline]
     pub fn y_axis() -> Unit<Self>
-    where
-        R::Value: Cmp<typenum::U1, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U1, Output = Greater> {
         Unit::new_unchecked(Self::y())
     }
 
     /// The unit column vector with a 1 as its third component, and zero elsewhere.
     #[inline]
     pub fn z_axis() -> Unit<Self>
-    where
-        R::Value: Cmp<typenum::U2, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U2, Output = Greater> {
         Unit::new_unchecked(Self::z())
     }
 
     /// The unit column vector with a 1 as its fourth component, and zero elsewhere.
     #[inline]
     pub fn w_axis() -> Unit<Self>
-    where
-        R::Value: Cmp<typenum::U3, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U3, Output = Greater> {
         Unit::new_unchecked(Self::w())
     }
 
     /// The unit column vector with a 1 as its fifth component, and zero elsewhere.
     #[inline]
     pub fn a_axis() -> Unit<Self>
-    where
-        R::Value: Cmp<typenum::U4, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U4, Output = Greater> {
         Unit::new_unchecked(Self::a())
     }
 
     /// The unit column vector with a 1 as its sixth component, and zero elsewhere.
     #[inline]
     pub fn b_axis() -> Unit<Self>
-    where
-        R::Value: Cmp<typenum::U5, Output = Greater>,
-    {
+    where R::Value: Cmp<typenum::U5, Output = Greater> {
         Unit::new_unchecked(Self::b())
     }
 }

src/base/construction_slice.rs

@@ -22,7 +22,8 @@ impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
         ncols: C,
         rstride: RStride,
         cstride: CStride,
-    ) -> Self {
+    ) -> Self
+    {
         let data = SliceStorage::from_raw_parts(
             data.as_ptr().offset(start as isize),
             (nrows, ncols),
@@ -42,7 +43,8 @@ impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
         ncols: C,
         rstride: RStride,
         cstride: CStride,
-    ) -> Self {
+    ) -> Self
+    {
         // NOTE: The assertion implements the following formula, but without subtractions to avoid
         // underflow panics:
         //      len >= (ncols - 1) * cstride + (nrows - 1) * rstride + 1
@@ -73,7 +75,8 @@ impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
         ncols: C,
         rstride: RStride,
         cstride: CStride,
-    ) -> Self {
+    ) -> Self
+    {
         let data = SliceStorageMut::from_raw_parts(
             data.as_mut_ptr().offset(start as isize),
             (nrows, ncols),
@@ -93,7 +96,8 @@ impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
         ncols: C,
         rstride: RStride,
         cstride: CStride,
-    ) -> Self {
+    ) -> Self
+    {
         // NOTE: The assertion implements the following formula, but without subtractions to avoid
         // underflow panics:
         //      len >= (ncols - 1) * cstride + (nrows - 1) * rstride + 1
@@ -120,7 +124,8 @@ impl<'a, N: Scalar, R: Dim, C: Dim> MatrixSliceMN<'a, N, R, C> {
         start: usize,
         nrows: R,
         ncols: C,
-    ) -> Self {
+    ) -> Self
+    {
         Self::from_slice_with_strides_generic_unchecked(data, start, nrows, ncols, U1, nrows)
     }
 
@@ -145,7 +150,8 @@ impl<'a, N: Scalar, R: Dim, C: Dim> MatrixSliceMutMN<'a, N, R, C> {
         start: usize,
         nrows: R,
         ncols: C,
-    ) -> Self {
+    ) -> Self
+    {
         Self::from_slice_with_strides_generic_unchecked(data, start, nrows, ncols, U1, nrows)
     }
 

src/base/default_allocator.rs

@@ -54,7 +54,8 @@ where
         nrows: R,
         ncols: C,
         iter: I,
-    ) -> Self::Buffer {
+    ) -> Self::Buffer
+    {
         let mut res = unsafe { Self::allocate_uninitialized(nrows, ncols) };
         let mut count = 0;
 
@@ -93,7 +94,8 @@ impl<N: Scalar, C: Dim> Allocator<N, Dynamic, C> for DefaultAllocator {
         nrows: Dynamic,
         ncols: C,
         iter: I,
-    ) -> Self::Buffer {
+    ) -> Self::Buffer
+    {
         let it = iter.into_iter();
         let res: Vec<N> = it.collect();
         assert!(res.len() == nrows.value() * ncols.value(),
@@ -123,7 +125,8 @@ impl<N: Scalar, R: DimName> Allocator<N, R, Dynamic> for DefaultAllocator {
         nrows: R,
         ncols: Dynamic,
         iter: I,
-    ) -> Self::Buffer {
+    ) -> Self::Buffer
+    {
         let it = iter.into_iter();
         let res: Vec<N> = it.collect();
         assert!(res.len() == nrows.value() * ncols.value(),
@@ -154,7 +157,8 @@ where
         rto: RTo,
         cto: CTo,
         buf: <Self as Allocator<N, RFrom, CFrom>>::Buffer,
-    ) -> MatrixArray<N, RTo, CTo> {
+    ) -> MatrixArray<N, RTo, CTo>
+    {
         let mut res = <Self as Allocator<N, RTo, CTo>>::allocate_uninitialized(rto, cto);
 
         let (rfrom, cfrom) = buf.shape();
@@ -182,7 +186,8 @@ where
         rto: Dynamic,
         cto: CTo,
         buf: MatrixArray<N, RFrom, CFrom>,
-    ) -> MatrixVec<N, Dynamic, CTo> {
+    ) -> MatrixVec<N, Dynamic, CTo>
+    {
         let mut res = <Self as Allocator<N, Dynamic, CTo>>::allocate_uninitialized(rto, cto);
 
         let (rfrom, cfrom) = buf.shape();
@@ -210,7 +215,8 @@ where
         rto: RTo,
         cto: Dynamic,
         buf: MatrixArray<N, RFrom, CFrom>,
-    ) -> MatrixVec<N, RTo, Dynamic> {
+    ) -> MatrixVec<N, RTo, Dynamic>
+    {
         let mut res = <Self as Allocator<N, RTo, Dynamic>>::allocate_uninitialized(rto, cto);
 
         let (rfrom, cfrom) = buf.shape();
@@ -233,7 +239,8 @@ impl<N: Scalar, CFrom: Dim, CTo: Dim> Reallocator<N, Dynamic, CFrom, Dynamic, CT
         rto: Dynamic,
         cto: CTo,
         buf: MatrixVec<N, Dynamic, CFrom>,
-    ) -> MatrixVec<N, Dynamic, CTo> {
+    ) -> MatrixVec<N, Dynamic, CTo>
+    {
         let new_buf = buf.resize(rto.value() * cto.value());
         MatrixVec::new(rto, cto, new_buf)
     }
@@ -248,7 +255,8 @@ impl<N: Scalar, CFrom: Dim, RTo: DimName> Reallocator<N, Dynamic, CFrom, RTo, Dy
         rto: RTo,
         cto: Dynamic,
         buf: MatrixVec<N, Dynamic, CFrom>,
-    ) -> MatrixVec<N, RTo, Dynamic> {
+    ) -> MatrixVec<N, RTo, Dynamic>
+    {
         let new_buf = buf.resize(rto.value() * cto.value());
         MatrixVec::new(rto, cto, new_buf)
     }
@@ -263,7 +271,8 @@ impl<N: Scalar, RFrom: DimName, CTo: Dim> Reallocator<N, RFrom, Dynamic, Dynamic
         rto: Dynamic,
         cto: CTo,
         buf: MatrixVec<N, RFrom, Dynamic>,
-    ) -> MatrixVec<N, Dynamic, CTo> {
+    ) -> MatrixVec<N, Dynamic, CTo>
+    {
         let new_buf = buf.resize(rto.value() * cto.value());
         MatrixVec::new(rto, cto, new_buf)
     }
@@ -278,7 +287,8 @@ impl<N: Scalar, RFrom: DimName, RTo: DimName> Reallocator<N, RFrom, Dynamic, RTo
         rto: RTo,
         cto: Dynamic,
         buf: MatrixVec<N, RFrom, Dynamic>,
-    ) -> MatrixVec<N, RTo, Dynamic> {
+    ) -> MatrixVec<N, RTo, Dynamic>
+    {
         let new_buf = buf.resize(rto.value() * cto.value());
         MatrixVec::new(rto, cto, new_buf)
     }

src/base/dimension.rs

@@ -30,9 +30,7 @@ impl Dynamic {
 #[cfg(feature = "serde-serialize")]
 impl Serialize for Dynamic {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
+    where S: Serializer {
         self.value.serialize(serializer)
     }
 }
@@ -40,9 +38,7 @@ impl Serialize for Dynamic {
 #[cfg(feature = "serde-serialize")]
 impl<'de> Deserialize<'de> for Dynamic {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
+    where D: Deserializer<'de> {
         usize::deserialize(deserializer).map(|x| Dynamic { value: x })
     }
 }
@@ -368,7 +364,8 @@ impl<
         G: Bit + Any + Debug + Copy + PartialEq + Send + Sync,
     > IsNotStaticOne
     for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G>
-{}
+{
+}
 
 impl<U: Unsigned + DimName, B: Bit + Any + Debug + Copy + PartialEq + Send + Sync> NamedDim
     for UInt<U, B>
@@ -409,4 +406,5 @@ impl<U: Unsigned + DimName, B: Bit + Any + Debug + Copy + PartialEq + Send + Syn
 
 impl<U: Unsigned + DimName, B: Bit + Any + Debug + Copy + PartialEq + Send + Sync> IsNotStaticOne
     for UInt<U, B>
-{}
+{
+}

src/base/edition.rs

@@ -16,9 +16,7 @@ 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).
     #[inline]
     pub fn upper_triangle(&self) -> MatrixMN<N, R, C>
-    where
-        DefaultAllocator: Allocator<N, R, C>,
-    {
+    where DefaultAllocator: Allocator<N, R, C> {
         let mut res = self.clone_owned();
         res.fill_lower_triangle(N::zero(), 1);
 
@@ -28,9 +26,7 @@ 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).
     #[inline]
     pub fn lower_triangle(&self) -> MatrixMN<N, R, C>
-    where
-        DefaultAllocator: Allocator<N, R, C>,
-    {
+    where DefaultAllocator: Allocator<N, R, C> {
         let mut res = self.clone_owned();
         res.fill_upper_triangle(N::zero(), 1);
 
@@ -50,9 +46,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     /// Fills `self` with the identity matrix.
     #[inline]
     pub fn fill_with_identity(&mut self)
-    where
-        N: Zero + One,
-    {
+    where N: Zero + One {
         self.fill(N::zero());
         self.fill_diagonal(N::one());
     }
@@ -551,9 +545,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// rows and/or columns than `self`, then the extra rows or columns are filled with `val`.
     #[cfg(any(feature = "std", feature = "alloc"))]
     pub fn resize(self, new_nrows: usize, new_ncols: usize, val: N) -> DMatrix<N>
-    where
-        DefaultAllocator: Reallocator<N, R, C, Dynamic, Dynamic>,
-    {
+    where DefaultAllocator: Reallocator<N, R, C, Dynamic, Dynamic> {
         self.resize_generic(Dynamic::new(new_nrows), Dynamic::new(new_ncols), val)
     }
 
@@ -562,9 +554,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// The values are copied such that `self[(i, j)] == result[(i, j)]`. If the result has more
     /// rows and/or columns than `self`, then the extra rows or columns are filled with `val`.
     pub fn fixed_resize<R2: DimName, C2: DimName>(self, val: N) -> MatrixMN<N, R2, C2>
-    where
-        DefaultAllocator: Reallocator<N, R, C, R2, C2>,
-    {
+    where DefaultAllocator: Reallocator<N, R, C, R2, C2> {
         self.resize_generic(R2::name(), C2::name(), val)
     }
 
@@ -642,7 +632,8 @@ unsafe fn compress_rows<N: Scalar>(
     ncols: usize,
     i: usize,
     nremove: usize,
-) {
+)
+{
     let new_nrows = nrows - nremove;
 
     if new_nrows == 0 || ncols == 0 {
@@ -681,7 +672,8 @@ unsafe fn extend_rows<N: Scalar>(
     ncols: usize,
     i: usize,
     ninsert: usize,
-) {
+)
+{
     let new_nrows = nrows + ninsert;
 
     if new_nrows == 0 || ncols == 0 {

src/base/helper.rs

@@ -18,9 +18,7 @@ pub fn reject<G: Gen, F: FnMut(&T) -> bool, T: Arbitrary>(g: &mut G, f: F) -> T
 #[doc(hidden)]
 #[inline]
 pub fn reject_rand<G: Rng + ?Sized, F: FnMut(&T) -> bool, T>(g: &mut G, f: F) -> T
-where
-    Standard: Distribution<T>,
-{
+where Standard: Distribution<T> {
     use std::iter;
     iter::repeat(()).map(|_| g.gen()).find(f).unwrap()
 }

src/base/matrix.rs

@@ -99,9 +99,7 @@ where
     S: Serialize,
 {
     fn serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error>
-    where
-        T: Serializer,
-    {
+    where T: Serializer {
         self.data.serialize(serializer)
     }
 }
@@ -115,9 +113,7 @@ where
     S: Deserialize<'de>,
 {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
+    where D: Deserializer<'de> {
         S::deserialize(deserializer).map(|x| Matrix {
             data: x,
             _phantoms: PhantomData,
@@ -319,9 +315,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Moves this matrix into one that owns its data.
     #[inline]
     pub fn into_owned(self) -> MatrixMN<N, R, C>
-    where
-        DefaultAllocator: Allocator<N, R, C>,
-    {
+    where DefaultAllocator: Allocator<N, R, C> {
         Matrix::from_data(self.data.into_owned())
     }
 
@@ -355,9 +349,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Clones this matrix to one that owns its data.
     #[inline]
     pub fn clone_owned(&self) -> MatrixMN<N, R, C>
-    where
-        DefaultAllocator: Allocator<N, R, C>,
-    {
+    where DefaultAllocator: Allocator<N, R, C> {
         Matrix::from_data(self.data.clone_owned())
     }
 
@@ -393,9 +385,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Returns a matrix containing the result of `f` applied to each of its entries.
     #[inline]
     pub fn map<N2: Scalar, F: FnMut(N) -> N2>(&self, mut f: F) -> MatrixMN<N2, R, C>
-    where
-        DefaultAllocator: Allocator<N2, R, C>,
-    {
+    where DefaultAllocator: Allocator<N2, R, C> {
         let (nrows, ncols) = self.data.shape();
 
         let mut res = unsafe { MatrixMN::new_uninitialized_generic(nrows, ncols) };
@@ -541,9 +531,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Transposes `self`.
     #[inline]
     pub fn transpose(&self) -> MatrixMN<N, C, R>
-    where
-        DefaultAllocator: Allocator<N, C, R>,
-    {
+    where DefaultAllocator: Allocator<N, C, R> {
         let (nrows, ncols) = self.data.shape();
 
         unsafe {
@@ -666,9 +654,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     /// 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)
-    where
-        DefaultAllocator: Allocator<N, R, C>,
-    {
+    where DefaultAllocator: Allocator<N, R, C> {
         let (nrows, ncols) = self.shape();
 
         for j in 0..ncols {
@@ -765,9 +751,7 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<Complex<N>, R, C>> Matrix<Complex<N>, R
     /// The conjugate transposition of `self`.
     #[inline]
     pub fn conjugate_transpose(&self) -> MatrixMN<Complex<N>, C, R>
-    where
-        DefaultAllocator: Allocator<Complex<N>, C, R>,
-    {
+    where DefaultAllocator: Allocator<Complex<N>, C, R> {
         let (nrows, ncols) = self.data.shape();
 
         unsafe {
@@ -808,9 +792,7 @@ 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.
     #[inline]
     pub fn diagonal(&self) -> VectorN<N, D>
-    where
-        DefaultAllocator: Allocator<N, D>,
-    {
+    where DefaultAllocator: Allocator<N, D> {
         assert!(
             self.is_square(),
             "Unable to get the diagonal of a non-square matrix."
@@ -831,9 +813,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."
@@ -855,9 +835,7 @@ impl<N: Scalar + Zero, D: DimAdd<U1>, S: Storage<N, D>> Vector<N, D, S> {
     /// coordinates.
     #[inline]
     pub fn to_homogeneous(&self) -> VectorN<N, DimSum<D, U1>>
-    where
-        DefaultAllocator: Allocator<N, DimSum<D, U1>>,
-    {
+    where DefaultAllocator: Allocator<N, DimSum<D, U1>> {
         let len = self.len();
         let hnrows = DimSum::<D, U1>::from_usize(len + 1);
         let mut res = unsafe { VectorN::<N, _>::new_uninitialized_generic(hnrows, U1) };
@@ -923,7 +901,8 @@ where
         other: &Self,
         epsilon: Self::Epsilon,
         max_relative: Self::Epsilon,
-    ) -> bool {
+    ) -> bool
+    {
         self.relative_eq(other, epsilon, max_relative)
     }
 }
@@ -1040,7 +1019,8 @@ impl<N, R: Dim, C: Dim, S> Eq for Matrix<N, R, C, S>
 where
     N: Scalar + Eq,
     S: Storage<N, R, C>,
-{}
+{
+}
 
 impl<N, R: Dim, C: Dim, S> PartialEq for Matrix<N, R, C, S>
 where
@@ -1220,8 +1200,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>
-where
-    DefaultAllocator: Allocator<N, U3>,
+where DefaultAllocator: Allocator<N, U3>
 {
     /// Computes the matrix `M` such that for all vector `v` we have `M * v == self.cross(&v)`.
     #[inline]
@@ -1311,18 +1290,14 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     /// Returns a normalized version of this matrix.
     #[inline]
     pub fn normalize(&self) -> MatrixMN<N, R, C>
-    where
-        DefaultAllocator: Allocator<N, R, C>,
-    {
+    where DefaultAllocator: Allocator<N, R, C> {
         self / 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>>
-    where
-        DefaultAllocator: Allocator<N, R, C>,
-    {
+    where DefaultAllocator: Allocator<N, R, C> {
         let n = self.norm();
 
         if n <= min_norm {
@@ -1446,7 +1421,8 @@ where
         other: &Self,
         epsilon: Self::Epsilon,
         max_relative: Self::Epsilon,
-    ) -> bool {
+    ) -> bool
+    {
         self.as_ref()
             .relative_eq(other.as_ref(), epsilon, max_relative)
     }

src/base/matrix_alga.rs

@@ -146,8 +146,7 @@ where
 }
 
 impl<N: Real, R: DimName, C: DimName> NormedSpace for MatrixMN<N, R, C>
-where
-    DefaultAllocator: Allocator<N, R, C>,
+where DefaultAllocator: Allocator<N, R, C>
 {
     #[inline]
     fn norm_squared(&self) -> N {
@@ -181,8 +180,7 @@ where
 }
 
 impl<N: Real, R: DimName, C: DimName> InnerSpace for MatrixMN<N, R, C>
-where
-    DefaultAllocator: Allocator<N, R, C>,
+where DefaultAllocator: Allocator<N, R, C>
 {
     type Real = N;
 
@@ -202,8 +200,7 @@ where
 //   − 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>
-where
-    DefaultAllocator: Allocator<N, R, C>,
+where DefaultAllocator: Allocator<N, R, C>
 {
     #[inline]
     fn orthonormalize(vs: &mut [MatrixMN<N, R, C>]) -> usize {
@@ -236,9 +233,7 @@ where
 
     #[inline]
     fn orthonormal_subspace_basis<F>(vs: &[Self], mut f: F)
-    where
-        F: FnMut(&Self) -> bool,
-    {
+    where F: FnMut(&Self) -> bool {
         // FIXME: is this necessary?
         assert!(
             vs.len() <= Self::dimension(),

src/base/matrix_array.rs

@@ -107,7 +107,8 @@ where
     R::Value: Mul<C::Value>,
     Prod<R::Value, C::Value>: ArrayLength<N>,
     GenericArray<N, Prod<R::Value, C::Value>>: Copy,
-{}
+{
+}
 
 impl<N, R, C> Clone for MatrixArray<N, R, C>
 where
@@ -132,7 +133,8 @@ where
     C: DimName,
     R::Value: Mul<C::Value>,
     Prod<R::Value, C::Value>: ArrayLength<N>,
-{}
+{
+}
 
 impl<N, R, C> PartialEq for MatrixArray<N, R, C>
 where
@@ -182,17 +184,13 @@ where
 
     #[inline]
     fn into_owned(self) -> Owned<N, R, C>
-    where
-        DefaultAllocator: Allocator<N, R, C>,
-    {
+    where DefaultAllocator: Allocator<N, R, C> {
         self
     }
 
     #[inline]
     fn clone_owned(&self) -> Owned<N, R, C>
-    where
-        DefaultAllocator: Allocator<N, R, C>,
-    {
+    where DefaultAllocator: Allocator<N, R, C> {
         let it = self.iter().cloned();
 
         DefaultAllocator::allocate_from_iterator(self.shape().0, self.shape().1, it)
@@ -232,7 +230,8 @@ where
     R::Value: Mul<C::Value>,
     Prod<R::Value, C::Value>: ArrayLength<N>,
     DefaultAllocator: Allocator<N, R, C, Buffer = Self>,
-{}
+{
+}
 
 unsafe impl<N, R, C> ContiguousStorageMut<N, R, C> for MatrixArray<N, R, C>
 where
@@ -242,7 +241,8 @@ where
     R::Value: Mul<C::Value>,
     Prod<R::Value, C::Value>: ArrayLength<N>,
     DefaultAllocator: Allocator<N, R, C, Buffer = Self>,
-{}
+{
+}
 
 /*
  *
@@ -260,9 +260,7 @@ where
     Prod<R::Value, C::Value>: ArrayLength<N>,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
+    where S: Serializer {
         let mut serializer = serializer.serialize_seq(Some(R::dim() * C::dim()))?;
 
         for e in self.iter() {
@@ -283,9 +281,7 @@ where
     Prod<R::Value, C::Value>: ArrayLength<N>,
 {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'a>,
-    {
+    where D: Deserializer<'a> {
         deserializer.deserialize_seq(MatrixArrayVisitor::new())
     }
 }
@@ -330,9 +326,7 @@ where
 
     #[inline]
     fn visit_seq<V>(self, mut visitor: V) -> Result<MatrixArray<N, R, C>, V::Error>
-    where
-        V: SeqAccess<'a>,
-    {
+    where V: SeqAccess<'a> {
         let mut out: Self::Value = unsafe { mem::uninitialized() };
         let mut curr = 0;
 

src/base/matrix_slice.rs

@@ -91,7 +91,8 @@ slice_storage_impl!("A mutable matrix data storage for mutable matrix slice. Onl
 
 impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Copy
     for SliceStorage<'a, N, R, C, RStride, CStride>
-{}
+{
+}
 
 impl<'a, N: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Clone
     for SliceStorage<'a, N, R, C, RStride, CStride>
@@ -206,7 +207,8 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
         start: (usize, usize),
         shape: (usize, usize),
         steps: (usize, usize),
-    ) {
+    )
+    {
         let my_shape = self.shape();
         // NOTE: we don't do any subtraction to avoid underflow for zero-sized matrices.
         //
@@ -803,7 +805,8 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     pub fn rows_range<RowRange: SliceRange<R>>(
         &self,
         rows: RowRange,
-    ) -> MatrixSlice<N, RowRange::Size, C, S::RStride, S::CStride> {
+    ) -> MatrixSlice<N, RowRange::Size, C, S::RStride, S::CStride>
+    {
         self.slice_range(rows, ..)
     }
 
@@ -812,7 +815,8 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
     pub fn columns_range<ColRange: SliceRange<C>>(
         &self,
         cols: ColRange,
-    ) -> MatrixSlice<N, R, ColRange::Size, S::RStride, S::CStride> {
+    ) -> MatrixSlice<N, R, ColRange::Size, S::RStride, S::CStride>
+    {
         self.slice_range(.., cols)
     }
 }
@@ -841,7 +845,8 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     pub fn rows_range_mut<RowRange: SliceRange<R>>(
         &mut self,
         rows: RowRange,
-    ) -> MatrixSliceMut<N, RowRange::Size, C, S::RStride, S::CStride> {
+    ) -> MatrixSliceMut<N, RowRange::Size, C, S::RStride, S::CStride>
+    {
         self.slice_range_mut(rows, ..)
     }
 
@@ -850,7 +855,8 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
     pub fn columns_range_mut<ColRange: SliceRange<C>>(
         &mut self,
         cols: ColRange,
-    ) -> MatrixSliceMut<N, R, ColRange::Size, S::RStride, S::CStride> {
+    ) -> MatrixSliceMut<N, R, ColRange::Size, S::RStride, S::CStride>
+    {
         self.slice_range_mut(.., cols)
     }
 }

src/base/matrix_vec.rs

@@ -94,8 +94,7 @@ impl<N, R: Dim, C: Dim> Deref for MatrixVec<N, R, C> {
  *
  */
 unsafe impl<N: Scalar, C: Dim> Storage<N, Dynamic, C> for MatrixVec<N, Dynamic, C>
-where
-    DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>,
+where DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>
 {
     type RStride = U1;
     type CStride = Dynamic;
@@ -122,17 +121,13 @@ where
 
     #[inline]
     fn into_owned(self) -> Owned<N, Dynamic, C>
-    where
-        DefaultAllocator: Allocator<N, Dynamic, C>,
-    {
+    where DefaultAllocator: Allocator<N, Dynamic, C> {
         self
     }
 
     #[inline]
     fn clone_owned(&self) -> Owned<N, Dynamic, C>
-    where
-        DefaultAllocator: Allocator<N, Dynamic, C>,
-    {
+    where DefaultAllocator: Allocator<N, Dynamic, C> {
         self.clone()
     }
 
@@ -143,8 +138,7 @@ where
 }
 
 unsafe impl<N: Scalar, R: DimName> Storage<N, R, Dynamic> for MatrixVec<N, R, Dynamic>
-where
-    DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>,
+where DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>
 {
     type RStride = U1;
     type CStride = R;
@@ -171,17 +165,13 @@ where
 
     #[inline]
     fn into_owned(self) -> Owned<N, R, Dynamic>
-    where
-        DefaultAllocator: Allocator<N, R, Dynamic>,
-    {
+    where DefaultAllocator: Allocator<N, R, Dynamic> {
         self
     }
 
     #[inline]
     fn clone_owned(&self) -> Owned<N, R, Dynamic>
-    where
-        DefaultAllocator: Allocator<N, R, Dynamic>,
-    {
+    where DefaultAllocator: Allocator<N, R, Dynamic> {
         self.clone()
     }
 
@@ -197,8 +187,7 @@ where
  *
  */
 unsafe impl<N: Scalar, C: Dim> StorageMut<N, Dynamic, C> for MatrixVec<N, Dynamic, C>
-where
-    DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>,
+where DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>
 {
     #[inline]
     fn ptr_mut(&mut self) -> *mut N {
@@ -211,17 +200,14 @@ where
     }
 }
 
-unsafe impl<N: Scalar, C: Dim> ContiguousStorage<N, Dynamic, C> for MatrixVec<N, Dynamic, C> where
-    DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>
+unsafe impl<N: Scalar, C: Dim> ContiguousStorage<N, Dynamic, C> for MatrixVec<N, Dynamic, C> where DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>
 {}
 
-unsafe impl<N: Scalar, C: Dim> ContiguousStorageMut<N, Dynamic, C> for MatrixVec<N, Dynamic, C> where
-    DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>
+unsafe impl<N: Scalar, C: Dim> ContiguousStorageMut<N, Dynamic, C> for MatrixVec<N, Dynamic, C> where DefaultAllocator: Allocator<N, Dynamic, C, Buffer = Self>
 {}
 
 unsafe impl<N: Scalar, R: DimName> StorageMut<N, R, Dynamic> for MatrixVec<N, R, Dynamic>
-where
-    DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>,
+where DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>
 {
     #[inline]
     fn ptr_mut(&mut self) -> *mut N {
@@ -249,10 +235,8 @@ impl<N: Abomonation, R: Dim, C: Dim> Abomonation for MatrixVec<N, R, C> {
     }
 }
 
-unsafe impl<N: Scalar, R: DimName> ContiguousStorage<N, R, Dynamic> for MatrixVec<N, R, Dynamic> where
-    DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>
+unsafe impl<N: Scalar, R: DimName> ContiguousStorage<N, R, Dynamic> for MatrixVec<N, R, Dynamic> where DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>
 {}
 
-unsafe impl<N: Scalar, R: DimName> ContiguousStorageMut<N, R, Dynamic> for MatrixVec<N, R, Dynamic> where
-    DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>
+unsafe impl<N: Scalar, R: DimName> ContiguousStorageMut<N, R, Dynamic> for MatrixVec<N, R, Dynamic> where DefaultAllocator: Allocator<N, R, Dynamic, Buffer = Self>
 {}

src/base/ops.rs

@@ -724,9 +724,7 @@ impl<N: Scalar + ClosedAdd, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C,
     /// Adds a scalar to `self`.
     #[inline]
     pub fn add_scalar(&self, rhs: N) -> MatrixMN<N, R, C>
-    where
-        DefaultAllocator: Allocator<N, R, C>,
-    {
+    where DefaultAllocator: Allocator<N, R, C> {
         let mut res = self.clone_owned();
         res.add_scalar_mut(rhs);
         res
@@ -735,9 +733,7 @@ impl<N: Scalar + ClosedAdd, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C,
     /// Adds a scalar to `self` in-place.
     #[inline]
     pub fn add_scalar_mut(&mut self, rhs: N)
-    where
-        S: StorageMut<N, R, C>,
-    {
+    where S: StorageMut<N, R, C> {
         for e in self.iter_mut() {
             *e += rhs
         }