--- a/src/Grids/equidistant_grid.jl	Thu Mar 21 08:00:05 2024 +0100
+++ b/src/Grids/equidistant_grid.jl	Thu Mar 21 15:38:30 2024 +0100
@@ -103,8 +103,8 @@
 
 Note: If `limit_lower` and `limit_upper` are integers and `size` would allow a
 completely integer grid, `equidistant_grid` will still return a floating point
-grid. This simlifies the implementation and avoids certain surprise
-behaviours.
+grid. This simplifies the implementation and avoids certain surprise
+behaviors.
 """
 function equidistant_grid(size::Dims, limit_lower, limit_upper)
     gs = map(equidistant_grid, size, limit_lower, limit_upper)

--- a/src/Grids/grid.jl	Thu Mar 21 08:00:05 2024 +0100
+++ b/src/Grids/grid.jl	Thu Mar 21 15:38:30 2024 +0100
@@ -27,7 +27,7 @@
 """
     coordinate_size(g)
 
-The lenght of the coordinate vector of `Grid` `g`.
+The length of the coordinate vector of `Grid` `g`.
 """
 coordinate_size(::Type{<:Grid{T}}) where T = _ncomponents(T)
 coordinate_size(g::Grid) = coordinate_size(typeof(g)) # TBD: Name of this function?!

--- a/src/LazyTensors/lazy_array.jl	Thu Mar 21 08:00:05 2024 +0100
+++ b/src/LazyTensors/lazy_array.jl	Thu Mar 21 15:38:30 2024 +0100
@@ -1,7 +1,7 @@
 """
     LazyArray{T,D} <: AbstractArray{T,D}
 
-Array which is calcualted lazily when indexing.
+Array which is calculated lazily when indexing.
 
 A subtype of `LazyArray` will use lazy version of `+`, `-`, `*`, `/`.
 """
@@ -42,7 +42,7 @@
 
 """
     LazyElementwiseOperation{T,D,Op} <: LazyArray{T,D}
-Struct allowing for lazy evaluation of elementwise operations on `AbstractArray`s.
+Struct allowing for lazy evaluation of element-wise operations on `AbstractArray`s.
 
 A `LazyElementwiseOperation` contains two arrays together with an operation.
 The operations are carried out when the `LazyElementwiseOperation` is indexed.

--- a/src/LazyTensors/lazy_tensor_operations.jl	Thu Mar 21 08:00:05 2024 +0100
+++ b/src/LazyTensors/lazy_tensor_operations.jl	Thu Mar 21 15:38:30 2024 +0100
@@ -5,7 +5,7 @@
 
 Allows the result of a `LazyTensor` applied to a vector to be treated as an `AbstractArray`.
 With a mapping `m` and a vector `v` the TensorApplication object can be created by `m*v`.
-The actual result will be calcualted when indexing into `m*v`.
+The actual result will be calculated when indexing into `m*v`.
 """
 struct TensorApplication{T,R,D, TM<:LazyTensor{<:Any,R,D}, AA<:AbstractArray{<:Any,D}} <: LazyArray{T,R}
     t::TM
@@ -102,7 +102,7 @@
     TensorComposition(tm, tmi::IdentityTensor)
     TensorComposition(tmi::IdentityTensor, tm)
 
-Composes a `Tensormapping` `tm` with an `IdentityTensor` `tmi`, by returning `tm`
+Composes a `LazyTensor` `tm` with an `IdentityTensor` `tmi`, by returning `tm`
 """
 function TensorComposition(tm::LazyTensor{T,R,D}, tmi::IdentityTensor{T,D}) where {T,R,D}
     @boundscheck check_domain_size(tm, range_size(tmi))
@@ -125,7 +125,7 @@
 """
     InflatedTensor{T,R,D} <: LazyTensor{T,R,D}
 
-An inflated `LazyTensor` with dimensions added before and afer its actual dimensions.
+An inflated `LazyTensor` with dimensions added before and after its actual dimensions.
 """
 struct InflatedTensor{T,R,D,D_before,R_middle,D_middle,D_after, TM<:LazyTensor{T,R_middle,D_middle}} <: LazyTensor{T,R,D}
     before::IdentityTensor{T,D_before}
