typos

Author: spaette

doc/Interpolations.jl.ipynb

@@ -96,7 +96,7 @@
    "source": [
     "You'll notice that when creating the quadratic interpolation, we had to give another input parameter to the interpolation type: the `Line(OnCell())` argument which specifies the boundary condition. The first term (`Line`) specifies the behavior of the boundary condition, the second (`OnCell`) specifies where it applies. In this case `yitp_quadratic` will become linear for `x < 0.5` or `x > 10.5`. The alternative, `OnGrid`, would apply the boundary condition for `x < 1` or `x > 10`.\n",
     "\n",
-    "All interpolations of quadratic degree or higher require a prefiltering step, which entails solving a tridiagonal system of equations (details can be found for example in [this paper](http://dx.doi.org/10.1109/42.875199)), in order to make the interpolating function pass through the data points. `Interpolations.jl` takes care of solving this system for you, but in order to close the system a boundary condition is requred."
+    "All interpolations of quadratic degree or higher require a prefiltering step, which entails solving a tridiagonal system of equations (details can be found for example in [this paper](http://dx.doi.org/10.1109/42.875199)), in order to make the interpolating function pass through the data points. `Interpolations.jl` takes care of solving this system for you, but in order to close the system a boundary condition is required."
    ]
   },
   {

doc/Interpolations_algebra.nb

@@ -153,7 +153,7 @@ that\n\np(1) = 0\np(0) = q(1)\np\[CloseCurlyQuote](1) = 0\n\
 p\[CloseCurlyQuote](0) = q\[CloseCurlyQuote](1)\nq\[CloseCurlyQuote](0) = 0\n\
 p\[CloseCurlyQuote]\[CloseCurlyQuote](1) = 0\np\[CloseCurlyQuote]\
 \[CloseCurlyQuote](0) = q\[CloseCurlyQuote]\[CloseCurlyQuote](1)\n\nThese \
-conditions are satisifed by the following cubic polynomials (TODO: show \
+conditions are satisfied by the following cubic polynomials (TODO: show \
 derivation somehow -- I just took it from Tim\[CloseCurlyQuote]s notes):"
 }], "Text",
  CellChangeTimes->{{3.656419693589711*^9, 3.6564199581451*^9}, {
@@ -362,7 +362,7 @@ Cell[BoxData[{
      "]"}], "/.", "params"}]}], "\[IndentingNewLine]", 
   RowBox[{"(*", " ", 
    RowBox[{
-   "To", " ", "analyzy", " ", "bounary", " ", "conditions", " ", "we", " ", 
+   "To", " ", "analyze", " ", "boundary", " ", "conditions", " ", "we", " ", 
     "also", " ", "want", " ", "first", " ", "and", " ", "second", " ", 
     "derivatives", " ", "of", " ", "y"}], " ", 
    "*)"}]}], "\[IndentingNewLine]", 

doc/Math.md

@@ -57,6 +57,6 @@ abstract Interpolation{IT<:InterpolationType,EB<:ExtrapolationBehavior}
 
 1. For this reason, linear B-splines are often referred to as *2nd order*, which may be a source of confusion since the interpolating function itself is linear, i.e. of first order. In `Interpolations.jl`, we will try to avoid this confusion by referring to interpolation degree by "linear", "quadratic" etc.
 
-2. Although the separation of concepts 1-3 from extrapolation behavior is computationally sound, it does allow for some interesting, yet probably nonsensical, combinations of interpolation degrees, boundary conditions and extrapolation behavior. One could imagine for example a constant interpolation (which needs no boundary condition) with linear extrapolation, in which case the interpolating function is a sequence of "steps" with 0-derivative inside the domain, while suddenly having a nonzero derivative outside. Similarly, in most cases where the extrapolation behavior is defined as constant or reflecting, it will make sense to specify matching boundary conditions, but other combinations are entirely supported by `Interpolations.jl`; your milage may vary, very much...
+2. Although the separation of concepts 1-3 from extrapolation behavior is computationally sound, it does allow for some interesting, yet probably nonsensical, combinations of interpolation degrees, boundary conditions and extrapolation behavior. One could imagine for example a constant interpolation (which needs no boundary condition) with linear extrapolation, in which case the interpolating function is a sequence of "steps" with 0-derivative inside the domain, while suddenly having a nonzero derivative outside. Similarly, in most cases where the extrapolation behavior is defined as constant or reflecting, it will make sense to specify matching boundary conditions, but other combinations are entirely supported by `Interpolations.jl`; your mileage may vary, very much...
 
 </sup>

