Typo fixes.

CHANGELOG.md

@@ -130,7 +130,7 @@ This adds support for serialization using the
 
 Pure Rust implementation of some Blas operations:
 
-  * `.iamax()` retuns the index of the maximum value of a vector.
+  * `.iamax()` returns the index of the maximum value of a vector.
   * `.axpy(...)` computes `self = a * x + b * self`.
   * `.gemv(...)` computes `self = alpha * a * x + beta * self` with a matrix and vector `a` and `x`.
   * `.ger(...)` computes `self = alpha * x^t * y + beta * self` where `x` and `y` are vectors.
@@ -367,7 +367,7 @@ crate for vectors, rotations and points. To enable them, activate the
 
 ## [0.7.0]
 ### Added
-  * Added implementation of assignement operators (+=, -=, etc.) for
+  * Added implementation of assignment operators (+=, -=, etc.) for
     everything.
 ### Modified
   * Points and vectors are now linked to each other with associated types

nalgebra-glm/src/ext/matrix_clip_space.rs

@@ -90,7 +90,7 @@ pub fn ortho<N: Real>(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) -
 //    unimplemented!()
 //}
 
-/// Creates a matrix for a symetric perspective-view frustum based on the right handedness and OpenGL near and far clip planes definition.
+/// Creates a matrix for a symmetric perspective-view frustum based on the right handedness and OpenGL near and far clip planes definition.
 pub fn perspective<N: Real>(fovy: N, aspect: N, near: N, far: N) -> TMat4<N> {
     Perspective3::new(fovy, aspect, near, far).unwrap()
 }

nalgebra-glm/src/ext/matrix_projection.rs

@@ -64,7 +64,7 @@ pub fn project_zo<N: Real>(obj: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>, vi
     )
 }
 
-/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates using OpengGL near and far clip planes definition.
+/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates using OpenGL near and far clip planes definition.
 ///
 /// # Parameters
 ///     * `obj`: Specify the window coordinates to be mapped.
@@ -119,4 +119,4 @@ pub fn unproject_zo<N: Real>(win: &TVec3<N>, model: &TMat4<N>, proj: &TMat4<N>,
 
     let result = transform * pt;
     result.fixed_rows::<U3>(0) / result.w
-}
+}

nalgebra-glm/src/gtx/rotate_vector.rs

@@ -56,7 +56,7 @@ pub fn rotate_z_vec4<N: Real>(v: &TVec4<N>, angle: N) -> TVec4<N> {
     Rotation3::from_axis_angle(&TVec3::z_axis(), angle).to_homogeneous() * v
 }
 
-/// Computes a spehical linear interpolation between the vectors `x` and `y` assumed to be normalized.
+/// 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()
 }

nalgebra-glm/src/lib.rs

@@ -50,13 +50,13 @@
     * Functions operating in 2d will usually end with the `2d` suffix, e.g., `glm::rotade2d` is for 2D while `glm::rotate` is for 3D.
     * Functions operating on vector will often end with the `_vec` suffix, possibly followed by the dimension of vector, e.g., `glm::rotate_vec2`.
     * Every function related to quaternions start with the `quat_` prefix, e.g., `glm::quat_dot(q1, q2)`.
-    * All the conversion functions have unique names as described [bellow](#conversions).
+    * 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)` will create a 3D vector.
     * Using the `::new` constructor. For example `Vec3::new(x, y, z)` 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])` will create a 3D vector.
-    Keep in mind that constructing a matrix using this type of funcitons require its components to be arrange in column-major order on the slice.
+    Keep in mind that constructing a matrix using this type of functions require its components to be arrange in column-major order on the slice.
     * Using a geometric construction function. For example `glm::rotation(angle, axis)` 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
@@ -184,4 +184,4 @@ mod exponential;
 
 mod ext;
 mod gtc;
-mod gtx;
+mod gtx;

nalgebra-lapack/src/cholesky.rs

@@ -11,7 +11,7 @@ use na::{DefaultAllocator, Matrix, MatrixMN, MatrixN, Scalar};
 
 use lapack;
 
