Allow non-Real eltype with quantile

This is consistent with `Statistics.quantile` and avoids breakage due to #977.
It's particularly useful for `Union{T, Missing}`, e.g. a view of nonmissing entries
in a vector. This also allows supporting some types such as `Date`, though currently
this only works for some values (would need to implement `type=1`).

Author: nalimilan

src/weights.jl

@@ -626,7 +626,7 @@ is strictly superior to ``h``. The weighted ``p`` quantile is given by ``v_k + 
 with ``γ = (h - S_k)/(S_{k+1} - S_k)``. In particular, when all weights are equal,
 the function returns the same result as the unweighted `quantile`.
 """
-function quantile(v::AbstractVector{V}, w::AbstractWeights{W}, p::AbstractVector{<:Real}) where {V<:Real,W<:Real}
+function quantile(v::AbstractVector{V}, w::AbstractWeights{W}, p::AbstractVector{<:Real}) where {V, W<:Real}
     # checks
     isempty(v) && throw(ArgumentError("quantile of an empty array is undefined"))
     isempty(p) && throw(ArgumentError("empty quantile array"))
@@ -650,24 +650,32 @@ function quantile(v::AbstractVector{V}, w::AbstractWeights{W}, p::AbstractVector
     vw = sort!(collect(zip(view(v, nz), view(w, nz))))
     N = length(vw)
 
+    # missing is always sorted last
+    if ismissing(vw[end][1])
+        throw(ArgumentError("quantiles are undefined in presence of missing values"))
+    end
+
     # prepare percentiles
     ppermute = sortperm(p)
     p = p[ppermute]
 
     # prepare out vector
-    out = Vector{typeof(zero(V)/1)}(undef, length(p))
+    v1 = vw[1][1]
+    out = Vector{typeof(v1 + zero(eltype(p))*zero(W)*zero(v1))}(undef, length(p))
     fill!(out, vw[end][1])
 
-    for x in v
-        isnan(x) && return fill!(out, x)
+    # NaN is always sorted last in the absence of missing
+    # This behavior isn't consistent with Statistics.quantile, but preserve it for backward compatibility
+    if vw[end][1] isa Number && isnan(vw[end][1])
+        return fill(vw[end][1], length(p))
     end
 
     # loop on quantiles
+    w1 = vw[1][2]
     Sk, Skold = zero(W), zero(W)
-    vk, vkold = zero(V), zero(V)
+    vk, vkold = zero(v1), zero(v1)
     k = 0
 
-    w1 = vw[1][2]
     for i in 1:length(p)
         if isa(w, FrequencyWeights)
             h = p[i] * (wsum - 1) + 1
@@ -693,19 +701,19 @@ function quantile(v::AbstractVector{V}, w::AbstractWeights{W}, p::AbstractVector
     return out
 end
 
-function quantile(v::AbstractVector{<:Real}, w::UnitWeights, p::AbstractVector{<:Real})
+function quantile(v::AbstractVector, w::UnitWeights, p::AbstractVector{<:Real})
     length(v) != length(w) && throw(DimensionMismatch("Inconsistent array dimension."))
     return quantile(v, p)
 end
 
-quantile(v::AbstractVector{<:Real}, w::AbstractWeights{<:Real}, p::Number) = quantile(v, w, [p])[1]
+quantile(v::AbstractVector, w::AbstractWeights, p::Real) = quantile(v, w, [p])[1]
 
 ##### Weighted median #####
 
 """
-    median(v::AbstractVector{<:Real}, w::AbstractWeights)
+    median(v::AbstractVector, w::AbstractWeights)
 
 Compute the weighted median of `v` with weights `w`
 (of type `AbstractWeights`). See the documentation for [`quantile`](@ref) for more details.
 """
-median(v::AbstractVector{<:Real}, w::AbstractWeights{<:Real}) = quantile(v, w, 0.5)
+median(v::AbstractVector, w::AbstractWeights) = quantile(v, w, 0.5)

test/weights.jl

@@ -459,6 +459,14 @@ end
     w = [1, 1/3, 1/3, 1/3, 1]
     answer = 6.0
     @test quantile(data[1], f(w), 0.5) ≈ answer atol = 1e-5
+
+    # Test non-Real eltype
+    @test_throws ArgumentError quantile([missing, 1], f([1, 2]), 0.5)
+    @test quantile(Union{Float64, Missing}[1, 2, 3, 4], f([1, 2, 2, 1]), 0.5) ==
+        quantile(Any[1, 2, 3, 4], f([1, 2, 2, 1]), 0.5) ==
+        quantile([1, 2, 3, 4], f([1, 2, 2, 1]), 0.5)
+    @test quantile([Date(2005, 01, 01), Date(2005, 01, 01)], f([1, 1]), 0.5) ==
+        Date(2005, 01, 01)
 end
 
 @testset "Median $f" for f in weight_funcs