Convert to floating point numbers where it makes sense

Author: andrewjradcliffe

src/utils.jl

@@ -12,7 +12,18 @@ _denom(A, ::Colon) = length(A)
 @inline _reducedsize(A::AbstractArray{T, N}, dims::NTuple{M, Int}) where {T, N, M} = ntuple(d -> d ∈ dims ? 1 : size(A, d), Val(N))
 
 #### Numerical stability/limits
-_xlogx(x::T) where {T} = ifelse(iszero(x), zero(T), x * log(x))
-_xlogy(x::T, y::T) where {T} = ifelse(iszero(x) & !isnan(y), zero(T), x * log(y))
+function _xlogx(x::T) where {T<:AbstractFloat}
+    ifelse(iszero(x), zero(T), x * log(x))
+end
+_xlogx(x::Real) = _xlogx(float(x))
+
+function _xlogy(x::T, y::T) where {T<:AbstractFloat}
+    ifelse(iszero(x) & !isnan(y), zero(T), x * log(y))
+end
+_xlogy(x::Real, y::Real) = _xlogy(float(x), float(y))
 # _xlogxdy(x::T, y::T) where {T} = _xlogy(x, ifelse(iszero(x) & iszero(y), zero(T), x / y))
-_klterm(x::T, y::T) where {T} = _xlogy(x, x) - _xlogy(x, y)
+function _klterm(x::T, y::T) where {T}
+    xf = float(x)
+    yf = float(y)
+    _xlogy(xf, xf) - _xlogy(xf, yf)
+end

src/vdistance.jl

@@ -7,9 +7,9 @@
 
 # Distances
 _vminkowski(x, y, p::T, dims=:) where {T<:Integer} =
-    vmapreducethen((xᵢ, yᵢ) -> abs(xᵢ - yᵢ)^p, +, x -> exp((one(T)/p) * log(abs(x))), x, y, dims=dims)
+    vmapreducethen((xᵢ, yᵢ) -> abs(float(xᵢ) - float(yᵢ))^p, +, x -> exp((one(T)/p) * log(abs(x))), x, y, dims=dims)
 _vminkowski(x, y, p::T, dims=:) where {T<:AbstractFloat} =
-    vmapreducethen((xᵢ, yᵢ) -> exp(p * log(abs(xᵢ - yᵢ))), +, x -> exp((one(T)/p) * log(abs(x))), x, y, dims=dims)
+    vmapreducethen((xᵢ, yᵢ) -> exp(p * log(abs(float(xᵢ) - float(yᵢ)))), +, x -> exp((one(T)/p) * log(abs(x))), x, y, dims=dims)
 _vminkowski(x, y, p::Rational{T}, dims=:) where {T} = _vminkowski(x, y, float(p), dims=dims)
 
 """
@@ -39,9 +39,9 @@ function vminkowski(x, y, p::Real; dims=:)
 end
 
 _vtminkowski(x, y, p::T, dims=:) where {T<:Integer} =
-    vtmapreducethen((xᵢ, yᵢ) -> abs(xᵢ - yᵢ)^p, +, x -> exp((one(T)/p) * log(abs(x))), x, y, dims=dims)
+    vtmapreducethen((xᵢ, yᵢ) -> abs(float(xᵢ) - float(yᵢ))^p, +, x -> exp((one(T)/p) * log(abs(x))), x, y, dims=dims)
 _vtminkowski(x, y, p::T, dims=:) where {T<:AbstractFloat} =
-    vtmapreducethen((xᵢ, yᵢ) -> exp(p * log(abs(xᵢ - yᵢ))), +, x -> exp((one(T)/p) * log(abs(x))), x, y, dims=dims)
+    vtmapreducethen((xᵢ, yᵢ) -> exp(p * log(abs(float(xᵢ) - float(yᵢ)))), +, x -> exp((one(T)/p) * log(abs(x))), x, y, dims=dims)
 _vtminkowski(x, y, p::Rational{T}, dims=:) where {T} = _vtminkowski(x, y, float(p), dims=dims)
 
 """