-/// The cholesky decomposion of a symmetric-definite-positive matrix.
+/// The cholesky decomposition of a symmetric-definite-positive matrix.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
@@ -50,7 +50,7 @@ impl<N: CholeskyScalar + Zero, D: Dim> Cholesky<N, D>
 where
     DefaultAllocator: Allocator<N, D, D>,
 {
-    /// Complutes the cholesky decomposition of the given symmetric-definite-positive square
+    /// Computes the cholesky decomposition of the given symmetric-definite-positive square
     /// matrix.
     ///
     /// Only the lower-triangular part of the input matrix is considered.
@@ -183,7 +183,7 @@ where
  *
  */
 /// Trait implemented by floats (`f32`, `f64`) and complex floats (`Complex<f32>`, `Complex<f64>`)
-/// supported by the cholesky decompotition.
+/// supported by the cholesky decomposition.
 pub trait CholeskyScalar: Scalar {
     #[allow(missing_docs)]
     fn xpotrf(uplo: u8, n: i32, a: &mut [Self], lda: i32, info: &mut i32);

nalgebra-lapack/src/eigen.rs

@@ -317,7 +317,7 @@ where
  * Lapack functions dispatch.
  *
  */
-/// Trait implemented by scalar type for which Lapack funtion exist to compute the
+/// Trait implemented by scalar type for which Lapack function exist to compute the
 /// eigendecomposition.
 pub trait EigenScalar: Scalar {
     #[allow(missing_docs)]

nalgebra-lapack/src/lu.rs

@@ -244,7 +244,7 @@ where
 
     /// Solves in-place the linear system `self * x = b`, where `x` is the unknown to be determined.
     ///
-    /// Retuns `false` if no solution was found (the decomposed matrix is singular).
+    /// 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>,
@@ -255,7 +255,7 @@ where
     /// Solves in-place the linear system `self.transpose() * x = b`, where `x` is the unknown to be
     /// determined.
     ///
-    /// Retuns `false` if no solution was found (the decomposed matrix is singular).
+    /// 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>,
@@ -266,7 +266,7 @@ where
     /// Solves in-place the linear system `self.conjugate_transpose() * x = b`, where `x` is the unknown to
     /// be determined.
     ///
-    /// Retuns `false` if no solution was found (the decomposed matrix is singular).
+    /// Returns `false` if no solution was found (the decomposed matrix is singular).
     pub fn solve_conjugate_transpose_mut<R2: Dim, C2: Dim>(
         &self,
         b: &mut MatrixMN<N, R2, C2>,

nalgebra-lapack/src/qr.rs

@@ -171,7 +171,7 @@ where
  * Lapack functions dispatch.
  *
  */
-/// Trait implemented by scalar types for which Lapack funtion exist to compute the
+/// Trait implemented by scalar types for which Lapack function exist to compute the
 /// QR decomposition.
 pub trait QRScalar: Scalar {
     fn xgeqrf(
@@ -195,7 +195,7 @@ pub trait QRScalar: Scalar {
     ) -> i32;
 }
 
-/// Trait implemented by reals for which Lapack funtion exist to compute the
+/// Trait implemented by reals for which Lapack function exist to compute the
 /// QR decomposition.
 pub trait QRReal: QRScalar {
     #[allow(missing_docs)]

nalgebra-lapack/src/schur.rs

@@ -59,14 +59,14 @@ impl<N: RealSchurScalar + Real, D: Dim> RealSchur<N, D>
 where
     DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,
 {
-    /// Computes the eigenvalues and real Schur foorm of the matrix `m`.
+    /// Computes the eigenvalues and real Schur form of the matrix `m`.
     ///
     /// Panics if the method did not converge.
     pub fn new(m: MatrixN<N, D>) -> Self {
         Self::try_new(m).expect("RealSchur decomposition: convergence failed.")
     }
 
-    /// Computes the eigenvalues and real Schur foorm of the matrix `m`.
+    /// Computes the eigenvalues and real Schur form of the matrix `m`.
     ///
     /// Returns `None` if the method did not converge.
     pub fn try_new(mut m: MatrixN<N, D>) -> Option<Self> {

src/base/blas.rs

@@ -180,7 +180,7 @@ where
         let mut res = N::zero();
 
         // We have to define them outside of the loop (and not inside at first assignment)
-        // otherwize vectorization won't kick in for some reason.
+        // otherwise vectorization won't kick in for some reason.
         let mut acc0;
         let mut acc1;
         let mut acc2;
@@ -527,7 +527,7 @@ where
             let is_dynamic = R1::is::<Dynamic>() || C1::is::<Dynamic>() || R2::is::<Dynamic>()
                 || C2::is::<Dynamic>() || R3::is::<Dynamic>()
                 || C3::is::<Dynamic>();
-            // Thershold determined ampirically.
+            // Threshold determined empirically.
             const SMALL_DIM: usize = 5;
 
             if is_dynamic && nrows1 > SMALL_DIM && ncols1 > SMALL_DIM && nrows2 > SMALL_DIM

src/base/componentwise.rs

@@ -1,4 +1,4 @@
-// Non-convensional componentwise operators.
+// Non-conventional componentwise operators.
 
 use num::{Signed, Zero};
 use std::ops::{Add, Mul};

src/base/matrix.rs

@@ -58,7 +58,7 @@ pub type MatrixCross<N, R1, C1, R2, C2> =
 /// components.
 ///
 /// The matrix dimensions parameters `R` and `C` can either be:
-/// - type-level unsigned integer contants (e.g. `U1`, `U124`) from the `nalgebra::` root module.
+/// - type-level unsigned integer constants (e.g. `U1`, `U124`) from the `nalgebra::` root module.
 /// All numbers from 0 to 127 are defined that way.
 /// - type-level unsigned integer constants (e.g. `U1024`, `U10000`) from the `typenum::` crate.
 /// Using those, you will not get error messages as nice as for numbers smaller than 128 defined on
@@ -1298,7 +1298,7 @@ impl<N: Real, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
 
     /// Normalizes this matrix in-place or does nothing if its norm is smaller or equal to `eps`.
     ///
-    /// If the normalization succeded, returns the old normal of this matrix.
+    /// If the normalization succeeded, returns the old normal of this matrix.
     #[inline]
     pub fn try_normalize_mut(&mut self, min_norm: N) -> Option<N> {
         let n = self.norm();

src/base/matrix_slice.rs

@@ -676,8 +676,8 @@ pub trait SliceRange<D: Dim> {
 
     /// The start index of the range.
     fn begin(&self, shape: D) -> usize;
-    // NOTE: this is the index immediatly after the last index.
-    /// The index immediatly after the last index inside of the range.
+    // NOTE: this is the index immediately after the last index.
+    /// The index immediately after the last index inside of the range.
     fn end(&self, shape: D) -> usize;
     /// The number of elements of the range, i.e., `self.end - self.begin`.
     fn size(&self, shape: D) -> Self::Size;

src/base/matrix_vec.rs

@@ -58,10 +58,10 @@ impl<N, R: Dim, C: Dim> MatrixVec<N, R, C> {
         &mut self.data
     }
 
-    /// Resizes the undelying mutable data storage and unrwaps it.
+    /// Resizes the underlying mutable data storage and unwraps it.
     ///
     /// If `sz` is larger than the current size, additional elements are uninitialized.
-    /// If `sz` is smaller than the current size, additional elements are trucated.
+    /// If `sz` is smaller than the current size, additional elements are truncated.
     #[inline]
     pub unsafe fn resize(mut self, sz: usize) -> Vec<N> {
         let len = self.len();

src/base/ops.rs

@@ -124,7 +124,7 @@ where
 
 /*
  *
- * Addition & Substraction
+ * Addition & Subtraction
  *
  */
 
@@ -415,7 +415,7 @@ macro_rules! componentwise_scalarop_impl(
 
                 // XXX: optimize our iterator!
                 //
-                // Using our own iterator prevents loop unrolling, wich breaks some optimization
+                // Using our own iterator prevents loop unrolling, which breaks some optimization
                 // (like SIMD). On the other hand, using the slice iterator is 4x faster.
 
                 // for left in res.iter_mut() {
@@ -469,7 +469,7 @@ macro_rules! left_scalar_mul_impl(
 
                 // XXX: optimize our iterator!
                 //
-                // Using our own iterator prevents loop unrolling, wich breaks some optimization
+                // Using our own iterator prevents loop unrolling, which breaks some optimization
                 // (like SIMD). On the other hand, using the slice iterator is 4x faster.
 
                 // for rhs in res.iter_mut() {

src/base/scalar.rs

@@ -7,7 +7,7 @@ use std::any::Any;
 /// This does not make any assumption on the algebraic properties of `Self`.
 pub trait Scalar: Copy + PartialEq + Debug + Any {
     #[inline]
-    /// Tests if `Self` the the same as the type `T`
+    /// Tests if `Self` the same as the type `T`
     ///
     /// Typically used to test of `Self` is a f32 or a f64 with `N::is::<f32>()`.
     fn is<T: Scalar>() -> bool {

src/base/storage.rs

@@ -50,7 +50,7 @@ pub unsafe trait Storage<N: Scalar, R: Dim, C: Dim = U1>: Debug + Sized {
     /// element of any dimension. Must be equal to `Self::dimension()` if it is not `None`.
     fn shape(&self) -> (R, C);
 
-    /// The spacing between concecutive row elements and consecutive column elements.
+    /// The spacing between consecutive row elements and consecutive column elements.
     ///
     /// For example this returns `(1, 5)` for a row-major matrix with 5 columns.
     fn strides(&self) -> (Self::RStride, Self::CStride);

src/base/unit.rs

@@ -13,9 +13,9 @@ use abomonation::Abomonation;
 use alga::general::SubsetOf;
 use alga::linear::NormedSpace;
 
-/// A wrapper that ensures the undelying algebraic entity has a unit norm.
+/// A wrapper that ensures the underlying algebraic entity has a unit norm.
 ///
-/// Use `.as_ref()` or `.unwrap()` to obtain the undelying value by-reference or by-move.
+/// Use `.as_ref()` or `.unwrap()` to obtain the underlying value by-reference or by-move.
 #[repr(C)]
 #[derive(Eq, PartialEq, Clone, Hash, Debug, Copy)]
 pub struct Unit<T> {
@@ -187,7 +187,7 @@ where
 //     }
 // }
 
-// FIXME:re-enable this impl when spacialization is possible.
+// FIXME:re-enable this impl when specialization is possible.
 // Currently, it is disabled so that we can have a nice output for the `UnitQuaternion` display.
 /*
 impl<T: fmt::Display> fmt::Display for Unit<T> {

src/geometry/isometry_ops.rs

@@ -378,7 +378,7 @@ isometry_from_composition_impl_all!(
     (D, D), (D, U1) for D: DimName;
     self: Rotation<N, D>, right: Isometry<N, D, Rotation<N, D>>,
     Output = Isometry<N, D, Rotation<N, D>>;
-    // FIXME: don't call iverse explicitly?
+    // FIXME: don't call inverse explicitly?
     [val val] => self * right.inverse();
     [ref val] => self * right.inverse();
     [val ref] => self * right.inverse();

src/geometry/op_macros.rs

@@ -5,7 +5,7 @@
 /// Macro for the implementation of multiplication and division.
 macro_rules! md_impl(
     (
-    // Operator, operator method, and calar bounds.
+    // Operator, operator method, and scalar bounds.
      $Op: ident, $op: ident $(where N: $($ScalarBounds: ident),*)*;
      // Storage dimensions, and dimension bounds.
      ($R1: ty, $C1: ty),($R2: ty, $C2: ty) for $($Dims: ident: $DimsBound: ident $(<$($BoundParam: ty),*>)*),+
@@ -13,7 +13,7 @@ macro_rules! md_impl(
      $(where $ConstraintType: ty: $ConstraintBound: ident<$($ConstraintBoundParams: ty $( = $EqBound: ty )*),*> )*;
      // Argument identifiers and types + output.
      $lhs: ident: $Lhs: ty, $rhs: ident: $Rhs: ty, Output = $Result: ty;
-     // Operator actual mplementation.
+     // Operator actual implementation.
      $action: expr;
      // Lifetime.
      $($lives: tt),*) => {
@@ -38,7 +38,7 @@ macro_rules! md_impl(
 /// Implements all the argument reference combinations.
 macro_rules! md_impl_all(
     (
-     // Operator, operator method, and calar bounds.
+     // Operator, operator method, and scalar bounds.
      $Op: ident, $op: ident $(where N: $($ScalarBounds: ident),*)*;
      // Storage dimensions, and dimension bounds.
      ($R1: ty, $C1: ty),($R2: ty, $C2: ty) for $($Dims: ident: $DimsBound: ident $(<$($BoundParam: ty),*>)*),+
@@ -82,7 +82,7 @@ macro_rules! md_impl_all(
     }
 );
 
-/// Macro for the implementation of assignement-multiplication and assignement-division.
+/// Macro for the implementation of assignment-multiplication and assignment-division.
 macro_rules! md_assign_impl(
     (
      // Operator, operator method, and scalar bounds.
@@ -109,7 +109,7 @@ macro_rules! md_assign_impl(
     }
 );
 
-/// Macro for the implementation of assignement-multiplication and assignement-division with and
+/// Macro for the implementation of assignment-multiplication and assignment-division with and
 /// without reference to the right-hand-side.
 macro_rules! md_assign_impl_all(
     (
@@ -165,7 +165,7 @@ macro_rules! add_sub_impl(
 );
 
 // FIXME: merge with `md_assign_impl`.
-/// Macro for the implementation of assignement-addition and assignement-subtraction.
+/// Macro for the implementation of assignment-addition and assignment-subtraction.
 macro_rules! add_sub_assign_impl(
     ($Op: ident, $op: ident, $bound: ident;
      ($R1: ty, $C1: ty),($R2: ty, $C2: ty) for $($Dims: ident: $DimsBound: ident),+;

src/geometry/perspective.rs

@@ -149,19 +149,19 @@ impl<N: Real> Perspective3<N> {
         self.matrix
     }
 
-    /// Gets the `width / height` aspect ratio of the view frustrum.
+    /// Gets the `width / height` aspect ratio of the view frustum.
     #[inline]
     pub fn aspect(&self) -> N {
         self.matrix[(1, 1)] / self.matrix[(0, 0)]
     }
 
-    /// Gets the y field of view of the view frustrum.
+    /// Gets the y field of view of the view frustum.
     #[inline]
     pub fn fovy(&self) -> N {
         (N::one() / self.matrix[(1, 1)]).atan() * ::convert(2.0)
     }
 
-    /// Gets the near plane offset of the view frustrum.
+    /// Gets the near plane offset of the view frustum.
     #[inline]
     pub fn znear(&self) -> N {
         let ratio = (-self.matrix[(2, 2)] + N::one()) / (-self.matrix[(2, 2)] - N::one());
@@ -169,7 +169,7 @@ impl<N: Real> Perspective3<N> {
         self.matrix[(2, 3)] / (ratio * ::convert(2.0)) - self.matrix[(2, 3)] / ::convert(2.0)
     }
 
-    /// Gets the far plane offset of the view frustrum.
+    /// Gets the far plane offset of the view frustum.
     #[inline]
     pub fn zfar(&self) -> N {
         let ratio = (-self.matrix[(2, 2)] + N::one()) / (-self.matrix[(2, 2)] - N::one());
@@ -219,7 +219,7 @@ impl<N: Real> Perspective3<N> {
     }
 
     /// Updates this perspective matrix with a new `width / height` aspect ratio of the view
-    /// frustrum.
+    /// frustum.
     #[inline]
     pub fn set_aspect(&mut self, aspect: N) {
         assert!(
@@ -229,7 +229,7 @@ impl<N: Real> Perspective3<N> {
         self.matrix[(0, 0)] = self.matrix[(1, 1)] / aspect;
     }
 
-    /// Updates this perspective with a new y field of view of the view frustrum.
+    /// Updates this perspective with a new y field of view of the view frustum.
     #[inline]
     pub fn set_fovy(&mut self, fovy: N) {
         let old_m22 = self.matrix[(1, 1)];
@@ -237,21 +237,21 @@ impl<N: Real> Perspective3<N> {
         self.matrix[(0, 0)] = self.matrix[(0, 0)] * (self.matrix[(1, 1)] / old_m22);
     }
 
-    /// Updates this perspective matrix with a new near plane offset of the view frustrum.
+    /// Updates this perspective matrix with a new near plane offset of the view frustum.
     #[inline]
     pub fn set_znear(&mut self, znear: N) {
         let zfar = self.zfar();
         self.set_znear_and_zfar(znear, zfar);
     }
 
-    /// Updates this perspective matrix with a new far plane offset of the view frustrum.
+    /// Updates this perspective matrix with a new far plane offset of the view frustum.
     #[inline]
     pub fn set_zfar(&mut self, zfar: N) {
         let znear = self.znear();
         self.set_znear_and_zfar(znear, zfar);
     }
 
-    /// Updates this perspective matrix with new near and far plane offsets of the view frustrum.
+    /// Updates this perspective matrix with new near and far plane offsets of the view frustum.
     #[inline]
     pub fn set_znear_and_zfar(&mut self, znear: N, zfar: N) {
         self.matrix[(2, 2)] = (zfar + znear) / (znear - zfar);

src/geometry/point_construction.rs

@@ -53,7 +53,7 @@ where
 
 /*
  *
- * Traits that buid points.
+ * Traits that build points.
  *
  */
 impl<N: Scalar + Bounded, D: DimName> Bounded for Point<N, D>

src/geometry/quaternion.rs

@@ -391,7 +391,7 @@ impl<N: Real> UnitQuaternion<N> {
     pub fn angle(&self) -> N {
         let w = self.quaternion().scalar().abs();
 
-        // Handle innacuracies that make break `.acos`.
+        // Handle inaccuracies that make break `.acos`.
         if w >= N::one() {
             N::zero()
         } else {
@@ -507,7 +507,7 @@ impl<N: Real> UnitQuaternion<N> {
         Unit::try_new(v, N::zero())
     }
 
-    /// The rotation axis of this unit quaternion multiplied by the rotation agle.
+    /// The rotation axis of this unit quaternion multiplied by the rotation angle.
     #[inline]
     pub fn scaled_axis(&self) -> Vector3<N> {
         if let Some(axis) = self.axis() {

src/geometry/quaternion_construction.rs

@@ -278,7 +278,7 @@ impl<N: Real> UnitQuaternion<N> {
         if let Some(axis) = Unit::try_new(c, N::default_epsilon()) {
             let cos = na.dot(&nb);
 
-            // The cosinus may be out of [-1, 1] because of innacuracies.
+            // The cosinus may be out of [-1, 1] because of inaccuracies.
             if cos <= -N::one() {
                 return None;
             } else if cos >= N::one() {

src/geometry/reflection.rs

@@ -44,7 +44,7 @@ impl<N: Real, D: Dim, S: Storage<N, D>> Reflection<N, D, S> {
         &self.axis
     }
 
-    // FIXME: naming convension: reflect_to, reflect_assign ?
+    // FIXME: naming convention: reflect_to, reflect_assign ?
     /// Applies the reflection to the columns of `rhs`.
     pub fn reflect<R2: Dim, C2: Dim, S2>(&self, rhs: &mut Matrix<N, R2, C2, S2>)
     where

src/geometry/rotation_ops.rs

@@ -53,7 +53,7 @@ md_impl_all!(
 );
 
 // Rotation ÷ Rotation
-// FIXME: instead of calling inverse explicitely, could we just add a `mul_tr` or `mul_inv` method?
+// FIXME: instead of calling inverse explicitly, could we just add a `mul_tr` or `mul_inv` method?
 md_impl_all!(
     Div, div;
     (D, D), (D, D) for D: DimName;

src/geometry/rotation_specialization.rs

@@ -35,7 +35,7 @@ impl<N: Real> Rotation2<N> {
         Self::new(axisangle[0])
     }
 
-    /// The rotation matrix required to align `a` and `b` but with its angl.
+    /// The rotation matrix required to align `a` and `b` but with its angle.
     ///
     /// This is the rotation `R` such that `(R * a).angle(b) == 0 && (R * a).dot(b).is_positive()`.
     #[inline]
@@ -279,7 +279,7 @@ impl<N: Real> Rotation3<N> {
         Self::new_observer_frame(dir, up).inverse()
     }
 
-    /// The rotation matrix required to align `a` and `b` but with its angl.
+    /// The rotation matrix required to align `a` and `b` but with its angle.
     ///
     /// This is the rotation `R` such that `(R * a).angle(b) == 0 && (R * a).dot(b).is_positive()`.
     #[inline]

src/geometry/similarity.rs

@@ -246,8 +246,8 @@ where
     }
 }
 
-// NOTE: we don't require `R: Rotation<...>` here becaus this is not useful for the implementation
-// and makes it harde to use it, e.g., for Transform × Isometry implementation.
+// NOTE: we don't require `R: Rotation<...>` here because this is not useful for the implementation
+// and makes it harder to use it, e.g., for Transform × Isometry implementation.
 // This is OK since all constructors of the isometry enforce the Rotation bound already (and
 // explicit struct construction is prevented by the private scaling factor).
 impl<N: Real, D: DimName, R> Similarity<N, D, R>

src/geometry/similarity_construction.rs

@@ -65,7 +65,7 @@ where
     R: AlgaRotation<Point<N, D>>,
     DefaultAllocator: Allocator<N, D>,
 {
-    /// The similarity that applies tha scaling factor `scaling`, followed by the rotation `r` with
+    /// The similarity that applies the scaling factor `scaling`, followed by the rotation `r` with
     /// its axis passing through the point `p`.
     #[inline]
     pub fn rotation_wrt_point(r: R, p: Point<N, D>, scaling: N) -> Self {
@@ -135,7 +135,7 @@ macro_rules! similarity_construction_impl(
                 Self::from_isometry(Isometry::<_, U3, $Rot>::new(translation, axisangle), scaling)
             }
 
-            /// Creates an similarity that corresponds to the a scaling factor and a local frame of
+            /// Creates an similarity that corresponds to a scaling factor and a local frame of
             /// an observer standing at the point `eye` and looking toward `target`.
             ///
             /// It maps the view direction `target - eye` to the positive `z` axis and the origin to the

src/geometry/similarity_ops.rs

@@ -445,7 +445,7 @@ similarity_from_composition_impl_all!(
     (D, D), (D, U1) for D: DimName;
     self: Rotation<N, D>, right: Similarity<N, D, Rotation<N, D>>,
     Output = Similarity<N, D, Rotation<N, D>>;
-    // FIXME: don't call iverse explicitly?
+    // FIXME: don't call inverse explicitly?
     [val val] => self * right.inverse();
     [ref val] => self * right.inverse();
     [val ref] => self * right.inverse();

src/geometry/transform.rs

@@ -256,7 +256,7 @@ where
         self.matrix
     }
 
-    /// A reference to the underlynig matrix.
+    /// A reference to the underlying matrix.
     #[inline]
     pub fn matrix(&self) -> &MatrixN<N, DimNameSum<D, U1>> {
         &self.matrix

src/geometry/translation_ops.rs

@@ -31,7 +31,7 @@ add_sub_impl!(Mul, mul, ClosedAdd;
     Translation::from_vector(self.vector + right.vector); );
 
 // Translation ÷ Translation
-// FIXME: instead of calling inverse explicitely, could we just add a `mul_tr` or `mul_inv` method?
+// FIXME: instead of calling inverse explicitly, could we just add a `mul_tr` or `mul_inv` method?
 add_sub_impl!(Div, div, ClosedSub;
     (D, U1), (D, U1) -> (D) for D: DimName;
     self: &'a Translation<N, D>, right: &'b Translation<N, D>, Output = Translation<N, D>;

src/geometry/unit_complex_construction.rs

@@ -35,7 +35,7 @@ impl<N: Real> UnitComplex<N> {
         Self::new(angle)
     }
 
-    /// Builds the unit complex number frow the sinus and cosinus of the rotation angle.
+    /// Builds the unit complex number from the sinus and cosinus of the rotation angle.
     ///
     /// The input values are not checked.
     #[inline]

src/lib.rs

@@ -233,8 +233,8 @@ where
 ///
 /// In particular:
 ///     * If `min < val < max`, this returns `val`.
-///     * If `val <= min`, this retuns `min`.
-///     * If `val >= max`, this retuns `max`.
+///     * If `val <= min`, this returns `min`.
+///     * If `val >= max`, this returns `max`.
 #[inline]
 pub fn clamp<T: PartialOrd>(val: T, min: T, max: T) -> T {
     if val > min {

src/linalg/cholesky.rs

@@ -9,7 +9,7 @@ use constraint::{SameNumberOfRows, ShapeConstraint};
 use dimension::{Dim, DimSub, Dynamic};
 use storage::{Storage, StorageMut};
 
-/// The Cholesky decomposion of a symmetric-definite-positive matrix.
+/// The Cholesky decomposition of a symmetric-definite-positive matrix.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 #[cfg_attr(
     feature = "serde-serialize",
@@ -50,7 +50,7 @@ where
 {
     /// Attempts to compute the Cholesky decomposition of `matrix`.
     ///
-    /// Returns `None` if the input matrix is not definite-positive. The intput matrix is assumed
+    /// Returns `None` if the input matrix is not definite-positive. The input matrix is assumed
     /// to be symmetric and only the lower-triangular part is read.
     pub fn new(mut matrix: MatrixN<N, D>) -> Option<Self> {
         assert!(matrix.is_square(), "The input matrix must be square.");
@@ -157,7 +157,7 @@ where
 {
     /// Attempts to compute the Cholesky decomposition of this matrix.
     ///
-    /// Returns `None` if the input matrix is not definite-positive. The intput matrix is assumed
+    /// Returns `None` if the input matrix is not definite-positive. The input matrix is assumed
     /// to be symmetric and only the lower-triangular part is read.
     pub fn cholesky(self) -> Option<Cholesky<N, D>> {
         Cholesky::new(self.into_owned())

src/linalg/full_piv_lu.rs

@@ -174,7 +174,7 @@ where
 {
     /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
     ///
-    /// Retuns `None` if the decomposed matrix is not invertible.
+    /// Returns `None` if the decomposed matrix is not invertible.
     pub fn solve<R2: Dim, C2: Dim, S2>(
         &self,
         b: &Matrix<N, R2, C2, S2>,

src/linalg/householder.rs

@@ -112,7 +112,7 @@ where
     let dim = m.data.shape().0;
 
     // NOTE: we could build the identity matrix and call p_mult on it.
-    // Instead we don't so that we take in accout the matrix sparcity.
+    // Instead we don't so that we take in account the matrix sparseness.
     let mut res = MatrixN::identity_generic(dim, dim);
 
     for i in (0..dim.value() - 1).rev() {

src/linalg/inverse.rs

@@ -118,7 +118,7 @@ impl<N: Real, D: Dim, S: StorageMut<N, D, D>> SquareMatrix<N, D, S> {
     }
 }
 
-// NOTE: this is an extremely efficient, loop-unrolled matrix inverse from MESA (MIT licenced).
+// NOTE: this is an extremely efficient, loop-unrolled matrix inverse from MESA (MIT licensed).
 fn do_inverse4<N: Real, D: Dim, S: StorageMut<N, D, D>>(
     m: &MatrixN<N, D>,
     out: &mut SquareMatrix<N, D, S>,

src/linalg/qr.rs

@@ -107,7 +107,7 @@ where
         let (nrows, ncols) = self.qr.data.shape();
 
         // NOTE: we could build the identity matrix and call q_mul on it.
-        // Instead we don't so that we take in accout the matrix sparcity.
+        // Instead we don't so that we take in account the matrix sparseness.
         let mut res = Matrix::identity_generic(nrows, nrows.min(ncols));
         let dim = self.diag.len();
 

src/linalg/schur.rs

@@ -72,7 +72,7 @@ where
     ///
     /// # Arguments
     ///
-    /// * `eps`       − tolerence used to determine when a value converged to 0.
+    /// * `eps`       − tolerance used to determine when a value converged to 0.
     /// * `max_niter` − maximum total number of iterations performed by the algorithm. If this
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.
@@ -519,7 +519,7 @@ where
     ///
     /// # Arguments
     ///
-    /// * `eps`       − tolerence used to determine when a value converged to 0.
+    /// * `eps`       − tolerance used to determine when a value converged to 0.
     /// * `max_niter` − maximum total number of iterations performed by the algorithm. If this
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.
@@ -536,7 +536,7 @@ where
 
         let mut work = unsafe { VectorN::new_uninitialized_generic(self.data.shape().0, U1) };
 
-        // Special case for 2x2 natrices.
+        // Special case for 2x2 matrices.
         if self.nrows() == 2 {
             // FIXME: can we avoid this slicing
             // (which is needed here just to transform D to U2)?

src/linalg/solve.rs

@@ -8,7 +8,7 @@ use base::{DefaultAllocator, Matrix, MatrixMN, SquareMatrix, Vector};
 
 impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     /// Computes the solution of the linear system `self . x = b` where `x` is the unknown and only
-    /// the lower-triangular part of `self` (including the diagonal) is concidered not-zero.
+    /// the lower-triangular part of `self` (including the diagonal) is considered not-zero.
     #[inline]
     pub fn solve_lower_triangular<R2: Dim, C2: Dim, S2>(
         &self,
@@ -28,7 +28,7 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     }
 
     /// Computes the solution of the linear system `self . x = b` where `x` is the unknown and only
-    /// the upper-triangular part of `self` (including the diagonal) is concidered not-zero.
+    /// the upper-triangular part of `self` (including the diagonal) is considered not-zero.
     #[inline]
     pub fn solve_upper_triangular<R2: Dim, C2: Dim, S2>(
         &self,
@@ -48,7 +48,7 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     }
 
     /// Solves the linear system `self . x = b` where `x` is the unknown and only the
-    /// lower-triangular part of `self` (including the diagonal) is concidered not-zero.
+    /// lower-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
         b: &mut Matrix<N, R2, C2, S2>,
@@ -98,7 +98,7 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
 
     // FIXME: add the same but for solving upper-triangular.
     /// Solves the linear system `self . x = b` where `x` is the unknown and only the
-    /// lower-triangular part of `self` is concidered not-zero. The diagonal is never read as it is
+    /// lower-triangular part of `self` is considered not-zero. The diagonal is never read as it is
     /// assumed to be equal to `diag`. Returns `false` and does not modify its inputs if `diag` is zero.
     pub fn solve_lower_triangular_with_diag_mut<R2: Dim, C2: Dim, S2>(
         &self,
@@ -130,7 +130,7 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     }
 
     /// Solves the linear system `self . x = b` where `x` is the unknown and only the
-    /// upper-triangular part of `self` (including the diagonal) is concidered not-zero.
+    /// upper-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
         b: &mut Matrix<N, R2, C2, S2>,
@@ -185,7 +185,7 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
      */
 
     /// Computes the solution of the linear system `self.transpose() . x = b` where `x` is the unknown and only
-    /// the lower-triangular part of `self` (including the diagonal) is concidered not-zero.
+    /// the lower-triangular part of `self` (including the diagonal) is considered not-zero.
     #[inline]
     pub fn tr_solve_lower_triangular<R2: Dim, C2: Dim, S2>(
         &self,
@@ -205,7 +205,7 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     }
 
     /// Computes the solution of the linear system `self.transpose() . x = b` where `x` is the unknown and only
-    /// the upper-triangular part of `self` (including the diagonal) is concidered not-zero.
+    /// the upper-triangular part of `self` (including the diagonal) is considered not-zero.
     #[inline]
     pub fn tr_solve_upper_triangular<R2: Dim, C2: Dim, S2>(
         &self,
@@ -225,7 +225,7 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     }
 
     /// Solves the linear system `self.transpose() . x = b` where `x` is the unknown and only the
-    /// lower-triangular part of `self` (including the diagonal) is concidered not-zero.
+    /// lower-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn tr_solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
         b: &mut Matrix<N, R2, C2, S2>,
@@ -272,7 +272,7 @@ impl<N: Real, D: Dim, S: Storage<N, D, D>> SquareMatrix<N, D, S> {
     }
 
     /// Solves the linear system `self.transpose() . x = b` where `x` is the unknown and only the
-    /// upper-triangular part of `self` (including the diagonal) is concidered not-zero.
+    /// upper-triangular part of `self` (including the diagonal) is considered not-zero.
     pub fn tr_solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
         &self,
         b: &mut Matrix<N, R2, C2, S2>,

src/linalg/svd.rs

@@ -94,7 +94,7 @@ where
     ///
     /// * `compute_u` − set this to `true` to enable the computation of left-singular vectors.
     /// * `compute_v` − set this to `true` to enable the computation of left-singular vectors.
-    /// * `eps`       − tolerence used to determine when a value converged to 0.
+    /// * `eps`       − tolerance used to determine when a value converged to 0.
     /// * `max_niter` − maximum total number of iterations performed by the algorithm. If this
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.
@@ -251,7 +251,7 @@ where
                 end -= 1;
             }
 
-            // Re-delimit the suproblem in case some decoupling occured.
+            // Re-delimit the subproblem in case some decoupling occurred.
             let sub = Self::delimit_subproblem(&mut b, &mut u, &mut v_t, end, eps);
             start = sub.0;
             end = sub.1;
@@ -593,7 +593,7 @@ where
     ///
     /// * `compute_u` − set this to `true` to enable the computation of left-singular vectors.
     /// * `compute_v` − set this to `true` to enable the computation of left-singular vectors.
-    /// * `eps`       − tolerence used to determine when a value converged to 0.
+    /// * `eps`       − tolerance used to determine when a value converged to 0.
     /// * `max_niter` − maximum total number of iterations performed by the algorithm. If this
     /// number of iteration is exceeded, `None` is returned. If `niter == 0`, then the algorithm
     /// continues indefinitely until convergence.

src/linalg/symmetric_eigen.rs

@@ -214,7 +214,7 @@ where
                 end -= 1;
             }
 
-            // Re-delimit the suproblem in case some decoupling occured.
+            // Re-delimit the subproblem in case some decoupling occurred.
             let sub = Self::delimit_subproblem(&diag, &mut off_diag, end, eps);
 
             start = sub.0;
@@ -297,7 +297,7 @@ where
 pub fn wilkinson_shift<N: Real>(tmm: N, tnn: N, tmn: N) -> N {
     let sq_tmn = tmn * tmn;
     if !sq_tmn.is_zero() {
-        // We have the guarantee thet the denominator won't be zero.
+        // We have the guarantee that the denominator won't be zero.
         let d = (tmm - tnn) * ::convert(0.5);
         tnn - sq_tmn / (d + d.signum() * (d * d + sq_tmn).sqrt())
     } else {