Merge pull request #33 from KristofferC/kc/slices

update to 0.4

Author: KristofferC

.gitignore

@@ -0,0 +1,4 @@
+*.jl.cov
+*.jl.*.cov
+*.jl.mem
+*.ji

.travis.yml

@@ -3,7 +3,6 @@ os:
     - linux
     - osx
 julia:
-    - 0.3
     - 0.4
     - nightly
 notifications:

README.md

@@ -3,7 +3,6 @@
 [![Build Status](https://travis-ci.org/JuliaStats/Distances.jl.svg?branch=master)](https://travis-ci.org/JuliaStats/Distances.jl)
 [![Coverage Status](https://coveralls.io/repos/JuliaStats/Distances.jl/badge.svg?branch=master&service=github)](https://coveralls.io/github/JuliaStats/Distances.jl?branch=master)
 
-[![Distances](http://pkg.julialang.org/badges/Distances_0.3.svg)](http://pkg.julialang.org/?pkg=Distances&ver=0.3)
 [![Distances](http://pkg.julialang.org/badges/Distances_0.4.svg)](http://pkg.julialang.org/?pkg=Distances&ver=0.4)
 
 A Julia package for evaluating distances(metrics) between vectors.

REQUIRE

@@ -1,3 +1 @@
-julia 0.3
-ArrayViews 0.4.8-
-Compat
+julia 0.4

src/Distances.jl

@@ -1,9 +1,7 @@
-isdefined(Base, :__precompile__) && __precompile__()
+__precompile__()
 
 module Distances
 
-using ArrayViews, Compat
-
 export
     # generic types/functions
     PreMetric,

src/common.jl

@@ -103,7 +103,7 @@ function sumsq_percol{T}(a::AbstractMatrix{T})
     n = size(a, 2)
     r = Array(T, n)
     for j = 1:n
-        aj = view(a,:,j)
+        aj = slice(a, :, j)
         r[j] = dot(aj, aj)
     end
     return r
@@ -115,7 +115,7 @@ function wsumsq_percol{T1, T2}(w::AbstractArray{T1}, a::AbstractMatrix{T2})
     T = typeof(one(T1)*one(T2))
     r = Array(T, n)
     for j = 1:n
-        aj = view(a,:,j)
+        aj = slice(a, :, j)
         s = zero(T)
         @simd for i = 1:m
             @inbounds s += w[i] * abs2(aj[i])
@@ -131,8 +131,8 @@ function dot_percol!(r::AbstractArray, a::AbstractMatrix, b::AbstractMatrix)
     size(b) == (m,n) && length(r) == n ||
         throw(DimensionMismatch("Inconsistent array dimensions."))
     for j = 1:n
-        aj = view(a,:,j)
-        bj = view(b,:,j)
+        aj = slice(a,:,j)
+        bj = slice(b,:,j)
         r[j] = dot(aj, bj)
     end
     return r

src/generic.jl

@@ -33,7 +33,7 @@ function colwise!(r::AbstractArray, metric::PreMetric, a::AbstractVector, b::Abs
     n = size(b, 2)
     length(r) == n || throw(DimensionMismatch("Incorrect size of r."))
     for j = 1 : n
-        @inbounds r[j] = evaluate(metric, a, view(b, :, j))
+        @inbounds r[j] = evaluate(metric, a, slice(b, :, j))
     end
     r
 end
@@ -42,7 +42,7 @@ function colwise!(r::AbstractArray, metric::PreMetric, a::AbstractMatrix, b::Abs
     n = size(a, 2)
     length(r) == n || throw(DimensionMismatch("Incorrect size of r."))
     for j = 1 : n
-        @inbounds r[j] = evaluate(metric, view(a, :, j), b)
+        @inbounds r[j] = evaluate(metric, slice(a, :, j), b)
     end
     r
 end
@@ -51,7 +51,7 @@ function colwise!(r::AbstractArray, metric::PreMetric, a::AbstractMatrix, b::Abs
     n = get_common_ncols(a, b)
     length(r) == n || throw(DimensionMismatch("Incorrect size of r."))
     for j = 1 : n
-        @inbounds r[j] = evaluate(metric, view(a, :, j), view(b, :, j))
+        @inbounds r[j] = evaluate(metric, slice(a, :, j), slice(b, :, j))
     end
     r
 end
@@ -86,9 +86,9 @@ function pairwise!(r::AbstractMatrix, metric::PreMetric, a::AbstractMatrix, b::A
     nb = size(b, 2)
     size(r) == (na, nb) || throw(DimensionMismatch("Incorrect size of r."))
     for j = 1 : size(b, 2)
-        bj = view(b,:,j)
+        bj = slice(b,:,j)
         for i = 1 : size(a, 2)
-            @inbounds r[i,j] = evaluate(metric, view(a,:,i), bj)
+            @inbounds r[i,j] = evaluate(metric, slice(a,:,i), bj)
         end
     end
     r
@@ -102,9 +102,9 @@ function pairwise!(r::AbstractMatrix, metric::SemiMetric, a::AbstractMatrix)
     n = size(a, 2)
     size(r) == (n, n) || throw(DimensionMismatch("Incorrect size of r."))
     for j = 1 : n
-        aj = view(a,:,j)
+        aj = slice(a,:,j)
         for i = j+1 : n
-            @inbounds r[i,j] = evaluate(metric, view(a,:,i), aj)
+            @inbounds r[i,j] = evaluate(metric, slice(a,:,i), aj)
         end
         @inbounds r[j,j] = 0
         for i = 1 : j-1

src/metrics.jl

@@ -28,18 +28,15 @@ type JSDivergence <: SemiMetric end
 
 type SpanNormDist <: SemiMetric end
 
-typealias UnionMetrics @compat(Union{Euclidean, SqEuclidean, Chebyshev, Cityblock, Minkowski, Hamming, Jaccard, RogersTanimoto, CosineDist, CorrDist, ChiSqDist, KLDivergence, JSDivergence, SpanNormDist})
+
+typealias UnionMetrics Union{Euclidean, SqEuclidean, Chebyshev, Cityblock, Minkowski, Hamming, Jaccard, RogersTanimoto, CosineDist, CorrDist, ChiSqDist, KLDivergence, JSDivergence, SpanNormDist}
 
 ###########################################################
 #
 #  Define Evaluate
 #
 ###########################################################
 
-if VERSION < v"0.4.0-dev+1624"
-    eachindex(A::AbstractArray...) = 1:length(A[1])
-end
-
 function evaluate(d::UnionMetrics, a::AbstractArray, b::AbstractArray)
     if length(a) != length(b)
         throw(DimensionMismatch("first array has length $(length(a)) which does not match the length of the second, $(length(b))."))
@@ -72,52 +69,52 @@ eval_end(d::UnionMetrics, s) = s
 evaluate{T <: Number}(dist::UnionMetrics, a::T, b::T) = eval_end(dist, eval_op(dist, a, b))
 
 # SqEuclidean
-@compat @inline eval_op(::SqEuclidean, ai, bi) = abs2(ai - bi)
-@compat @inline eval_reduce(::SqEuclidean, s1, s2) = s1 + s2
+@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{T <: Number}(a::T, b::T) = evaluate(SqEuclidean(), a, b)
 
 # Euclidean
-@compat @inline eval_op(::Euclidean, ai, bi) = abs2(ai - bi)
-@compat @inline eval_reduce(::Euclidean, s1, s2) = s1 + s2
+@inline eval_op(::Euclidean, ai, bi) = abs2(ai - bi)
+@inline eval_reduce(::Euclidean, s1, s2) = s1 + s2
 eval_end(::Euclidean, s) = sqrt(s)
 euclidean(a::AbstractArray, b::AbstractArray) = evaluate(Euclidean(), a, b)
 euclidean(a::Number, b::Number) = evaluate(Euclidean(), a, b)
 
 # Cityblock
-@compat @inline eval_op(::Cityblock, ai, bi) = abs(ai - bi)
-@compat @inline eval_reduce(::Cityblock, s1, s2) = s1 + s2
+@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{T <: Number}(a::T, b::T) = evaluate(Cityblock(), a, b)
 
 # Chebyshev
-@compat @inline eval_op(::Chebyshev, ai, bi) = abs(ai - bi)
-@compat @inline eval_reduce(::Chebyshev, s1, s2) = max(s1, s2)
+@inline eval_op(::Chebyshev, ai, bi) = abs(ai - bi)
+@inline eval_reduce(::Chebyshev, s1, s2) = max(s1, s2)
 # if only NaN, will output NaN
-@compat @inline eval_start(::Chebyshev, a::AbstractArray, b::AbstractArray) = abs(a[1] - b[1])
+@inline eval_start(::Chebyshev, a::AbstractArray, b::AbstractArray) = abs(a[1] - b[1])
 chebyshev(a::AbstractArray, b::AbstractArray) = evaluate(Chebyshev(), a, b)
 chebyshev{T <: Number}(a::T, b::T) = evaluate(Chebyshev(), a, b)
 
 # Minkowski
-@compat @inline eval_op(dist::Minkowski, ai, bi) = abs(ai - bi) .^ dist.p
-@compat @inline eval_reduce(::Minkowski, s1, s2) = s1 + s2
+@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{T <: Number}(a::T, b::T, p::Real) = evaluate(Minkowski(p), a, b)
 
 # Hamming
-@compat @inline eval_op(::Hamming, ai, bi) = ai != bi ? 1 : 0
-@compat @inline eval_reduce(::Hamming, s1, s2) = s1 + s2
+@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{T <: Number}(a::T, b::T) = evaluate(Hamming(), a, b)
 
 # Cosine dist
 function eval_start{T<:AbstractFloat}(::CosineDist, a::AbstractArray{T}, b::AbstractArray{T})
     zero(T), zero(T), zero(T)
 end
-@compat @inline eval_op(::CosineDist, ai, bi) = ai * bi, ai * ai, bi * bi
-@compat @inline function eval_reduce(::CosineDist, s1, s2)
+@inline eval_op(::CosineDist, ai, bi) = ai * bi, ai * ai, bi * bi
+@inline function eval_reduce(::CosineDist, s1, s2)
     a1, b1, c1 = s1
     a2, b2, c2 = s2
     return a1 + a2, b1 + b2, c1 + c2
@@ -135,32 +132,32 @@ corr_dist(a::AbstractArray, b::AbstractArray) = evaluate(CorrDist(), a, b)
 result_type(::CorrDist, a::AbstractArray, b::AbstractArray) = result_type(CosineDist(), a, b)
 
 # ChiSqDist
-@compat @inline eval_op(::ChiSqDist, ai, bi) = abs2(ai - bi) / (ai + bi)
-@compat @inline eval_reduce(::ChiSqDist, s1, s2) = s1 + s2
+@inline eval_op(::ChiSqDist, ai, bi) = abs2(ai - bi) / (ai + bi)
+@inline eval_reduce(::ChiSqDist, s1, s2) = s1 + s2
 chisq_dist(a::AbstractArray, b::AbstractArray) = evaluate(ChiSqDist(), a, b)
 
 # KLDivergence
-@compat @inline eval_op(::KLDivergence, ai, bi) = ai > 0 ? ai * log(ai / bi) : zero(ai)
-@compat @inline eval_reduce(::KLDivergence, s1, s2) = s1 + s2
+@inline eval_op(::KLDivergence, ai, bi) = ai > 0 ? ai * log(ai / bi) : zero(ai)
+@inline eval_reduce(::KLDivergence, s1, s2) = s1 + s2
 kl_divergence(a::AbstractArray, b::AbstractArray) = evaluate(KLDivergence(), a, b)
 
 # JSDivergence
-@compat @inline function eval_op{T}(::JSDivergence, ai::T, bi::T)
+@inline function eval_op{T}(::JSDivergence, ai::T, bi::T)
     u = (ai + bi) / 2
     ta = ai > 0 ? ai * log(ai) / 2 : zero(log(one(T)))
     tb = bi > 0 ? bi * log(bi) / 2 : zero(log(one(T)))
     tu = u > 0 ? u * log(u) : zero(log(one(T)))
     ta + tb - tu
 end
-@compat @inline eval_reduce(::JSDivergence, s1, s2) = s1 + s2
+@inline eval_reduce(::JSDivergence, s1, s2) = s1 + s2
 js_divergence(a::AbstractArray, b::AbstractArray) = evaluate(JSDivergence(), a, b)
 
 # SpanNormDist
 function eval_start(::SpanNormDist, a::AbstractArray, b::AbstractArray)
     a[1] - b[1], a[1] - b[1]
 end
-@compat @inline eval_op(::SpanNormDist, ai, bi)  = ai - bi
-@compat @inline function eval_reduce(::SpanNormDist, s1, s2)
+@inline eval_op(::SpanNormDist, ai, bi)  = ai - bi
+@inline function eval_reduce(::SpanNormDist, s1, s2)
     min_d, max_d = s1
     if s2 > max_d
         max_d = s2
@@ -179,38 +176,38 @@ end
 
 # Jaccard
 
-@compat @inline eval_start(::Jaccard, a::AbstractArray, b::AbstractArray) = 0, 0
-@compat @inline function eval_op(::Jaccard, s1, s2)
+@inline eval_start(::Jaccard, a::AbstractArray, b::AbstractArray) = 0, 0
+@inline function eval_op(::Jaccard, s1, s2)
     denominator = max(s1, s2)
     numerator = min(s1, s2)
     numerator, denominator
 end
-@compat @inline function eval_reduce(::Jaccard, s1, s2)
+@inline function eval_reduce(::Jaccard, s1, s2)
     a = s1[1] + s2[1]
     b = s1[2] + s2[2]
     a, b
 end
-@compat @inline eval_end(::Jaccard, a) = 1 - (a[1]/a[2])
+@inline eval_end(::Jaccard, a) = 1 - (a[1]/a[2])
 jaccard(a::AbstractArray, b::AbstractArray) = evaluate(Jaccard(), a, b)
 
 # Tanimoto
 
-@compat @inline eval_start(::RogersTanimoto, a::AbstractArray, b::AbstractArray) = 0, 0, 0, 0
-@compat @inline function eval_op(::RogersTanimoto, s1, s2)
+@inline eval_start(::RogersTanimoto, a::AbstractArray, b::AbstractArray) = 0, 0, 0, 0
+@inline function eval_op(::RogersTanimoto, s1, s2)
   tt = s1 && s2
   tf = s1 && !s2
   ft = !s1 && s2
   ff = !s1 && !s2
   tt, tf, ft, ff
 end
-@compat @inline function eval_reduce(::RogersTanimoto, s1, s2)
+@inline function eval_reduce(::RogersTanimoto, s1, s2)
     a = s1[1] + s2[1]
     b = s1[2] + s2[2]
     c = s1[3] + s2[3]
     d = s1[4] + s1[4]
     a, b, c, d
 end
-@compat @inline function eval_end(::RogersTanimoto, a)
+@inline function eval_end(::RogersTanimoto, a)
     numerator = 2(a[2] + a[3])
     denominator = a[1] + a[4] + 2(a[2] + a[3])
     numerator / denominator

src/wmetrics.jl

@@ -31,7 +31,7 @@ immutable WeightedHamming{W <: RealAbstractArray} <: Metric
 end
 
 
-typealias UnionWeightedMetrics{W} @compat(Union{WeightedEuclidean{W}, WeightedSqEuclidean{W}, WeightedCityblock{W}, WeightedMinkowski{W}, WeightedHamming{W}})
+typealias UnionWeightedMetrics{W} Union{WeightedEuclidean{W}, WeightedSqEuclidean{W}, WeightedCityblock{W}, WeightedMinkowski{W}, WeightedHamming{W}}
 Base.eltype(x::UnionWeightedMetrics) = eltype(x.weights)
 ###########################################################
 #
@@ -82,30 +82,30 @@ function evaluate(d::UnionWeightedMetrics, a::AbstractArray, b::AbstractArray)
 end
 
 # Squared Euclidean
-@compat @inline eval_op(::WeightedSqEuclidean, ai, bi, wi) = abs2(ai - bi) * wi
-@compat @inline eval_reduce(::WeightedSqEuclidean, s1, s2) = s1 + s2
+@inline eval_op(::WeightedSqEuclidean, ai, bi, wi) = abs2(ai - bi) * wi
+@inline eval_reduce(::WeightedSqEuclidean, s1, s2) = s1 + s2
 wsqeuclidean(a::AbstractArray, b::AbstractArray, w::AbstractArray) = evaluate(WeightedSqEuclidean(w), a, b)
 
 # Weighted Euclidean
-@compat @inline eval_op(::WeightedEuclidean, ai, bi, wi) = abs2(ai - bi) * wi
-@compat @inline eval_reduce(::WeightedEuclidean, s1, s2) = s1 + s2
-@compat @inline eval_end(::WeightedEuclidean, s) = sqrt(s)
+@inline eval_op(::WeightedEuclidean, ai, bi, wi) = abs2(ai - bi) * wi
+@inline eval_reduce(::WeightedEuclidean, s1, s2) = s1 + s2
+@inline eval_end(::WeightedEuclidean, s) = sqrt(s)
 weuclidean(a::AbstractArray, b::AbstractArray, w::AbstractArray) = evaluate(WeightedEuclidean(w), a, b)
 
 # City Block
-@compat @inline eval_op(::WeightedCityblock, ai, bi, wi) = abs((ai - bi) * wi)
-@compat @inline eval_reduce(::WeightedCityblock, s1, s2) = s1 + s2
+@inline eval_op(::WeightedCityblock, ai, bi, wi) = abs((ai - bi) * wi)
+@inline eval_reduce(::WeightedCityblock, s1, s2) = s1 + s2
 wcityblock(a::AbstractArray, b::AbstractArray, w::AbstractArray) = evaluate(WeightedCityblock(w), a, b)
 
 # Minkowski
-@compat @inline eval_op(dist::WeightedMinkowski, ai, bi, wi) = abs(ai - bi) .^ dist.p * wi
-@compat @inline eval_reduce(::WeightedMinkowski, s1, s2) = s1 + s2
+@inline eval_op(dist::WeightedMinkowski, ai, bi, wi) = abs(ai - bi) .^ dist.p * wi
+@inline eval_reduce(::WeightedMinkowski, s1, s2) = s1 + s2
 eval_end(dist::WeightedMinkowski, s) = s .^ (1/dist.p)
 wminkowski(a::AbstractArray, b::AbstractArray, w::AbstractArray, p::Real) = evaluate(WeightedMinkowski(w, p), a, b)
 
 # WeightedHamming
-@compat @inline eval_op(::WeightedHamming, ai, bi, wi) = ai != bi ? wi : zero(eltype(wi))
-@compat @inline eval_reduce(::WeightedHamming, s1, s2) = s1 + s2
+@inline eval_op(::WeightedHamming, ai, bi, wi) = ai != bi ? wi : zero(eltype(wi))
+@inline eval_reduce(::WeightedHamming, s1, s2) = s1 + s2
 whamming(a::AbstractArray, b::AbstractArray, w::AbstractArray) = evaluate(WeightedHamming(w), a, b)
 
 ###########################################################

test/REQUIRE

@@ -0,0 +1 @@
+BaseTestNext