@@ -78,7 +78,7 @@ dimensions `dims`.
 
 See also: [`veuclidean`](@ref), [`vchebyshev`](@ref), [`vminkowski`](@ref)
 """
-vmanhattan(x, y; dims=:) = vvmapreduce((xᵢ, yᵢ) -> abs(xᵢ - yᵢ), +, x, y, dims=dims)
+vmanhattan(x, y; dims=:) = vvmapreduce((xᵢ, yᵢ) -> abs(float(xᵢ) - float(yᵢ)), +, x, y, dims=dims)
 
 """
     vtmanhattan(x::AbstractArray, y::AbstractArray; dims=:)
@@ -88,7 +88,7 @@ dimensions `dims`. Threaded.
 
 See also: [`vteuclidean`](@ref), [`vtchebyshev`](@ref), [`vtminkowski`](@ref)
 """
-vtmanhattan(x, y; dims=:) = vtmapreduce((xᵢ, yᵢ) -> abs(xᵢ - yᵢ), +, x, y, dims=dims)
+vtmanhattan(x, y; dims=:) = vtmapreduce((xᵢ, yᵢ) -> abs(float(xᵢ) - float(yᵢ)), +, x, y, dims=dims)
 
 """
     veuclidean(x::AbstractArray, y::AbstractArray; dims=:)
@@ -98,7 +98,7 @@ dimensions `dims`.
 
 See also: [`vmanhattan`](@ref), [`vchebyshev`](@ref), [`vminkowski`](@ref)
 """
-veuclidean(x, y; dims=:) = vmapreducethen((xᵢ, yᵢ) -> abs2(xᵢ - yᵢ) , +, √, x, y, dims=dims)
+veuclidean(x, y; dims=:) = vmapreducethen((xᵢ, yᵢ) -> abs2(float(xᵢ) - float(yᵢ)) , +, √, x, y, dims=dims)
 
 """
     vteuclidean(x::AbstractArray, y::AbstractArray; dims=:)
@@ -108,7 +108,7 @@ dimensions `dims`. Threaded.
 
 See also: [`vtmanhattan`](@ref), [`vtchebyshev`](@ref), [`vtminkowski`](@ref)
 """
-vteuclidean(x, y; dims=:) = vtmapreducethen((xᵢ, yᵢ) -> abs2(xᵢ - yᵢ) , +, √, x, y, dims=dims)
+vteuclidean(x, y; dims=:) = vtmapreducethen((xᵢ, yᵢ) -> abs2(float(xᵢ) - float(yᵢ)) , +, √, x, y, dims=dims)
 
 """
     vchebyshev(x::AbstractArray, y::AbstractArray; dims=:)
@@ -118,8 +118,8 @@ dimensions `dims`.
 
 See also: [`vmanhattan`](@ref), [`veuclidean`](@ref), [`vminkowski`](@ref)
 """
-vchebyshev(x, y; dims=:) = vvmapreduce((xᵢ, yᵢ) -> abs(xᵢ - yᵢ), max, x, y, dims=dims)
-vchebyshev₋(x, y; dims=:) = vvmapreduce((xᵢ, yᵢ) -> abs(xᵢ - yᵢ), min, x, y, dims=dims)
+vchebyshev(x, y; dims=:) = vvmapreduce((xᵢ, yᵢ) -> abs(float(xᵢ) - float(yᵢ)), max, x, y, dims=dims)
+vchebyshev₋(x, y; dims=:) = vvmapreduce((xᵢ, yᵢ) -> abs(float(xᵢ) - float(yᵢ)), min, x, y, dims=dims)
 
 """
     vtchebyshev(x::AbstractArray, y::AbstractArray; dims=:)
