Add Previous and Next for Constant interpolation (#512)

* extended Constant docstring
* Docstrings for nearest, previous, next
* Extend example for previous, next
* Previous and Next with Gridded Interpolation
* Update docs/src/control.md
* Update src/b-splines/constant.jl
* Added note for const and scaling

Co-authored-by: Mark Kittisopikul <mkitti@users.noreply.github.com>

Author: judober

docs/src/control.md

@@ -14,6 +14,14 @@ Some examples:
 itp = interpolate(a, BSpline(Constant()))
 v = itp(5.4)   # returns a[5]
 
+# Previous-neighbor interpolation
+itp = interpolate(a, BSpline(Constant(Previous)))
+v = itp(1.8)   # returns a[1]
+
+# Next-neighbor interpolation
+itp = interpolate(a, BSpline(Constant(Next)))
+v = itp(5.4)   # returns a[6]
+
 # (Multi)linear interpolation
 itp = interpolate(A, BSpline(Linear()))
 v = itp(3.2, 4.1)  # returns 0.9*(0.8*A[3,4]+0.2*A[4,4]) + 0.1*(0.8*A[3,5]+0.2*A[4,5])
@@ -111,6 +119,10 @@ NoInterp()
 whereby the coordinate of the selected input vector MUST be located on a grid point. Requests for off grid
 coordinates results in the throwing of an error.
 
+For [`Constant`](@ref) there are additional parameters. Use `Constant{Previous}()` in order to perform a previous
+neighbor interpolation. Use `Constant{Next}()` for a next neighbor interpolation.
+Note that rounding can be an issue, see [#473](https://github.com/JuliaMath/Interpolations.jl/issues/473).
+
 `missing` data will naturally propagate through the interpolation,
 where some values will become missing. To avoid that, one can
 filter out the missing data points and use a gridded interpolation.

src/b-splines/constant.jl

@@ -1,8 +1,32 @@
 export Nearest, Previous, Next
 
 abstract type ConstantInterpType end
+
+"""
+Default parameter for `Constant` that performs *nearest-neighbor* interpolation.
+Can optionally be specified as
+```
+Constant() === Constant{Nearest}()
+```
+"""
 struct Nearest <: ConstantInterpType end
+
+"""
+Parameter for `Constant` that performs *previous-neighbor* interpolations.
+Applied through 
+´´´
+Constant{Previous}()
+´´´
+"""
 struct Previous <: ConstantInterpType end
+
+"""
+Parameter for `Constant` that performs *next-neighbor* interpolations.
+Applied through 
+```
+Constant{Next}()
+```
+"""
 struct Next <: ConstantInterpType end
 
 struct Constant{T<:ConstantInterpType,BC<:Union{Throw{OnGrid},Periodic{OnCell}}} <: DegreeBC{0}
@@ -30,7 +54,13 @@ end
 
 """
 Constant b-splines are *nearest-neighbor* interpolations, and effectively
-return `A[round(Int,x)]` when interpolating.
+return `A[round(Int,x)]` when interpolating without scaling.
+Scaling can lead to inaccurate position of the *neighbors* due to limited numerical precision.
+
+`Constant{Previous}` interpolates to the previous value and is thus equivalent
+to `A[floor(Int,x)]` without scaling.
+`Constant{Next}` interpolates to the next value and is thus equivalent
+to `A[ceil(Int,x)]` without scaling.
 """
 Constant