Merge pull request #226 from ArnoStrouwen/typos

typos CI

.github/dependabot.yml

@@ -5,3 +5,6 @@ updates:
     directory: "/" # Location of package manifests
     schedule:
       interval: "weekly"
+    ignore:
+      - dependency-name: "crate-ci/typos"
+        update-types: ["version-update:semver-patch"]

.github/workflows/SpellCheck.yml

@@ -0,0 +1,13 @@
+name: Spell Check
+
+on: [pull_request]
+
+jobs:
+  typos-check:
+    name: Spell Check with Typos
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Actions Repository
+        uses: actions/checkout@v3
+      - name: Check spelling
+        uses: crate-ci/[email protected] 

.typos.toml

@@ -0,0 +1,2 @@
+[default.extend-words]
+ND = "ND"

README.md

@@ -18,7 +18,7 @@ operators, fast tensor-product evaluations, pre-cached mutating
 evaluations, as well as `Zygote`-compatible non-mutating evaluations.
 
 The lazily implemented operator algebra allows the user to update the
-operator state by passing in an update function that accepts arbirary
+operator state by passing in an update function that accepts arbitrary
 parameter objects. Further, our operators behave like `AbstractMatrix` types
 thanks to  overloads defined for methods in `Base`, and `LinearAlgebra`.
 
@@ -29,7 +29,7 @@ or `NonlinearSolve.jl` as a linear/nonlinear operator, or to
 
 ## Installation
 
-`SciMLOperators.jl` is a registerd package and can be installed via
+`SciMLOperators.jl` is a registered package and can be installed via
 
 ```
 julia> import Pkg

docs/src/interface.md

@@ -35,7 +35,7 @@ interface includes, but is not limited to, the following:
   - `LinearAlgebra: mul!, ldiv!, lmul!, rmul!, factorize, issymmetric, ishermitian, isposdef`
   - `SparseArrays: sparse, issparse`
 
-## Multidimension arrays and batching
+## Multidimensional arrays and batching
 
 SciMLOperator can also be applied to `AbstractMatrix` subtypes where
 operator-evaluation is done column-wise.
@@ -134,7 +134,7 @@ L(v, u, p, t) != zero(N) # true
 ```
 
 The update behavior makes this package flexible enough to be used
-in `OrdianryDiffEq`. As the parameter object `p` is often reserved
+in `OrdinaryDiffEq`. As the parameter object `p` is often reserved
 for sensitivity computation via automatic-differentiation, a user may
 prefer to pass in state information via other arguments. For that
 reason, we allow update functions with arbitrary keyword arguments.

src/basic.jl

@@ -36,7 +36,7 @@ has_mul!(::IdentityOperator) = true
 has_ldiv(::IdentityOperator) = true
 has_ldiv!(::IdentityOperator) = true
 
-# opeator application
+# operator application
 for op in (:*, :\)
     @eval function Base.$op(ii::IdentityOperator, u::AbstractVecOrMat)
         @assert size(u, 1) == ii.len
@@ -128,7 +128,7 @@ Base.iszero(::NullOperator) = true
 has_adjoint(::NullOperator) = true
 has_mul!(::NullOperator) = true
 
-# opeator application
+# operator application
 Base.:*(nn::NullOperator, u::AbstractVecOrMat) = (@assert size(u, 1) == nn.len; zero(u))
 
 function LinearAlgebra.mul!(v::AbstractVecOrMat, nn::NullOperator, u::AbstractVecOrMat)

src/func.jl

@@ -265,7 +265,7 @@ function FunctionOperator(op,
     end
 
     if !_unwrap_val(_isinplace) & !_unwrap_val(_outofplace)
-        @error """Please provide a funciton with signatures `op(u, p, t)` for
+        @error """Please provide a function with signatures `op(u, p, t)` for
         applying the operator out-of-place, and/or the signature is
         `op(v, u, p, t)` for in-place application."""
     end
@@ -569,13 +569,13 @@ function _sizecheck(L::FunctionOperator, u, v)
             if !isa(u, AbstractVecOrMat)
                 msg = """$L constructed with `batch = true` only
                     accept input arrays that are `AbstractVecOrMat`s with
-                    `size(L, 2) == size(u, 1)`. Recieved $(typeof(u))."""
+                    `size(L, 2) == size(u, 1)`. Received $(typeof(u))."""
                 throw(ArgumentError(msg))
             end
 
             if size(L, 2) != size(u, 1)
                 msg = """$L accepts input `AbstractVecOrMat`s of size
-                    ($(size(L, 2)), K). Recievd array of size $(size(u))."""
+                    ($(size(L, 2)), K). Received array of size $(size(u))."""
                 throw(DimensionMismatch(msg))
             end
         end # u
@@ -584,13 +584,13 @@ function _sizecheck(L::FunctionOperator, u, v)
             if !isa(v, AbstractVecOrMat)
                 msg = """$L constructed with `batch = true` only
                     returns output arrays that are `AbstractVecOrMat`s with
-                    `size(L, 1) == size(v, 1)`. Recieved $(typeof(v))."""
+                    `size(L, 1) == size(v, 1)`. Received $(typeof(v))."""
                 throw(ArgumentError(msg))
             end
 
             if size(L, 1) != size(v, 1)
                 msg = """$L accepts output `AbstractVecOrMat`s of size
-                    ($(size(L, 1)), K). Recievd array of size $(size(v))."""
+                    ($(size(L, 1)), K). Received array of size $(size(v))."""
                 throw(DimensionMismatch(msg))
             end
         end # v
@@ -611,7 +611,7 @@ function _sizecheck(L::FunctionOperator, u, v)
     else # !batch
         if !isnothing(u)
             if size(u) ∉ (sizes[1], tuple(size(L, 2)))
-                msg = """$L recievd input array of size $(size(u)), but only
+                msg = """$L received input array of size $(size(u)), but only
                     accepts input arrays of size $(sizes[1]), or vectors like
                     `vec(u)` of size $(tuple(prod(sizes[1])))."""
                 throw(DimensionMismatch(msg))
@@ -620,7 +620,7 @@ function _sizecheck(L::FunctionOperator, u, v)
 
         if !isnothing(v)
             if size(v) ∉ (sizes[2], tuple(size(L, 1)))
-                msg = """$L recievd output array of size $(size(v)), but only
+                msg = """$L received output array of size $(size(v)), but only
                     accepts output arrays of size $(sizes[2]), or vectors like
                     `vec(u)` of size $(tuple(prod(sizes[2])))"""
                 throw(DimensionMismatch(msg))

src/matrix.jl

@@ -219,7 +219,7 @@ $SIGNATURES
 
 Represents an elementwise scaling (diagonal-scaling) operation that may
 be applied to an `AbstractVecOrMat`. When `diag` is an `AbstractVector`
-of length N, `L = DiagonalOpeator(diag, ...)` can be applied to
+of length N, `L = DiagonalOperator(diag, ...)` can be applied to
 `AbstractArray`s with `size(u, 1) == N`. Each column of the `u` will be
 scaled by `diag`, as in `LinearAlgebra.Diagonal(diag) * u`.