@@ -129,5 +129,5 @@ dimensions `dims`. Threaded.
 
 See also: [`vtmanhattan`](@ref), [`vteuclidean`](@ref), [`vtminkowski`](@ref)
 """
-vtchebyshev(x, y; dims=:) = vtmapreduce((xᵢ, yᵢ) -> abs(xᵢ - yᵢ), max, x, y, dims=dims)
-vtchebyshev₋(x, y; dims=:) = vtmapreduce((xᵢ, yᵢ) -> abs(xᵢ - yᵢ), min, x, y, dims=dims)
+vtchebyshev(x, y; dims=:) = vtmapreduce((xᵢ, yᵢ) -> abs(float(xᵢ) - float(yᵢ)), max, x, y, dims=dims)
+vtchebyshev₋(x, y; dims=:) = vtmapreduce((xᵢ, yᵢ) -> abs(float(xᵢ) - float(yᵢ)), min, x, y, dims=dims)

src/vstats.jl

@@ -5,18 +5,17 @@
 #
 ############################################################################################
 # Assorted functions from StatsBase, plus some of my own
-
 ################
 # Means
 function vmean(f::F, A; dims=:) where {F}
     c = 1 / _denom(A, dims)
-    vmapreducethen(f, +, x -> c * x, A, dims=dims)
+    vmapreducethen(x -> float(f(x)), +, x -> c * x, A, dims=dims)
 end
 vmean(A; dims=:) = vmean(identity, A, dims=dims)
 
 function vtmean(f::F, A; dims=:) where {F}
     c = 1 / _denom(A, dims)
-    vtmapreducethen(f, +, x -> c * x, A, dims=dims)
+    vtmapreducethen(x -> float(f(x)), +, x -> c * x, A, dims=dims)
 end
 vtmean(A; dims=:) = vtmean(identity, A, dims=dims)
 
@@ -97,13 +96,12 @@ _vmaxentropy(p, dims::NTuple{M, Int}) where {M} =
 _vmaxentropy(p, ::Colon) = log(length(p))
 vmaxentropy(p; dims=:) = _vmaxentropy(p, dims)
 vshannonentropy(p; dims=:) = vmapreducethen(_xlogx, +, -, p, dims=dims)
-vcollisionentropy(p; dims=:) = vmapreducethen(abs2, +, x -> -log(x), p, dims=dims)
+vcollisionentropy(p; dims=:) = vmapreducethen(abs2 ∘ float, +, x -> -log(x), p, dims=dims)
 vminentropy(p; dims=:) = vmapreducethen(identity, max, x -> -log(x), p, dims=dims)
 
-_vrenyientropy(p, α::T, dims) where {T<:Integer} =
-    (c = one(T) / (one(T) - α); vmapreducethen(x -> x^α, +, x -> c * log(x), p, dims=dims))
 _vrenyientropy(p, α::T, dims) where {T<:AbstractFloat} =
     (c = one(T) / (one(T) - α); vmapreducethen(x -> exp(α * log(x)), +, x -> c * log(x), p, dims=dims))
+_vrenyientropy(p, α::T, dims) where {T<:Integer} = _vrenyientryop(p, float(α), dims)
 _vrenyientropy(p, α::Rational{T}, dims) where {T} = _vrenyientropy(p, float(α), dims)
 function vrenyientropy(p, α::Real; dims=:)
     α < 0 && throw(ArgumentError("Order of Rényi entropy not legal, $(α) < 0."))
@@ -139,13 +137,12 @@ _vtmaxentropy(p, dims::NTuple{M, Int}) where {M} =
 _vtmaxentropy(p, ::Colon) = log(length(p))
 vtmaxentropy(p; dims=:) = _vtmaxentropy(p, dims)
 vtshannonentropy(p; dims=:) = vtmapreducethen(_xlogx, +, -, p, dims=dims)
-vtcollisionentropy(p; dims=:) = vtmapreducethen(abs2, +, x -> -log(x), p, dims=dims)
+vtcollisionentropy(p; dims=:) = vtmapreducethen(abs2 ∘ float, +, x -> -log(x), p, dims=dims)
 vtminentropy(p; dims=:) = vtmapreducethen(identity, max, x -> -log(x), p, dims=dims)
 
-_vtrenyientropy(p, α::T, dims) where {T<:Integer} =
-    (c = one(T) / (one(T) - α); vtmapreducethen(x -> x^α, +, x -> c * log(x), p, dims=dims))
 _vtrenyientropy(p, α::T, dims) where {T<:AbstractFloat} =
     (c = one(T) / (one(T) - α); vtmapreducethen(x -> exp(α * log(x)), +, x -> c * log(x), p, dims=dims))
+_vtrenyientropy(p, α::T, dims) where {T<:Integer} = _vrenyientryop(p, float(α), dims)
 _vtrenyientropy(p, α::Rational{T}, dims) where {T} = _vtrenyientropy(p, float(α), dims)
 function vtrenyientropy(p, α::Real; dims=:)
     α < 0 && throw(ArgumentError("Order of Rényi entropy not legal, $(α) < 0."))
@@ -274,7 +271,7 @@ See also: [`vmaxad`](@ref)
 """
 function vmeanad(x, y; dims=:)
     c = 1 / _denom(x, dims)
