Merge pull request #17 from jannschu/fix-typos

Fix typos in comments and documenation

Author: xd009642

README.md

@@ -47,7 +47,7 @@ assert!(report.termination.was_successful());
 
 # References
 
-Sofware:
+Software:
 
 - The [MINPACK](https://www.netlib.org/minpack/) Fortran implementation.
 - A C version/update, [lmfit][lmfit].
@@ -59,7 +59,7 @@ One original reference for the algorithm seems to be
 
 by one of the authors of MINPACK.
 
-The algorihm is also described in the form as
+The algorithm is also described in the form as
 implemented by this crate in the [book "Numerical Optimization"](https://link.springer.com/book/10.1007%2F978-0-387-40065-5) by Nocedal and Wright, chapters 4 and 10.
 
-[lmfit]: https://github.com/pkgw/pwkit/blob/master/pwkit/lmmin.py
+[lmfit]: https://jugit.fz-juelich.de/mlz/lmfit

src/lm.rs

@@ -182,7 +182,7 @@ impl<F: RealField + Float> LevenbergMarquardt<F> {
     ///   \quad\text{for all }i=1,\ldots,n.
     /// ```
     ///
-    /// This is based on the fact that those vectors are orthognal near the optimum (gradient is zero).
+    /// This is based on the fact that those vectors are orthogonal near the optimum (gradient is zero).
     /// The angle check is scale invariant, whereas checking that
     /// `$\nabla f(\vec{x})\approx \vec{0}$` is not.
     ///
@@ -250,7 +250,7 @@ impl<F: RealField + Float> LevenbergMarquardt<F> {
 
     /// Try to solve the given least squares problem.
     ///
-    /// The paramters of the problem which are set when this function is called
+    /// The parameters of the problem which are set when this function is called
     /// are used as the initial guess for `$\vec{x}$`.
     pub fn minimize<N, M, O>(&self, target: O) -> (O, MinimizationReport<F>)
     where
@@ -290,7 +290,7 @@ impl<F: RealField + Float> LevenbergMarquardt<F> {
                     determine_lambda_and_parameter_update(&mut lls, &lm.diag, lm.delta, lm.lambda);
                 let tr_iteration = lm.trust_region_iteration(&mut lls, param);
                 match tr_iteration {
-                    // successful paramter update, break and recompute Jacobian
+                    // successful parameter update, break and recompute Jacobian
                     Ok(Some(residuals)) => break residuals,
                     // terminate (either success or failure)
                     Err(reason) => return lm.into_report(reason),

src/qr.rs

@@ -42,7 +42,7 @@ where
     qr: Matrix<F, M, N, S>,
     /// Diagonal entries of R
     r_diag: OVector<F, N>,
-    /// Permution matrix. Entry `$i$` specifies which column of the identity
+    /// Permutation matrix. Entry `$i$` specifies which column of the identity
     /// matrix to use.
     permutation: OVector<usize, N>,
     work: OVector<F, N>,
@@ -211,7 +211,7 @@ where
     upper_r: OMatrix<F, DimMaximum<M, N>, N>,
     /// Diagonal entries of `$\mathbf{L}$`.
     l_diag: OVector<F, N>,
-    /// Permution matrix. Entry `$i$` specifies which column of the identity
+    /// Permutation matrix. Entry `$i$` specifies which column of the identity
     /// matrix to use.
     permutation: OVector<usize, N>,
     pub(crate) column_norms: OVector<F, N>,
@@ -364,7 +364,7 @@ where
         mut out: OVector<F, N>,
     ) -> (OVector<F, N>, CholeskyFactor<F, M, N>) {
         out.copy_from(&self.qt_b);
-        let mut rhs = self.eliminate_diag(diag, out /* will be filled and returnd */);
+        let mut rhs = self.eliminate_diag(diag, out /* will be filled and returned */);
         core::mem::swap(&mut self.work, &mut rhs);
         self.solve_after_elimination(rhs)
     }

src/utils.rs

@@ -35,10 +35,10 @@ cfg_if::cfg_if! {
 /// You can try to check your derivative implementation of an
 /// [`LeastSquaresProblem`](trait.LeastSquaresProblem.html) with this.
 ///
-/// Computing the derivatives numerically is unstable: You can construct
+/// Computing the derivatives numerically is numerically unstable: You can construct
 /// functions where the computed result is far off. If you
 /// observe large differences between the derivative computed by this function
-/// and your implementation the reason _might_ be due to instabilty.
+/// and your implementation the reason _might_ be due to instability.
 ///
 /// The achieved precision by this function
 /// is lower than the floating point precision in general. So the error is bigger