Loosen type annotations and fix #130 (#134)

Author: devmotion

src/common.jl

@@ -109,10 +109,10 @@ function sumsq_percol(a::AbstractMatrix{T}) where {T}
     return r
 end
 
-function wsumsq_percol(w::AbstractArray{T1}, a::AbstractMatrix{T2}) where {T1, T2}
+function wsumsq_percol(w::AbstractArray, a::AbstractMatrix)
     m = size(a, 1)
     n = size(a, 2)
-    T = typeof(one(T1) * one(T2))
+    T = typeof(zero(eltype(w)) * abs2(zero(eltype(a))))
     r = Vector{T}(undef, n)
     for j = 1:n
         aj = view(a, :, j)

src/metrics.jl

@@ -252,22 +252,21 @@ end
     end
     return eval_end(d, s)
 end
-result_type(dist::UnionMetrics, ::AbstractArray{T1}, ::AbstractArray{T2}) where {T1, T2} =
-    typeof(eval_end(dist, parameters(dist) === nothing ?
-                        eval_op(dist, one(T1), one(T2)) :
-                        eval_op(dist, one(T1), one(T2), one(eltype(dist)))))
+result_type(dist::UnionMetrics, a::AbstractArray, b::AbstractArray) =
+    typeof(evaluate(dist, oneunit(eltype(a)), oneunit(eltype(b))))
+
 eval_start(d::UnionMetrics, a::AbstractArray, b::AbstractArray) =
     zero(result_type(d, a, b))
 eval_end(d::UnionMetrics, s) = s
 
-evaluate(dist::UnionMetrics, a::T, b::T) where {T <: Number} = eval_end(dist, eval_op(dist, a, b))
+evaluate(dist::UnionMetrics, a::Number, b::Number) = eval_end(dist, eval_op(dist, a, b))
 
 # SqEuclidean
 @inline eval_op(::SqEuclidean, ai, bi) = abs2(ai - bi)
 @inline eval_reduce(::SqEuclidean, s1, s2) = s1 + s2
 
 sqeuclidean(a::AbstractArray, b::AbstractArray) = evaluate(SqEuclidean(), a, b)
-sqeuclidean(a::T, b::T) where {T <: Number} = evaluate(SqEuclidean(), a, b)
+sqeuclidean(a::Number, b::Number) = evaluate(SqEuclidean(), a, b)
 
 # Euclidean
 @inline eval_op(::Euclidean, ai, bi) = abs2(ai - bi)
@@ -285,13 +284,13 @@ Base.eltype(d::PeriodicEuclidean) = eltype(d.periods)
     s3 = min(s2, p - s2)
     abs2(s3)
 end
+@inline function eval_op(d::PeriodicEuclidean, ai, bi)
+    periods = d.periods
+    p = isempty(periods) ? oneunit(eltype(periods)) : first(periods)
+    eval_op(d, ai, bi, p)
+end
 @inline eval_reduce(::PeriodicEuclidean, s1, s2) = s1 + s2
 @inline eval_end(::PeriodicEuclidean, s) = sqrt(s)
-function evaluate(dist::PeriodicEuclidean, a::T, b::T) where {T <: Real}
-    p = first(dist.periods)
-    d = mod(abs(a - b), p)
-    min(d, p - d)
-end
 peuclidean(a::AbstractArray, b::AbstractArray, p::AbstractArray{<: Real}) =
     evaluate(PeriodicEuclidean(p), a, b)
 peuclidean(a::Number, b::Number, p::Real) = evaluate(PeriodicEuclidean([p]), a, b)