@@ -219,7 +219,7 @@
 @doc raw"""
     LazyOuterProduct(tms...)
 
-Creates a `TensorComposition` for the outerproduct of `tms...`.
+Creates a `TensorComposition` for the outer product of `tms...`.
 This is done by separating the outer product into regular products of outer products involving only identity mappings and one non-identity mapping.
 
 First let
@@ -278,7 +278,7 @@
 `tm`.
 
 An example of when this operation is useful is when extending a one
-dimensional difference operator `D` to a 2D grid of a ceratin size. In that
+dimensional difference operator `D` to a 2D grid of a certain size. In that
 case we could have
 
 ```julia

--- a/src/LazyTensors/tensor_types.jl	Thu Mar 21 08:00:05 2024 +0100
+++ b/src/LazyTensors/tensor_types.jl	Thu Mar 21 15:38:30 2024 +0100
@@ -1,7 +1,7 @@
 """
     IdentityTensor{T,D} <: LazyTensor{T,D,D}
 
-The lazy identity LazyTensor for a given size. Usefull for building up higher dimensional tensor mappings from lower
+The lazy identity LazyTensor for a given size. Useful for building up higher dimensional tensor mappings from lower
 dimensional ones through outer products. Also used in the Implementation for InflatedTensor.
 """
 struct IdentityTensor{T,D} <: LazyTensor{T,D,D}
@@ -57,8 +57,8 @@
 """
     DenseTensor{T,R,D,...}(A, range_indicies, domain_indicies)
 
-LazyTensor defined by the AbstractArray A. `range_indicies` and `domain_indicies` define which indicies of A should
-be considerd the range and domain of the LazyTensor. Each set of indices must be ordered in ascending order.
+LazyTensor defined by the AbstractArray A. `range_indicies` and `domain_indicies` define which indices of A should
+be considered the range and domain of the LazyTensor. Each set of indices must be ordered in ascending order.
 
 For instance, if A is a m x n matrix, and range_size = (1,), domain_size = (2,), then the DenseTensor performs the
 standard matrix-vector product on vectors of size n.

--- a/src/LazyTensors/tuple_manipulation.jl	Thu Mar 21 08:00:05 2024 +0100
+++ b/src/LazyTensors/tuple_manipulation.jl	Thu Mar 21 15:38:30 2024 +0100
@@ -3,7 +3,7 @@
 
 Splits the multi-index `I` into two parts. One part which is expected to be
 used as a view, and one which is expected to be used as an index.
-Eg.
+E.g.
 ```julia-repl
 julia> LazyTensors.split_index(1, 3, 2, 1, (1,2,3,4)...)
 ((1, Colon(), Colon(), Colon(), 4), (2, 3))
@@ -33,7 +33,7 @@
     split_tuple(t, szs)
 
 Split the tuple `t` into a set of tuples of the sizes given in `szs`.
-`sum(szs)` should equal `lenght(t)`.
+`sum(szs)` should equal `length(t)`.
 
 E.g
 ```julia-repl

--- a/src/SbpOperators/stencil_set.jl	Thu Mar 21 08:00:05 2024 +0100
+++ b/src/SbpOperators/stencil_set.jl	Thu Mar 21 15:38:30 2024 +0100
@@ -5,7 +5,7 @@
     StencilSet
 
 A `StencilSet` contains a set of associated stencils. The stencils
-are are stored in a table, and can be accesed by indexing into the `StencilSet`.
+are are stored in a table, and can be accessed by indexing into the `StencilSet`.
 """
 struct StencilSet
     table
@@ -21,7 +21,7 @@
 table of the `StencilSet` is a parsed TOML intended for functions like
 `parse_scalar` and `parse_stencil`.
 
-The `StencilSet` table is not parsed beyond the inital TOML parse. To get usable
+The `StencilSet` table is not parsed beyond the initial TOML parse. To get usable
 stencils use the `parse_stencil` functions on the fields of the stencil set.
 
 The reason for this is that since stencil sets are intended to be very