get rid of old typealiases

docs/src/counts.md

@@ -7,7 +7,7 @@ The package provides functions to count the occurrences of distinct values.
 ```@docs
 counts
 proportions
-addcounts!(r::AbstractArray, x::StatsBase.IntegerArray, levels::StatsBase.IntUnitRange)
+addcounts!(r::AbstractArray, x::AbstractArray{<:Integer}, levels::UnitRange{<:Integer})
 ```
 
 ## Counting over arbitrary distinct values

docs/src/scalarstats.md

@@ -69,7 +69,7 @@ percentile
 iqr
 nquantile
 quantile
-Statistics.median(v::StatsBase.RealVector, w::AbstractWeights{<:Real})
+Statistics.median(v::AbstractVector{<:Real}, w::AbstractWeights{<:Real})
 quantilerank
 percentilerank
 ```

src/common.jl

@@ -1,29 +1,6 @@
 # common utilities
 
-## convenient type alias
-#
-#  These types signficantly reduces the need of using
-#  type parameters in functions (which are often just
-#  for the purpose of restricting the arrays to real)
-#
-# These could be removed when the Base supports
-# covariant type notation, i.e. AbstractVector{<:Real}
-#
-
-const RealArray{T<:Real,N} = AbstractArray{T,N}
-const RealVector{T<:Real} = AbstractArray{T,1}
-const RealMatrix{T<:Real} = AbstractArray{T,2}
-
-const IntegerArray{T<:Integer,N} = AbstractArray{T,N}
-const IntegerVector{T<:Integer} = AbstractArray{T,1}
-const IntegerMatrix{T<:Integer} = AbstractArray{T,2}
-
-const RealFP = Union{Float32, Float64}
-
-# A convenient typealias for deprecating default corrected Bool
-const DepBool = Union{Bool, Nothing}
-
-function depcheck(fname::Symbol, varname::Symbol, b::DepBool)
+function depcheck(fname::Symbol, varname::Symbol, b::Union{Bool, Nothing})
     if b === nothing
         msg = "$fname will default to $varname=true in the future. Use $varname=false for previous behaviour."
         Base.depwarn(msg, fname)

src/counts.jl

@@ -6,8 +6,6 @@
 #
 #################################################
 
-const IntUnitRange{T<:Integer} = UnitRange{T}
-
 if isdefined(Base, :ht_keyindex2)
     const ht_keyindex2! = Base.ht_keyindex2
 else
@@ -24,14 +22,14 @@ array `r`. For each `xi ∈ x`, if `xi == levels[j]`, then we increment `r[j]`.
 If a weighting vector `wv` is specified, the sum of weights is used rather than the
 raw counts.
 """
-function addcounts!(r::AbstractArray, x::IntegerArray, levels::IntUnitRange)
+function addcounts!(r::AbstractArray, x::AbstractArray{<:Integer}, levels::UnitRange{<:Integer})
     # add counts of integers from x that fall within levels to r
 
     checkbounds(r, axes(levels)...)
 
     m0 = first(levels)
     m1 = last(levels)
-    b = m0 - firstindex(levels) # firstindex(levels) == 1 because levels::IntUnitRange
+    b = m0 - firstindex(levels) # firstindex(levels) == 1 because levels::UnitRange{<:Integer}
 
     @inbounds for xi in x
         if m0 <= xi <= m1
@@ -41,7 +39,7 @@ function addcounts!(r::AbstractArray, x::IntegerArray, levels::IntUnitRange)
     return r
 end
 
-function addcounts!(r::AbstractArray, x::IntegerArray, levels::IntUnitRange, wv::AbstractWeights)
+function addcounts!(r::AbstractArray, x::AbstractArray{<:Integer}, levels::UnitRange{<:Integer}, wv::AbstractWeights)
     # add wv weighted counts of integers from x that fall within levels to r
 
     length(x) == length(wv) ||
@@ -82,14 +80,14 @@ The output is a vector of length `length(levels)`.
 """
 function counts end
 
-counts(x::IntegerArray, levels::IntUnitRange) =
+counts(x::AbstractArray{<:Integer}, levels::UnitRange{<:Integer}) =
     addcounts!(zeros(Int, length(levels)), x, levels)
-counts(x::IntegerArray, levels::IntUnitRange, wv::AbstractWeights) =
+counts(x::AbstractArray{<:Integer}, levels::UnitRange{<:Integer}, wv::AbstractWeights) =
     addcounts!(zeros(eltype(wv), length(levels)), x, levels, wv)
-counts(x::IntegerArray, k::Integer) = counts(x, 1:k)
-counts(x::IntegerArray, k::Integer, wv::AbstractWeights) = counts(x, 1:k, wv)
-counts(x::IntegerArray) = counts(x, span(x))
-counts(x::IntegerArray, wv::AbstractWeights) = counts(x, span(x), wv)
+counts(x::AbstractArray{<:Integer}, k::Integer) = counts(x, 1:k)
+counts(x::AbstractArray{<:Integer}, k::Integer, wv::AbstractWeights) = counts(x, 1:k, wv)
+counts(x::AbstractArray{<:Integer}) = counts(x, span(x))
+counts(x::AbstractArray{<:Integer}, wv::AbstractWeights) = counts(x, span(x), wv)
 
 
 """
@@ -101,8 +99,8 @@ Equivalent to `counts(x, levels) / length(x)`.
 If a vector of weights `wv` is provided, the proportion of weights is computed rather
 than the proportion of raw counts.
 """
-proportions(x::IntegerArray, levels::IntUnitRange) = counts(x, levels) .* inv(length(x))
-proportions(x::IntegerArray, levels::IntUnitRange, wv::AbstractWeights) =
+proportions(x::AbstractArray{<:Integer}, levels::UnitRange{<:Integer}) = counts(x, levels) .* inv(length(x))
+proportions(x::AbstractArray{<:Integer}, levels::UnitRange{<:Integer}, wv::AbstractWeights) =
     counts(x, levels, wv) .* inv(sum(wv))
 
 """
@@ -113,14 +111,14 @@ Return the proportion of integers in 1 to `k` that occur in `x`.
 If a vector of weights `wv` is provided, the proportion of weights is computed rather
 than the proportion of raw counts.
 """
-proportions(x::IntegerArray, k::Integer) = proportions(x, 1:k)
-proportions(x::IntegerArray, k::Integer, wv::AbstractWeights) = proportions(x, 1:k, wv)
-proportions(x::IntegerArray) = proportions(x, span(x))
-proportions(x::IntegerArray, wv::AbstractWeights) = proportions(x, span(x), wv)
+proportions(x::AbstractArray{<:Integer}, k::Integer) = proportions(x, 1:k)
+proportions(x::AbstractArray{<:Integer}, k::Integer, wv::AbstractWeights) = proportions(x, 1:k, wv)
+proportions(x::AbstractArray{<:Integer}) = proportions(x, span(x))
+proportions(x::AbstractArray{<:Integer}, wv::AbstractWeights) = proportions(x, span(x), wv)
 
 #### functions for counting a single list of integers (2D)
 
-function addcounts!(r::AbstractArray, x::IntegerArray, y::IntegerArray, levels::NTuple{2,IntUnitRange})
+function addcounts!(r::AbstractArray, x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, levels::NTuple{2,UnitRange{<:Integer}})
     # add counts of pairs from zip(x,y) to r
 
     xlevels, ylevels = levels
@@ -146,8 +144,8 @@ function addcounts!(r::AbstractArray, x::IntegerArray, y::IntegerArray, levels::
     return r
 end
 
-function addcounts!(r::AbstractArray, x::IntegerArray, y::IntegerArray,
-                    levels::NTuple{2,IntUnitRange}, wv::AbstractWeights)
+function addcounts!(r::AbstractArray, x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer},
+                    levels::NTuple{2,UnitRange{<:Integer}}, wv::AbstractWeights)
     # add counts of pairs from zip(x,y) to r
 
     length(x) == length(y) == length(wv) ||
@@ -182,43 +180,43 @@ end
 
 # facet functions
 
-function counts(x::IntegerArray, y::IntegerArray, levels::NTuple{2,IntUnitRange})
+function counts(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, levels::NTuple{2,UnitRange{<:Integer}})
     addcounts!(zeros(Int, length(levels[1]), length(levels[2])), x, y, levels)
 end
 
-function counts(x::IntegerArray, y::IntegerArray, levels::NTuple{2,IntUnitRange}, wv::AbstractWeights)
+function counts(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, levels::NTuple{2,UnitRange{<:Integer}}, wv::AbstractWeights)
     addcounts!(zeros(eltype(wv), length(levels[1]), length(levels[2])), x, y, levels, wv)
 end
 
-counts(x::IntegerArray, y::IntegerArray, levels::IntUnitRange) =
+counts(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, levels::UnitRange{<:Integer}) =
     counts(x, y, (levels, levels))
-counts(x::IntegerArray, y::IntegerArray, levels::IntUnitRange, wv::AbstractWeights) =
+counts(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, levels::UnitRange{<:Integer}, wv::AbstractWeights) =
     counts(x, y, (levels, levels), wv)
 
-counts(x::IntegerArray, y::IntegerArray, ks::NTuple{2,Integer}) =
+counts(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, ks::NTuple{2,Integer}) =
     counts(x, y, (1:ks[1], 1:ks[2]))
-counts(x::IntegerArray, y::IntegerArray, ks::NTuple{2,Integer}, wv::AbstractWeights) =
+counts(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, ks::NTuple{2,Integer}, wv::AbstractWeights) =
     counts(x, y, (1:ks[1], 1:ks[2]), wv)
-counts(x::IntegerArray, y::IntegerArray, k::Integer) = counts(x, y, (1:k, 1:k))
-counts(x::IntegerArray, y::IntegerArray, k::Integer, wv::AbstractWeights) =
+counts(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, k::Integer) = counts(x, y, (1:k, 1:k))
+counts(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, k::Integer, wv::AbstractWeights) =
     counts(x, y, (1:k, 1:k), wv)
-counts(x::IntegerArray, y::IntegerArray) = counts(x, y, (span(x), span(y)))
-counts(x::IntegerArray, y::IntegerArray, wv::AbstractWeights) = counts(x, y, (span(x), span(y)), wv)
+counts(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}) = counts(x, y, (span(x), span(y)))
+counts(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, wv::AbstractWeights) = counts(x, y, (span(x), span(y)), wv)
 
-proportions(x::IntegerArray, y::IntegerArray, levels::NTuple{2,IntUnitRange}) =
+proportions(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, levels::NTuple{2,UnitRange{<:Integer}}) =
     counts(x, y, levels) .* inv(length(x))
-proportions(x::IntegerArray, y::IntegerArray, levels::NTuple{2,IntUnitRange}, wv::AbstractWeights) =
+proportions(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, levels::NTuple{2,UnitRange{<:Integer}}, wv::AbstractWeights) =
     counts(x, y, levels, wv) .* inv(sum(wv))
 
-proportions(x::IntegerArray, y::IntegerArray, ks::NTuple{2,Integer}) =
+proportions(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, ks::NTuple{2,Integer}) =
     proportions(x, y, (1:ks[1], 1:ks[2]))
-proportions(x::IntegerArray, y::IntegerArray, ks::NTuple{2,Integer}, wv::AbstractWeights) =
+proportions(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, ks::NTuple{2,Integer}, wv::AbstractWeights) =
     proportions(x, y, (1:ks[1], 1:ks[2]), wv)
-proportions(x::IntegerArray, y::IntegerArray, k::Integer) = proportions(x, y, (1:k, 1:k))
-proportions(x::IntegerArray, y::IntegerArray, k::Integer, wv::AbstractWeights) =
+proportions(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, k::Integer) = proportions(x, y, (1:k, 1:k))
+proportions(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, k::Integer, wv::AbstractWeights) =
     proportions(x, y, (1:k, 1:k), wv)
-proportions(x::IntegerArray, y::IntegerArray) = proportions(x, y, (span(x), span(y)))
-proportions(x::IntegerArray, y::IntegerArray, wv::AbstractWeights) =
+proportions(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}) = proportions(x, y, (span(x), span(y)))
+proportions(x::AbstractArray{<:Integer}, y::AbstractArray{<:Integer}, wv::AbstractWeights) =
     proportions(x, y, (span(x), span(y)), wv)
 
 

src/cov.jl

@@ -91,11 +91,11 @@ _scattermatm(x::DenseMatrix, wv::AbstractWeights, mean, dims::Int) =
 
 ## weighted cov
 covm(x::DenseMatrix, mean, w::AbstractWeights, dims::Int=1;
-     corrected::DepBool=nothing) =
+     corrected::Union{Bool, Nothing}=nothing) =
     rmul!(scattermat(x, w, mean=mean, dims=dims), varcorrection(w, depcheck(:covm, :corrected, corrected)))
 
 
-cov(x::DenseMatrix, w::AbstractWeights, dims::Int=1; corrected::DepBool=nothing) =
+cov(x::DenseMatrix, w::AbstractWeights, dims::Int=1; corrected::Union{Bool, Nothing}=nothing) =
     covm(x, mean(x, w, dims=dims), w, dims; corrected=depcheck(:cov, :corrected, corrected))
 
 function corm(x::DenseMatrix, mean, w::AbstractWeights, vardim::Int=1)
@@ -118,7 +118,7 @@ function mean_and_cov(x::DenseMatrix, dims::Int=1; corrected::Bool=true)
     return m, covm(x, m, dims, corrected=corrected)
 end
 function mean_and_cov(x::DenseMatrix, wv::AbstractWeights, dims::Int=1;
-                      corrected::DepBool=nothing)
+                      corrected::Union{Bool, Nothing}=nothing)
     m = mean(x, wv, dims=dims)
     return m, cov(x, wv, dims; corrected=depcheck(:mean_and_cov, :corrected, corrected))
 end

src/deprecates.jl

@@ -27,12 +27,12 @@ end
 @deprecate mean!(R::AbstractArray, A::AbstractArray, w::AbstractWeights, dims::Int) mean!(R, A, w, dims=dims)
 @deprecate mean(A::AbstractArray{T}, w::AbstractWeights{W}, dims::Int) where {T<:Number,W<:Real} mean(A, w, dims=dims)
 
-@deprecate wquantile(v::RealVector, w::AbstractWeights{<:Real}, p::RealVector) quantile(v, w, p)
-@deprecate wquantile(v::RealVector, w::AbstractWeights{<:Real}, p::Number) quantile(v, w, [p])[1]
-@deprecate wquantile(v::RealVector, w::RealVector, p::RealVector) quantile(v, pweights(w), p)
-@deprecate wquantile(v::RealVector, w::RealVector, p::Number) quantile(v, pweights(w), [p])[1]
-@deprecate wmedian(v::RealVector, w::AbstractWeights{<:Real}) median(v, w)
-@deprecate wmedian(v::RealVector, w::RealVector) median(v, weights(w))
+@deprecate wquantile(v::AbstractVector{<:Real}, w::AbstractWeights{<:Real}, p::AbstractVector{<:Real}) quantile(v, w, p)
+@deprecate wquantile(v::AbstractVector{<:Real}, w::AbstractWeights{<:Real}, p::Number) quantile(v, w, [p])[1]
+@deprecate wquantile(v::AbstractVector{<:Real}, w::AbstractVector{<:Real}, p::AbstractVector{<:Real}) quantile(v, pweights(w), p)
+@deprecate wquantile(v::AbstractVector{<:Real}, w::AbstractVector{<:Real}, p::Number) quantile(v, pweights(w), [p])[1]
+@deprecate wmedian(v::AbstractVector{<:Real}, w::AbstractWeights{<:Real}) median(v, w)
+@deprecate wmedian(v::AbstractVector{<:Real}, w::AbstractVector{<:Real}) median(v, weights(w))
 
 @deprecate quantile(v::AbstractArray{<:Real}) quantile(v, [.0, .25, .5, .75, 1.0])
 
@@ -41,8 +41,8 @@ end
 @deprecate values(wv::AbstractWeights) convert(Vector, wv)
 
 ### Deprecated November 2021
-@deprecate stdm(x::RealArray, w::AbstractWeights, m::Real; corrected::DepBool=nothing) std(x, w, mean=m, corrected=corrected) false
-@deprecate varm(x::RealArray, w::AbstractWeights, m::Real; corrected::DepBool=nothing) var(x, w, mean=m, corrected=corrected) false
-@deprecate stdm(x::RealArray, w::AbstractWeights, m::RealArray, dim::Int; corrected::DepBool=nothing) std(x, w, dim, mean=m, corrected=corrected) false
-@deprecate varm(x::RealArray, w::AbstractWeights, m::RealArray, dim::Int; corrected::DepBool=nothing) var(x, w, dim, mean=m, corrected=corrected) false
-@deprecate varm!(R::AbstractArray, x::RealArray, w::AbstractWeights, m::RealArray, dim::Int; corrected::DepBool=nothing) var!(R, x, w, dim, mean=m, corrected=corrected) false
+@deprecate stdm(x::AbstractArray{<:Real}, w::AbstractWeights, m::Real; corrected::Union{Bool, Nothing}=nothing) std(x, w, mean=m, corrected=corrected) false
+@deprecate varm(x::AbstractArray{<:Real}, w::AbstractWeights, m::Real; corrected::Union{Bool, Nothing}=nothing) var(x, w, mean=m, corrected=corrected) false
+@deprecate stdm(x::AbstractArray{<:Real}, w::AbstractWeights, m::AbstractArray{<:Real}, dim::Int; corrected::Union{Bool, Nothing}=nothing) std(x, w, dim, mean=m, corrected=corrected) false
+@deprecate varm(x::AbstractArray{<:Real}, w::AbstractWeights, m::AbstractArray{<:Real}, dim::Int; corrected::Union{Bool, Nothing}=nothing) var(x, w, dim, mean=m, corrected=corrected) false
+@deprecate varm!(R::AbstractArray, x::AbstractArray{<:Real}, w::AbstractWeights, m::AbstractArray{<:Real}, dim::Int; corrected::Union{Bool, Nothing}=nothing) var!(R, x, w, dim, mean=m, corrected=corrected) false

src/empirical.jl

@@ -16,7 +16,7 @@ function (ecdf::ECDF)(x::Real)
     partialsum / weightsum
 end
 
-function (ecdf::ECDF)(v::RealVector)
+function (ecdf::ECDF)(v::AbstractVector{<:Real})
     evenweights = isempty(ecdf.weights)
     weightsum = evenweights ? length(ecdf.sorted_values) : sum(ecdf.weights)
     ord = sortperm(v)
@@ -53,7 +53,7 @@ evaluate CDF values on other samples.
 `extrema`, `minimum`, and `maximum` are supported to for obtaining the range over which
 function is inside the interval ``(0,1)``; the function is defined for the whole real line.
 """
-function ecdf(X::RealVector; weights::AbstractVector{<:Real}=Weights(Float64[]))
+function ecdf(X::AbstractVector{<:Real}; weights::AbstractVector{<:Real}=Weights(Float64[]))
     any(isnan, X) && throw(ArgumentError("ecdf can not include NaN values"))
     isempty(weights) || length(X) == length(weights) || throw(ArgumentError("data and weight vectors must be the same size," *
         "got $(length(X)) and $(length(weights))"))

src/misc.jl

@@ -57,7 +57,7 @@ Reconstruct a vector from its run-length encoding (see [`rle`](@ref)).
 `vals` is a vector of the values and `lens` is a vector of the corresponding
 run lengths.
 """
-function inverse_rle(vals::AbstractVector{T}, lens::IntegerVector) where T
+function inverse_rle(vals::AbstractVector{T}, lens::AbstractVector{<:Integer}) where T
     m = length(vals)
     length(lens) == m || raise_dimerror()
 
@@ -131,7 +131,7 @@ julia> indicatormat([1 2 2], 2)
  0  1  1
 ```
 """
-function indicatormat(x::IntegerArray, k::Integer; sparse::Bool=false)
+function indicatormat(x::AbstractArray{<:Integer}, k::Integer; sparse::Bool=false)
     sparse ? _indicatormat_sparse(x, k) : _indicatormat_dense(x, k)
 end
 
@@ -151,7 +151,7 @@ indicatormat(x::AbstractArray; sparse::Bool=false) =
     indicatormat(x, sort!(unique(x)); sparse=sparse)
 
 
-function _indicatormat_dense(x::IntegerArray, k::Integer)
+function _indicatormat_dense(x::AbstractArray{<:Integer}, k::Integer)
     n = length(x)
     r = zeros(Bool, k, n)
     for i = 1 : n
@@ -174,7 +174,7 @@ function _indicatormat_dense(x::AbstractArray{T}, c::AbstractArray{T}) where T
     return r
 end
 
-_indicatormat_sparse(x::IntegerArray, k::Integer) = (n = length(x); sparse(x, 1:n, true, k, n))
+_indicatormat_sparse(x::AbstractArray{<:Integer}, k::Integer) = (n = length(x); sparse(x, 1:n, true, k, n))
 
 function _indicatormat_sparse(x::AbstractArray{T}, c::AbstractArray{T}) where T
     d = indexmap(c)
@@ -187,4 +187,3 @@ function _indicatormat_sparse(x::AbstractArray{T}, c::AbstractArray{T}) where T
     end
     return sparse(rinds, 1:n, true, m, n)
 end
-