Typos

src/arnoldi.jl

@@ -15,7 +15,7 @@ m = arnoldi!(Hess, q, m, Ψ, H, dt=1.0; extended=true, norm_min=1e-15)
 
 Calculate the Hessenberg matrix and Arnoldi vectors of `H dt`, from `Ψ`.
 
-For a given order `m`, the `m×m` Hessemberg matrix is calculated and stored in
+For a given order `m`, the `m×m` Hessenberg matrix is calculated and stored in
 in the pre-allocated `Hess`. Further  an array of `m` normalized Arnoldi
 vectors is stored in in the pre-allocated `q`, plus one additional unnormalized
 Arnoldi vector.  The unnormalized `m+1`st vector could be used to easily
@@ -36,13 +36,13 @@ the algorithm.
 
 # Arguments
 
-- `Hess::Matrix{ComplexF64}`: Pre-allocated storage for the Hessemberg matrix.
+- `Hess::Matrix{ComplexF64}`: Pre-allocated storage for the Hessenberg matrix.
    Can be uninitialized on input. The matrix must be at least of size `m×m`, or
    `(m+1)×(m+1)` if `extended=true`. On output, the `m×m` sub-matrix of `Hess`
    (with the returned output `m`) will contain the Hessenberg matrix, and all
    other elements of `Hess` be be set to zero.
 - `q`: Pre-allocated array of states similar to `Ψ`, as storage for the
-  calculated Arnoldi vectors. These may be un-initialized on input. Must be at
+  calculated Arnoldi vectors. These may be uninitialized on input. Must be at
   least of length `m+1`
 - `m`: The requested dimensions of the output Hessenberg matrix.
 - `Ψ`: The starting vector for the Arnoldi procedure. This can be of any type,
@@ -134,10 +134,10 @@ end
 diagonalize_hessenberg_matrix(Hess, m; accumulate=false)
 ```
 
-Diagonalize the m × m top left submatrix of the given Hessenberg matrix.
+Diagonalize the m × m top left sub-matrix of the given Hessenberg matrix.
 
 If `accumulate` is `true`, return the concatenated eigenvalues for
-`Hess[1:1,1:1]` to `Hess[1:m,1:m]`, that is, all sumatrices of size 1 through
+`Hess[1:1,1:1]` to `Hess[1:m,1:m]`, that is, all sub-matrices of size 1 through
 `m`.
 """
 function diagonalize_hessenberg_matrix(Hess, m; accumulate=false)

src/controls.jl

@@ -464,7 +464,7 @@ function evaluate!(op::T, generator::T, args...; kwargs...) where {T}
         return op
     else
         # If they're not identical, they shouldn't be of the same type. If
-        # there's some weird custom type where static and timedependent
+        # there's some weird custom type where static and time-dependent
         # objects can be of the same type, they should define a custom method.
         error("typeof(op) = typeof(generator), but op ≢ generator")
     end

src/newton.jl

@@ -83,13 +83,13 @@ necessary and may have a size of up to `2*(n+n_use)`.
 
 # Arguments
 
-- `leja`: Array of leja values. Must contain the "old" leja values to be kept
-   in `leja(0:n-1)`. On output, `n_use` new leja points will be in
+- `leja`: Array of Leja values. Must contain the "old" Leja values to be kept
+   in `leja(0:n-1)`. On output, `n_use` new Leja points will be in
    `leja(n+:n+n_use-1)`, for the original value of `n`.  The `leja` array must
    use zero-based indexing.
-- `n`: On input, number of "old" leja points in `leja`. On output, total number
-  of leja points (i.e. `n=n+n_use`)
-- `newpoints`: On input, candidate points for new leja points.  The `n_use`
+- `n`: On input, number of "old" Leja points in `leja`. On output, total number
+  of Leja points (i.e. `n=n+n_use`)
+- `newpoints`: On input, candidate points for new Leja points.  The `n_use`
   best values will be chosen and added to `leja`. On output, the values of
   `new_points` are undefined.
 - `n_use`: Number of points that should be added to `leja`

src/propagate.jl

@@ -18,7 +18,7 @@ map_observables(::_StoreState, tlist, i, state::Vector) = state
 # Work around https://github.com/timholy/ProgressMeter.jl/issues/214
 import ProgressMeter
 struct NoProgress end
-ProgressMeter.next!(p::NoProgress) = nothing
+ProgressMeter.next!(::NoProgress) = nothing
 
 
 """Propagate a state over an entire time grid.
@@ -89,7 +89,7 @@ routine performs the following three steps:
   `state` is `true`.
 * `piecewise`: If given as a boolean, ensure that the internal `propagator` is
   an instance of [`PiecewisePropagator`](@ref), cf. [`init_prop`](@ref).
-* `pwc`: If given a a boolean, do a piecewise constant propagation where the
+* `pwc`: If given a boolean, do a piecewise constant propagation where the
   generator in each interval is constant (the internal `propagator` is a
   [`PWCPropagator`](@ref), cf. [`init_prop`](@ref))
 * `storage`: Flag whether to store and return the propagated states /

src/specrad.jl

@@ -115,7 +115,7 @@ end
 E_min, E_max = specrange(H, :diag)
 ```
 
-uses exact diagonization via the standard `eigvals` function to obtain the
+uses exact diagonalization via the standard `eigvals` function to obtain the
 smallest and largest eigenvalue. This should only be used for relatively small
 matrices.
 """