@@ -300,38 +299,39 @@ peuclidean(a::Number, b::Number, p::Real) = evaluate(PeriodicEuclidean([p]), a,
 @inline eval_op(::Cityblock, ai, bi) = abs(ai - bi)
 @inline eval_reduce(::Cityblock, s1, s2) = s1 + s2
 cityblock(a::AbstractArray, b::AbstractArray) = evaluate(Cityblock(), a, b)
-cityblock(a::T, b::T) where {T <: Number} = evaluate(Cityblock(), a, b)
+cityblock(a::Number, b::Number) = evaluate(Cityblock(), a, b)
 
 # Total variation
 @inline eval_op(::TotalVariation, ai, bi) = abs(ai - bi)
 @inline eval_reduce(::TotalVariation, s1, s2) = s1 + s2
 eval_end(::TotalVariation, s) = s / 2
 totalvariation(a::AbstractArray, b::AbstractArray) = evaluate(TotalVariation(), a, b)
-totalvariation(a::T, b::T) where {T <: Number} = evaluate(TotalVariation(), a, b)
+totalvariation(a::Number, b::Number) = evaluate(TotalVariation(), a, b)
 
 # Chebyshev
 @inline eval_op(::Chebyshev, ai, bi) = abs(ai - bi)
 @inline eval_reduce(::Chebyshev, s1, s2) = max(s1, s2)
 # if only NaN, will output NaN
 @inline Base.@propagate_inbounds eval_start(::Chebyshev, a::AbstractArray, b::AbstractArray) = abs(a[1] - b[1])
 chebyshev(a::AbstractArray, b::AbstractArray) = evaluate(Chebyshev(), a, b)
-chebyshev(a::T, b::T) where {T <: Number} = evaluate(Chebyshev(), a, b)
+chebyshev(a::Number, b::Number) = evaluate(Chebyshev(), a, b)
 
 # Minkowski
 @inline eval_op(dist::Minkowski, ai, bi) = abs(ai - bi).^dist.p
 @inline eval_reduce(::Minkowski, s1, s2) = s1 + s2
 eval_end(dist::Minkowski, s) = s.^(1 / dist.p)
 minkowski(a::AbstractArray, b::AbstractArray, p::Real) = evaluate(Minkowski(p), a, b)
-minkowski(a::T, b::T, p::Real) where {T <: Number} = evaluate(Minkowski(p), a, b)
+minkowski(a::Number, b::Number, p::Real) = evaluate(Minkowski(p), a, b)
 
 # Hamming
 @inline eval_op(::Hamming, ai, bi) = ai != bi ? 1 : 0
 @inline eval_reduce(::Hamming, s1, s2) = s1 + s2
 hamming(a::AbstractArray, b::AbstractArray) = evaluate(Hamming(), a, b)
-hamming(a::T, b::T) where {T <: Number} = evaluate(Hamming(), a, b)
+hamming(a::Number, b::Number) = evaluate(Hamming(), a, b)
 
 # Cosine dist
-@inline function eval_start(::CosineDist, a::AbstractArray{T}, b::AbstractArray{T}) where {T <: Real}
+@inline function eval_start(dist::CosineDist, a::AbstractArray, b::AbstractArray)
+    T = Base.promote_typeof(eval_op(dist, oneunit(eltype(a)), oneunit(eltype(b)))...)
     zero(T), zero(T), zero(T)
 end
 @inline eval_op(::CosineDist, ai, bi) = ai * bi, ai * ai, bi * bi
@@ -360,12 +360,14 @@ result_type(::CorrDist, a::AbstractArray, b::AbstractArray) = result_type(Cosine
 chisq_dist(a::AbstractArray, b::AbstractArray) = evaluate(ChiSqDist(), a, b)
 
 # KLDivergence
-@inline eval_op(::KLDivergence, ai, bi) = ai > 0 ? ai * log(ai / bi) : zero(ai)
+@inline eval_op(dist::KLDivergence, ai, bi) =
+    ai > 0 ? ai * log(ai / bi) : zero(eval_op(dist, oneunit(ai), bi))
 @inline eval_reduce(::KLDivergence, s1, s2) = s1 + s2
 kl_divergence(a::AbstractArray, b::AbstractArray) = evaluate(KLDivergence(), a, b)
 
 # GenKLDivergence
-@inline eval_op(::GenKLDivergence, ai, bi) = ai > 0 ? ai * log(ai / bi) - ai + bi : bi
+@inline eval_op(dist::GenKLDivergence, ai, bi) =
+    ai > 0 ? ai * log(ai / bi) - ai + bi : oftype(eval_op(dist, oneunit(ai), bi), bi)
 @inline eval_reduce(::GenKLDivergence, s1, s2) = s1 + s2
 gkl_divergence(a::AbstractArray, b::AbstractArray) = evaluate(GenKLDivergence(), a, b)
 
@@ -450,15 +452,17 @@ end
 
 eval_end(::SpanNormDist, s) = s[2] - s[1]
 spannorm_dist(a::AbstractArray, b::AbstractArray) = evaluate(SpanNormDist(), a, b)
-function result_type(dist::SpanNormDist, ::AbstractArray{T1}, ::AbstractArray{T2}) where {T1, T2}
-    typeof(eval_op(dist, one(T1), one(T2)))
-end
+result_type(dist::SpanNormDist, a::AbstractArray, b::AbstractArray) =
+    typeof(eval_op(dist, oneunit(eltype(a)), oneunit(eltype(b))))
 
 
 # Jaccard
 
 @inline eval_start(::Jaccard, a::AbstractArray{Bool}, b::AbstractArray{Bool}) = 0, 0
-@inline eval_start(::Jaccard, a::AbstractArray{T}, b::AbstractArray{T}) where {T} = zero(T), zero(T)
+@inline function eval_start(dist::Jaccard, a::AbstractArray, b::AbstractArray)
+    T = Base.promote_typeof(eval_op(dist, oneunit(eltype(a)), oneunit(eltype(b)))...)
+    zero(T), zero(T)
+end
 @inline function eval_op(::Jaccard, s1, s2)
     abs_m = abs(s1 - s2)
     abs_p = abs(s1 + s2)
@@ -478,7 +482,10 @@ jaccard(a::AbstractArray, b::AbstractArray) = evaluate(Jaccard(), a, b)
 # BrayCurtis
 
 @inline eval_start(::BrayCurtis, a::AbstractArray{Bool}, b::AbstractArray{Bool}) = 0, 0
-@inline eval_start(::BrayCurtis, a::AbstractArray{T}, b::AbstractArray{T}) where {T} = zero(T), zero(T)
+@inline function eval_start(dist::BrayCurtis, a::AbstractArray, b::AbstractArray)
+    T = Base.promote_typeof(eval_op(dist, oneunit(eltype(a)), oneunit(eltype(b)))...)
+    zero(T), zero(T)
+end
 @inline function eval_op(::BrayCurtis, s1, s2)
     abs_m = abs(s1 - s2)
     abs_p = abs(s1 + s2)

src/wmetrics.jl

@@ -39,12 +39,12 @@ Base.eltype(x::UnionWeightedMetrics) = eltype(x.weights)
 #
 ###########################################################
 
-function evaluate(dist::UnionWeightedMetrics, a::T, b::T) where {T <: Number}
-    eval_end(dist, eval_op(dist, a, b, one(eltype(dist))))
-end
-function result_type(dist::UnionWeightedMetrics, ::AbstractArray{T1}, ::AbstractArray{T2}) where {T1, T2}
-    typeof(evaluate(dist, one(T1), one(T2)))
+function evaluate(dist::UnionWeightedMetrics, a::Number, b::Number)
+    eval_end(dist, eval_op(dist, a, b, oneunit(eltype(dist))))
 end
+result_type(dist::UnionWeightedMetrics, a::AbstractArray, b::AbstractArray) =
+    typeof(evaluate(dist, oneunit(eltype(a)), oneunit(eltype(b))))
+
 @inline function eval_start(d::UnionWeightedMetrics, a::AbstractArray, b::AbstractArray)
     zero(result_type(d, a, b))
 end

test/test_dists.jl

@@ -299,6 +299,44 @@ end # testset
     @test_throws DimensionMismatch evaluate(Bregman(x -> sqeuclidean(x, zero(x)), x -> [1, 2]), [1, 2, 3], [1, 2, 3])
 end # testset
 
+@testset "Different input types" begin
+    for (x, y) in (([4, 5, 6, 7], [3.0, 9.0, 8.0, 1.0]),
+                   ([4, 5, 6, 7], [3//1 8; 9 1]))
+        @test (@inferred sqeuclidean(x, y)) == 57
+        @test (@inferred euclidean(x, y)) == sqrt(57)
+        @test (@inferred jaccard(x, y)) == convert(Base.promote_eltype(x, y), 13 // 28)
+        @test (@inferred cityblock(x, y)) == 13
+        @test (@inferred totalvariation(x, y)) == 6.5
+        @test (@inferred chebyshev(x, y)) == 6
+        @test (@inferred braycurtis(x, y)) == convert(Base.promote_eltype(x, y), 13 // 43)
+        @test (@inferred minkowski(x, y, 2)) == sqrt(57)
+        @test (@inferred peuclidean(x, y, fill(10, 4))) == sqrt(37)
+        @test (@inferred peuclidean(x - vec(y), zero(y), fill(10, 4))) == peuclidean(x, y, fill(10, 4))
+        @test (@inferred peuclidean(x, y, [10.0, 10.0, 10.0, Inf])) == sqrt(57)
+        @test_throws DimensionMismatch cosine_dist(1.0:2, 1.0:3)
+        @test (@inferred cosine_dist(x, y)) ≈ (1 - 112 / sqrt(19530))
+        @test (@inferred corr_dist(x, y)) ≈ cosine_dist(x .- mean(x), vec(y) .- mean(y))
+        @test (@inferred chisq_dist(x, y)) == sum((x - vec(y)).^2 ./ (x + vec(y)))
+        @test (@inferred spannorm_dist(x, y)) == maximum(x - vec(y)) - minimum(x - vec(y))
+
+        @test (@inferred gkl_divergence(x, y)) ≈ sum(i -> x[i] * log(x[i] / y[i]) - x[i] + y[i], 1:length(x))
+
+        @test (@inferred meanad(x, y)) ≈ mean(Float64[abs(x[i] - y[i]) for i in 1:length(x)])
+        @test (@inferred msd(x, y)) ≈ mean(Float64[abs2(x[i] - y[i]) for i in 1:length(x)])
+        @test (@inferred rmsd(x, y)) ≈ sqrt(msd(x, y))
+        @test (@inferred nrmsd(x, y)) ≈ sqrt(msd(x, y)) / (maximum(x) - minimum(x))
+
+        w = ones(Int, 4)
+        @test sqeuclidean(x, y) ≈ wsqeuclidean(x, y, w)
+
+        w = rand(1:length(x), size(x))
+        @test (@inferred wsqeuclidean(x, y, w)) ≈ dot((x - vec(y)).^2, w)
+        @test (@inferred weuclidean(x, y, w)) == sqrt(wsqeuclidean(x, y, w))
+        @test (@inferred wcityblock(x, y, w)) ≈ dot(abs.(x - vec(y)), w)
+        @test (@inferred wminkowski(x, y, w, 2)) ≈ weuclidean(x, y, w)
+    end
+end
+
 @testset "mahalanobis" begin
     for T in (Float64, F64)
         x, y = T.([4.0, 5.0, 6.0, 7.0]), T.([3.0, 9.0, 8.0, 1.0])