-    vmapreducethen((xᵢ, yᵢ) -> abs(xᵢ - yᵢ) , +, z -> c * z, x, y, dims=dims)
+    vmapreducethen((xᵢ, yᵢ) -> abs(float(xᵢ) - float(yᵢ)) , +, z -> c * z, x, y, dims=dims)
 end
 
 """
@@ -287,7 +284,7 @@ See also: [`vtmaxad`](@ref)
 """
 function vtmeanad(x, y; dims=:)
     c = 1 / _denom(x, dims)
-    vtmapreducethen((xᵢ, yᵢ) -> abs(xᵢ - yᵢ) , +, z -> c * z, x, y, dims=dims)
+    vtmapreducethen((xᵢ, yᵢ) -> abs(float(xᵢ) - float(yᵢ)) , +, z -> c * z, x, y, dims=dims)
 end
 
 """
@@ -320,7 +317,7 @@ See also: [`vrmse`](@ref)
 """
 function vmse(x, y; dims=:)
     c = 1 / _denom(x, dims)
-    vmapreducethen((xᵢ, yᵢ) -> abs2(xᵢ - yᵢ) , +, z -> c * z, x, y, dims=dims)
+    vmapreducethen((xᵢ, yᵢ) -> abs2(float(xᵢ) - float(yᵢ)) , +, z -> c * z, x, y, dims=dims)
 end
 
 """
@@ -333,7 +330,7 @@ See also: [`vtrmse`](@ref)
 """
 function vtmse(x, y; dims=:)
     c = 1 / _denom(x, dims)
-    vtmapreducethen((xᵢ, yᵢ) -> abs2(xᵢ - yᵢ) , +, z -> c * z, x, y, dims=dims)
+    vtmapreducethen((xᵢ, yᵢ) -> abs2(float(xᵢ) - float(yᵢ)) , +, z -> c * z, x, y, dims=dims)
 end
 
 """
@@ -348,7 +345,7 @@ See also: [`vmse`](@ref)
 """
 function vrmse(x, y; dims=:)
     c = 1 / _denom(x, dims)
-    vmapreducethen((xᵢ, yᵢ) -> abs2(xᵢ - yᵢ) , +, z -> √(c * z), x, y, dims=dims)
+    vmapreducethen((xᵢ, yᵢ) -> abs2(float(xᵢ) - float(yᵢ)) , +, z -> √(c * z), x, y, dims=dims)
 end
 
 """
@@ -363,7 +360,7 @@ See also: [`vtmse`](@ref)
 """
 function vtrmse(x, y; dims=:)
     c = 1 / _denom(x, dims)
-    vtmapreducethen((xᵢ, yᵢ) -> abs2(xᵢ - yᵢ) , +, z -> √(c * z), x, y, dims=dims)
+    vtmapreducethen((xᵢ, yᵢ) -> abs2(float(xᵢ) - float(yᵢ)) , +, z -> √(c * z), x, y, dims=dims)
 end
 
 # Match names with StatsBase

test/vstats.jl

@@ -30,10 +30,10 @@ end
     end
 end
 
-meanad(x, y; dims=:) = mean(abs.(x .- y), dims=dims)
+meanad(x, y; dims=:) = mean(abs.(float.(x) .- float.(y)), dims=dims)
 maxad(x, y; dims=:) = maximum(abs.(x .- y), dims=dims)
-mse(x, y; dims=:) = mean(abs2.(x .- y), dims=dims)
-rmse(x, y; dims=:) = .√mean(abs2.(x .- y), dims=dims)
+mse(x, y; dims=:) = mean(abs2.(float.(x) .- float.(y)), dims=dims)
+rmse(x, y; dims=:) = .√mean(abs2.(float.(x) .- float.(y)), dims=dims)
 
 @testset "meanad" begin
     for T ∈ (Float32, Float64, Int32)