src/b-splines/indexing.jl

@@ -98,7 +98,7 @@ function weightedindexes(parts::Vararg{Union{Int,GradParts},N}) where N
     #       gwik are gradient-coefficient WeightedIndexes along dimension k
     #       i2 is the integer index along dimension 2
     # These will result in a 2-vector gradient.
-    # TODO: check whether this is inferrable
+    # TODO: check whether this is inferable
     slot_substitute(parts, map(positions, parts), map(valuecoefs, parts), map(gradcoefs, parts))
 end
 
@@ -127,7 +127,7 @@ end
 # Substitute the dth dimension's gradient coefs for the remaining coefs, column by column
 slot_substitute(kind::Tuple, p, v, g, h) = (_column(kind, kind, p, v, g, h)..., slot_substitute(Base.tail(kind), p, v, g, h)...)
 slot_substitute(::Tuple{}, p, v, g, h) = ()
-# inner: calulate a single column
+# inner: calculate a single column
 function _column(kind1::K, kind2::K, p, v, g, h) where {K<:Tuple}
     ss = substitute_ruled(v, kind1, h)
     (map(maybe_weightedindex, p, ss), _column(Base.tail(kind1), kind2, p, v, g, h)...)

src/convenience-constructors.jl

@@ -1,4 +1,4 @@
-# convenience copnstructors for constant / linear / cubic spline interpolations
+# convenience constructors for constant / linear / cubic spline interpolations
 # 1D version
 constant_interpolation(range::AbstractRange, vs::AbstractVector; extrapolation_bc = Throw()) =
     extrapolate(scale(interpolate(vs, BSpline(Constant())), range), extrapolation_bc)

src/gpu_support.jl

@@ -59,7 +59,7 @@ end
 """
     Interpolations.root_storage_type(::Type{<:AbstractInterpolation}) -> Type{<:AbstractArray}
 
-This function returns the type of the root cofficients array of an `AbstractInterpolation`.
+This function returns the type of the root coefficients array of an `AbstractInterpolation`.
 Some array wrappers, like `OffsetArray`, should be skipped.
 """
 root_storage_type(::Type{T}) where {T<:AbstractInterpolation} = Array{eltype(T),ndims(T)} # fallback to `Array` by default.

src/iterate.jl

@@ -182,7 +182,7 @@ function checkbounds(::Type{Bool}, iter::KnotIterator{T,ET}, idx::Int) where {T,
 end
 
 # Returns the knot given by idx, or raise a BoundsError
-# Despatches to getknotindex(ET, iter, idx) if idx is an extrapolated knot,
+# Dispatches to getknotindex(ET, iter, idx) if idx is an extrapolated knot,
 # where ET is the boundary conditions for the relevant side
 function getindex(iter::KnotIterator{T, ET}, idx::Int) where {T, ET <: ExtrapDimSpec}
     # Get Left/Right Extrapolation Boundary Conditions for the KnotIterator

src/monotonic/monotonic.jl

@@ -75,7 +75,7 @@ Monotonic interpolation based on Akima (1970),
 "A New Method of Interpolation and Smooth Curve Fitting Based on Local Procedures",
 doi:10.1145/321607.321609.
 
-Tagents are dertermined at each given point locally,
+Tangents are determined at each given point locally,
 results are close to manual drawn curves
 """
 struct AkimaMonotonicInterpolation <: MonotonicInterpolationType

src/utils.jl

@@ -28,7 +28,7 @@ check1(args) = _check1(true, args...)
 @inline _check1(tf, a, args...) = _check1(tf & (a == 1), args...)
 _check1(tf) = tf
 
-# These are not inferrable for mixed-type tuples, so when that's important use `getfirst`
+# These are not inferable for mixed-type tuples, so when that's important use `getfirst`
 # and `getrest` instead.
 iextract(f::Flag, d) = f
 iextract(t::Tuple, d) = t[d]