fix deprecation warnings for new where syntax (#73)

* move to 0.6

* use function instead of macro in tests

Author: KristofferC

.travis.yml

@@ -1,16 +1,26 @@
 language: julia
+
 os:
     - linux
     - osx
+
 julia:
-    - 0.5
+    - 0.6
     - nightly
+
+matrix:
+    allow_failures:
+        - julia: nightly
+
 notifications:
     email: false
+
 sudo: false
+
 script:
     - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
     - julia -e 'Pkg.clone(pwd()); Pkg.build("Distances")'
     - julia -e 'Pkg.test("Distances", coverage=true)'
+
 after_success:
     - julia -e 'cd(Pkg.dir("Distances")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(process_folder())'

REQUIRE

@@ -1,2 +1 @@
-julia 0.5
-Compat 0.18
+julia 0.6

src/Distances.jl

@@ -2,8 +2,6 @@ __precompile__()
 
 module Distances
 
-using Compat
-
 export
     # generic types/functions
     PreMetric,

src/bhattacharyya.jl

@@ -2,14 +2,14 @@
 # be compared are probability distributions, frequencies or counts rather than
 # vectors of samples. Pre-calc accordingly if you have samples.
 
-type BhattacharyyaDist <: SemiMetric end
+struct BhattacharyyaDist <: SemiMetric end
 
-type HellingerDist <: Metric end
+struct HellingerDist <: Metric end
 
 
 # Bhattacharyya coefficient
 
-function bhattacharyya_coeff{T<:Number}(a::AbstractVector{T}, b::AbstractVector{T})
+function bhattacharyya_coeff(a::AbstractVector{T}, b::AbstractVector{T}) where {T <: Number}
     if length(a) != length(b)
         throw(DimensionMismatch("first array has length $(length(a)) which does not match the length of the second, $(length(b))."))
     end
@@ -31,19 +31,19 @@ function bhattacharyya_coeff{T<:Number}(a::AbstractVector{T}, b::AbstractVector{
     sqab / sqrt(asum * bsum)
 end
 
-bhattacharyya_coeff{T <: Number}(a::T, b::T) = throw("Bhattacharyya coefficient cannot be calculated for scalars")
+bhattacharyya_coeff(a::T, b::T) where {T <: Number} = throw("Bhattacharyya coefficient cannot be calculated for scalars")
 
 # Faster pair- and column-wise versions TBD...
 
 
 # Bhattacharyya distance
-evaluate{T<:Number}(dist::BhattacharyyaDist, a::AbstractVector{T}, b::AbstractVector{T}) = -log(bhattacharyya_coeff(a, b))
+evaluate(dist::BhattacharyyaDist, a::AbstractVector{T}, b::AbstractVector{T}) where {T <: Number} = -log(bhattacharyya_coeff(a, b))
 bhattacharyya(a::AbstractVector, b::AbstractVector) = evaluate(BhattacharyyaDist(), a, b)
-evaluate{T <: Number}(dist::BhattacharyyaDist, a::T, b::T) = throw("Bhattacharyya distance cannot be calculated for scalars")
-bhattacharyya{T <: Number}(a::T, b::T) = evaluate(BhattacharyyaDist(), a, b)
+evaluate(dist::BhattacharyyaDist, a::T, b::T) where {T <: Number} = throw("Bhattacharyya distance cannot be calculated for scalars")
+bhattacharyya(a::T, b::T) where {T <: Number} = evaluate(BhattacharyyaDist(), a, b)
 
 # Hellinger distance
-evaluate{T<:Number}(dist::HellingerDist, a::AbstractVector{T}, b::AbstractVector{T}) = sqrt(1 - bhattacharyya_coeff(a, b))
+evaluate(dist::HellingerDist, a::AbstractVector{T}, b::AbstractVector{T}) where {T <: Number} = sqrt(1 - bhattacharyya_coeff(a, b))
 hellinger(a::AbstractVector, b::AbstractVector) = evaluate(HellingerDist(), a, b)
-evaluate{T <: Number}(dist::HellingerDist, a::T, b::T) = throw("Hellinger distance cannot be calculated for scalars")
-hellinger{T <: Number}(a::T, b::T) = evaluate(HellingerDist(), a, b)
+evaluate(dist::HellingerDist, a::T, b::T) where {T <: Number} = throw("Hellinger distance cannot be calculated for scalars")
+hellinger(a::T, b::T) where {T <: Number} = evaluate(HellingerDist(), a, b)

src/common.jl

@@ -98,7 +98,7 @@ function sqrt!(a::AbstractArray)
     a
 end
 
-function sumsq_percol{T}(a::AbstractMatrix{T})
+function sumsq_percol(a::AbstractMatrix{T}) where {T}
     m = size(a, 1)
     n = size(a, 2)
     r = Vector{T}(n)
@@ -109,7 +109,7 @@ function sumsq_percol{T}(a::AbstractMatrix{T})
     return r
 end
 
-function wsumsq_percol{T1, T2}(w::AbstractArray{T1}, a::AbstractMatrix{T2})
+function wsumsq_percol(w::AbstractArray{T1}, a::AbstractMatrix{T2}) where {T1,T2}
     m = size(a, 1)
     n = size(a, 2)
     T = typeof(one(T1)*one(T2))

src/generic.jl

@@ -5,21 +5,21 @@
 #   d(x, y) >= 0
 #   d(x, x) = 0
 #
-@compat abstract type PreMetric end
+abstract type PreMetric end
 
 # a semimetric is a function d that satisfies:
 #
 #   d(x, y) >= 0
 #   d(x, x) = 0
 #   d(x, y) = d(y, x)
 #
-@compat abstract type SemiMetric <: PreMetric end
+abstract type SemiMetric <: PreMetric end
 
 # a metric is a semimetric that satisfies triangle inequality:
 #
 #   d(x, y) + d(y, z) >= d(x, z)
 #
-@compat abstract type Metric <: SemiMetric end
+abstract type Metric <: SemiMetric end
 
 
 # Generic functions

src/mahalanobis.jl

@@ -1,19 +1,19 @@
 # Mahalanobis distances
 
-immutable Mahalanobis{T} <: Metric
+struct Mahalanobis{T} <: Metric
     qmat::Matrix{T}
 end
 
-immutable SqMahalanobis{T} <: SemiMetric
+struct SqMahalanobis{T} <: SemiMetric
     qmat::Matrix{T}
 end
 
-result_type{T}(::Mahalanobis{T}, ::AbstractArray, ::AbstractArray) = T
-result_type{T}(::SqMahalanobis{T}, ::AbstractArray, ::AbstractArray) = T
+result_type(::Mahalanobis{T}, ::AbstractArray, ::AbstractArray) where {T} = T
+result_type(::SqMahalanobis{T}, ::AbstractArray, ::AbstractArray) where {T} = T
 
 # SqMahalanobis
 
-function evaluate{T<:AbstractFloat}(dist::SqMahalanobis{T}, a::AbstractVector, b::AbstractVector)
+function evaluate(dist::SqMahalanobis{T}, a::AbstractVector, b::AbstractVector) where {T <: AbstractFloat}
     if length(a) != length(b)
         throw(DimensionMismatch("first array has length $(length(a)) which does not match the length of the second, $(length(b))."))
     end
@@ -25,22 +25,22 @@ end
 
 sqmahalanobis(a::AbstractVector, b::AbstractVector, Q::AbstractMatrix) = evaluate(SqMahalanobis(Q), a, b)
 
-function colwise!{T<:AbstractFloat}(r::AbstractArray, dist::SqMahalanobis{T}, a::AbstractMatrix, b::AbstractMatrix)
+function colwise!(r::AbstractArray, dist::SqMahalanobis{T}, a::AbstractMatrix, b::AbstractMatrix) where {T <: AbstractFloat}
     Q = dist.qmat
     m, n = get_colwise_dims(size(Q, 1), r, a, b)
     z = a - b
     dot_percol!(r, Q * z, z)
 end
 
-function colwise!{T<:AbstractFloat}(r::AbstractArray, dist::SqMahalanobis{T}, a::AbstractVector, b::AbstractMatrix)
+function colwise!(r::AbstractArray, dist::SqMahalanobis{T}, a::AbstractVector, b::AbstractMatrix) where {T <: AbstractFloat}
     Q = dist.qmat
     m, n = get_colwise_dims(size(Q, 1), r, a, b)
     z = a .- b
     Qz = Q * z
     dot_percol!(r, Q * z, z)
 end
 
-function pairwise!{T<:AbstractFloat}(r::AbstractMatrix, dist::SqMahalanobis{T}, a::AbstractMatrix, b::AbstractMatrix)
+function pairwise!(r::AbstractMatrix, dist::SqMahalanobis{T}, a::AbstractMatrix, b::AbstractMatrix) where {T <: AbstractFloat}
     Q = dist.qmat
     m, na, nb = get_pairwise_dims(size(Q, 1), r, a, b)
 
@@ -58,7 +58,7 @@ function pairwise!{T<:AbstractFloat}(r::AbstractMatrix, dist::SqMahalanobis{T},
     r
 end
 
-function pairwise!{T<:AbstractFloat}(r::AbstractMatrix, dist::SqMahalanobis{T}, a::AbstractMatrix)
+function pairwise!(r::AbstractMatrix, dist::SqMahalanobis{T}, a::AbstractMatrix) where {T <: AbstractFloat}
     Q = dist.qmat
     m, n = get_pairwise_dims(size(Q, 1), r, a)
 
@@ -81,24 +81,24 @@ end
 
 # Mahalanobis
 
-function evaluate{T<:AbstractFloat}(dist::Mahalanobis{T}, a::AbstractVector, b::AbstractVector)
+function evaluate(dist::Mahalanobis{T}, a::AbstractVector, b::AbstractVector) where {T <: AbstractFloat}
     sqrt(evaluate(SqMahalanobis(dist.qmat), a, b))
 end
 
 mahalanobis(a::AbstractVector, b::AbstractVector, Q::AbstractMatrix) = evaluate(Mahalanobis(Q), a, b)
 
-function colwise!{T<:AbstractFloat}(r::AbstractArray, dist::Mahalanobis{T}, a::AbstractMatrix, b::AbstractMatrix)
+function colwise!(r::AbstractArray, dist::Mahalanobis{T}, a::AbstractMatrix, b::AbstractMatrix) where {T <: AbstractFloat}
     sqrt!(colwise!(r, SqMahalanobis(dist.qmat), a, b))
 end
 
-function colwise!{T<:AbstractFloat}(r::AbstractArray, dist::Mahalanobis{T}, a::AbstractVector, b::AbstractMatrix)
+function colwise!(r::AbstractArray, dist::Mahalanobis{T}, a::AbstractVector, b::AbstractMatrix) where {T <: AbstractFloat}
     sqrt!(colwise!(r, SqMahalanobis(dist.qmat), a, b))
 end
 
-function pairwise!{T<:AbstractFloat}(r::AbstractMatrix, dist::Mahalanobis{T}, a::AbstractMatrix, b::AbstractMatrix)
+function pairwise!(r::AbstractMatrix, dist::Mahalanobis{T}, a::AbstractMatrix, b::AbstractMatrix) where {T <: AbstractFloat}
     sqrt!(pairwise!(r, SqMahalanobis(dist.qmat), a, b))
 end
 
-function pairwise!{T<:AbstractFloat}(r::AbstractMatrix, dist::Mahalanobis{T}, a::AbstractMatrix)
+function pairwise!(r::AbstractMatrix, dist::Mahalanobis{T}, a::AbstractMatrix) where {T <: AbstractFloat}
     sqrt!(pairwise!(r, SqMahalanobis(dist.qmat), a))
 end