Merge branch 'master' into weights

Author: axsk

README.md

@@ -2,8 +2,9 @@
 
 [![Build Status](https://travis-ci.org/JuliaStats/KernelDensity.jl.svg?branch=master)](https://travis-ci.org/JuliaStats/KernelDensity.jl)
 [![Coverage Status](https://coveralls.io/repos/github/JuliaStats/KernelDensity.jl/badge.svg)](https://coveralls.io/github/JuliaStats/KernelDensity.jl)
-[![KernelDensity](http://pkg.julialang.org/badges/KernelDensity_0.4.svg)](http://pkg.julialang.org/?pkg=KernelDensity&ver=0.4)
+[![KernelDensity](http://pkg.julialang.org/badges/KernelDensity_0.4.svg)](http://pkg.julialang.org/?pkg=KernelDensity)
 [![KernelDensity](http://pkg.julialang.org/badges/KernelDensity_0.5.svg)](http://pkg.julialang.org/?pkg=KernelDensity)
+[![KernelDensity](http://pkg.julialang.org/badges/KernelDensity_0.6.svg)](http://pkg.julialang.org/?pkg=KernelDensity)
 
 Kernel density estimators for Julia.
 

REQUIRE

@@ -1,6 +1,6 @@
 julia 0.4
+Compat 0.17
 StatsBase
 Distributions
 Optim
 Interpolations
-Compat

src/KernelDensity.jl

@@ -1,20 +1,20 @@
-VERSION >= v"0.4.0-dev+6521" && __precompile__()
+__precompile__()
 
 module KernelDensity
 
+using Compat
 using StatsBase
 using Distributions
 using Optim
 using Interpolations
-using Compat
 
 import Base: conv
 import StatsBase: RealVector, RealMatrix
 import Distributions: twoπ, pdf
 
 export kde, kde_lscv, UnivariateKDE, BivariateKDE, InterpKDE, pdf
 
-abstract AbstractKDE
+@compat abstract type AbstractKDE end
 
 include("univariate.jl")
 include("bivariate.jl")

src/bivariate.jl

@@ -5,26 +5,32 @@ type BivariateKDE{Rx<:Range,Ry<:Range} <: AbstractKDE
     density::Matrix{Float64}
 end
 
-function kernel_dist{D<:UnivariateDistribution}(::Type{D},w::(@compat Tuple{Real,Real}))
+function kernel_dist{D<:UnivariateDistribution}(::Type{D},w::Tuple{Real,Real})
     kernel_dist(D,w[1]), kernel_dist(D,w[2])
 end
-function kernel_dist{Dx<:UnivariateDistribution,Dy<:UnivariateDistribution}(::Type{(@compat Tuple{Dx, Dy})},w::(@compat Tuple{Real,Real}))
+function kernel_dist{Dx<:UnivariateDistribution,Dy<:UnivariateDistribution}(::Type{Tuple{Dx, Dy}},w::Tuple{Real,Real})
     kernel_dist(Dx,w[1]), kernel_dist(Dy,w[2])
 end
 
+if VERSION >= v"0.6.0-dev.2123"
+    const DataTypeOrUnionAll = Union{DataType, UnionAll}
+else
+    const DataTypeOrUnionAll = DataType
+end
+
 # this function provided for backwards compatibility, though it doesn't have the type restrictions
 # to ensure that the given tuple only contains univariate distributions
-function kernel_dist(d::(@compat Tuple{DataType, DataType}),w::(@compat Tuple{Real,Real}))
+function kernel_dist(d::Tuple{DataTypeOrUnionAll, DataTypeOrUnionAll}, w::Tuple{Real,Real})
     kernel_dist(d[1],w[1]), kernel_dist(d[2],w[2])
 end
 
 # TODO: there are probably better choices.
-function default_bandwidth(data::(@compat Tuple{RealVector,RealVector}))
+function default_bandwidth(data::Tuple{RealVector,RealVector})
     default_bandwidth(data[1]), default_bandwidth(data[2])
 end
 
 # tabulate data for kde
-function tabulate(data::(@compat Tuple{RealVector, RealVector}), midpoints::(@compat Tuple{Range, Range}), weights::Weights = default_weights(data))
+function tabulate(data::Tuple{RealVector, RealVector}, midpoints::Tuple{Range, Range}, weights::Weights = default_weights(data))
     xdata, ydata = data
     ndata = length(xdata)
     length(ydata) == ndata || error("data vectors must be of same length")
@@ -56,7 +62,7 @@ function tabulate(data::(@compat Tuple{RealVector, RealVector}), midpoints::(@co
 end
 
 # convolution with product distribution of two univariates distributions
-function conv(k::BivariateKDE, dist::(@compat Tuple{UnivariateDistribution,UnivariateDistribution}) )
+function conv(k::BivariateKDE, dist::Tuple{UnivariateDistribution,UnivariateDistribution})
     # Transform to Fourier basis
     Kx, Ky = size(k.density)
     ft = rfft(k.density)
@@ -81,19 +87,19 @@ function conv(k::BivariateKDE, dist::(@compat Tuple{UnivariateDistribution,Univa
     BivariateKDE(k.x, k.y, dens)
 end
 
-typealias BivariateDistribution @compat(Union{MultivariateDistribution,Tuple{UnivariateDistribution,UnivariateDistribution}})
+const BivariateDistribution = Union{MultivariateDistribution,Tuple{UnivariateDistribution,UnivariateDistribution}}
 
-default_weights(data::(@compat Tuple{RealVector, RealVector})) = UniformWeights(length(data[1]))
+default_weights(data::Tuple{RealVector, RealVector}) = UniformWeights(length(data[1]))
 
-function kde(data::(@compat Tuple{RealVector, RealVector}), weights::Weights, midpoints::(@compat Tuple{Range, Range}), dist::BivariateDistribution)
+function kde(data::Tuple{RealVector, RealVector}, weights::Weights, midpoints::Tuple{Range, Range}, dist::BivariateDistribution)
     k = tabulate(data, midpoints, weights)
     conv(k,dist)
 end
 
-function kde(data::(@compat Tuple{RealVector, RealVector}), dist::BivariateDistribution;
-             boundary::(@compat Tuple{(@compat Tuple{Real,Real}),(@compat Tuple{Real,Real})}) = (kde_boundary(data[1],std(dist[1])),
+function kde(data::Tuple{RealVector, RealVector}, dist::BivariateDistribution;
+             boundary::Tuple{Tuple{Real,Real}, Tuple{Real,Real}} = (kde_boundary(data[1],std(dist[1])),
                                                      kde_boundary(data[2],std(dist[2]))),
-             npoints::(@compat Tuple{Int,Int})=(256,256),
+             npoints::Tuple{Int,Int}=(256,256),
              weights::Weights = default_weights(data))
 
     xmid = kde_range(boundary[1],npoints[1])
@@ -102,19 +108,19 @@ function kde(data::(@compat Tuple{RealVector, RealVector}), dist::BivariateDistr
     kde(data,weights,(xmid,ymid),dist)
 end
 
-function kde(data::(@compat Tuple{RealVector, RealVector}), midpoints::(@compat Tuple{Range, Range});
+function kde(data::Tuple{RealVector, RealVector}, midpoints::Tuple{Range, Range};
              bandwidth=default_bandwidth(data), kernel=Normal, weights::Weights = default_weights(data))
 
     dist = kernel_dist(kernel,bandwidth)
     kde(data,weights,midpoints,dist)
 end
 
-function kde(data::(@compat Tuple{RealVector, RealVector});
+function kde(data::Tuple{RealVector, RealVector};
              bandwidth=default_bandwidth(data),
              kernel=Normal,
-             boundary::(@compat Tuple{(@compat Tuple{Real,Real}),(@compat Tuple{Real,Real})}) = (kde_boundary(data[1],bandwidth[1]),
+             boundary::Tuple{Tuple{Real,Real}, Tuple{Real,Real}} = (kde_boundary(data[1],bandwidth[1]),
                                                      kde_boundary(data[2],bandwidth[2])),
-             npoints::(@compat Tuple{Int,Int})=(256,256),
+             npoints::Tuple{Int,Int}=(256,256),
              weights::Weights = default_weights(data))
 
     dist = kernel_dist(kernel,bandwidth)

src/interp.jl

@@ -1,9 +1,9 @@
-import Interpolations: interpolate
+import Interpolations: interpolate, scale
 
 type InterpKDE{K,I} <: AbstractKDE
     kde::K
     itp::I
-    InterpKDE(kde,itp) = new(kde,itp)
+    @compat (::Type{InterpKDE{K,I}}){K,I}(kde::K, itp::I) = new{K,I}(kde, itp)
 end
 
 

src/univariate.jl

@@ -8,7 +8,7 @@ end
 kernel_dist(::Type{Normal},w::Real) = Normal(0.0,w)
 kernel_dist(::Type{Uniform},w::Real) = (s = 1.7320508075688772*w; Uniform(-s,s))
 
-typealias LocationScale @compat(Union{Laplace,Logistic,SymTriangularDist})
+const LocationScale = Union{Laplace,Logistic,SymTriangularDist}
 kernel_dist{D}(::Type{D},w::Real) = (s = w/std(D(0.0,1.0)); D(0.0,s))
 
 
@@ -62,7 +62,7 @@ function kde_boundary(data::RealVector, bandwidth::Real)
 end
 
 # convert boundary and npoints to Range object
-function kde_range(boundary::(@compat Tuple{Real,Real}), npoints::Int)
+function kde_range(boundary::Tuple{Real,Real}, npoints::Int)
     lo, hi = boundary
     lo < hi || error("boundary (a,b) must have a < b")
 
@@ -142,7 +142,7 @@ function kde(data::RealVector, weights::Weights, midpoints::Range, dist::Univari
 end
 
 function kde(data::RealVector, dist::UnivariateDistribution;
-             boundary::(@compat Tuple{Real,Real})=kde_boundary(data,std(dist)), npoints::Int=2048, weights=default_weights(data))
+             boundary::Tuple{Real,Real}=kde_boundary(data,std(dist)), npoints::Int=2048, weights=default_weights(data))
 
     midpoints = kde_range(boundary,npoints)
     kde(data,weights,midpoints,dist)
@@ -156,7 +156,7 @@ function kde(data::RealVector, midpoints::Range;
 end
 
 function kde(data::RealVector; bandwidth=default_bandwidth(data), kernel=Normal,
-             npoints::Int=2048, boundary::(@compat Tuple{Real,Real})=kde_boundary(data,bandwidth), weights=default_weights(data))
+             npoints::Int=2048, boundary::Tuple{Real,Real}=kde_boundary(data,bandwidth), weights=default_weights(data))
     bandwidth > 0.0 || error("Bandwidth must be positive")
     dist = kernel_dist(kernel,bandwidth)
     kde(data,dist;boundary=boundary,npoints=npoints,weights=weights)
@@ -169,7 +169,7 @@ end
 
 function kde_lscv(data::RealVector, midpoints::Range;
                   kernel=Normal,
-                  bandwidth_range::(@compat Tuple{Real,Real})=(h=default_bandwidth(data); (0.25*h,1.5*h)),
+                  bandwidth_range::Tuple{Real,Real}=(h=default_bandwidth(data); (0.25*h,1.5*h)),
                   weights=default_weights(data))
 
     ndata = length(data)
@@ -179,7 +179,7 @@ function kde_lscv(data::RealVector, midpoints::Range;
     K = length(k.density)
     ft = rfft(k.density)
 
-    ft2 = abs2(ft)
+    ft2 = @compat(abs2.(ft))
     c = -twoπ/(step(k.x)*K)
     hlb, hub = bandwidth_range
 
@@ -193,7 +193,7 @@ function kde_lscv(data::RealVector, midpoints::Range;
         ψ*step(k.x)/K + pdf(dist,0.0)/ndata
     end
 
-    dist = kernel_dist(kernel, opt.minimum)
+    dist = kernel_dist(kernel, Optim.minimizer(opt))
     for j = 0:length(ft)-1
         ft[j+1] *= cf(dist, j*c)
     end
@@ -209,10 +209,10 @@ function kde_lscv(data::RealVector, midpoints::Range;
 end
 
 function kde_lscv(data::RealVector;
-                  boundary::(@compat Tuple{Real,Real})=kde_boundary(data,default_bandwidth(data)),
+                  boundary::Tuple{Real,Real}=kde_boundary(data,default_bandwidth(data)),
                   npoints::Int=2048,
                   kernel=Normal,
-                  bandwidth_range::(@compat Tuple{Real,Real})=(h=default_bandwidth(data); (0.25*h,1.5*h)),
+                  bandwidth_range::Tuple{Real,Real}=(h=default_bandwidth(data); (0.25*h,1.5*h)),
                   weights::Weights = default_weights(data))
 
     midpoints = kde_range(boundary,npoints)

test/bivariate.jl

@@ -1,18 +1,17 @@
 using Base.Test
 using Distributions
 using KernelDensity
-using Compat
 
 import KernelDensity: kernel_dist, default_bandwidth, kde_boundary, kde_range, tabulate
 
-for D in [(@compat Tuple{Normal,Normal}),(@compat Tuple{Uniform,Uniform}),(@compat Tuple{Logistic,Logistic}),
+for D in [Tuple{Normal,Normal}, Tuple{Uniform,Uniform}, Tuple{Logistic,Logistic},
           (Normal, Normal), (Uniform, Uniform), (Logistic, Logistic)]
     d = KernelDensity.kernel_dist(D,(0.5,0.5))
     dx,dy = d
     @test mean(dx) == 0.0
     @test mean(dy) == 0.0
-    @test_approx_eq std(dx) 0.5
-    @test_approx_eq std(dy) 0.5
+    @test std(dx) ≈ 0.5
+    @test std(dy) ≈ 0.5
 end
 
 r = kde_range((-2.0,2.0), 128)
@@ -31,31 +30,31 @@ for X in ([0.0], [0.0,0.0], [0.0,0.5], [-0.5:0.1:0.5;])
         @test isa(k1,BivariateKDE)
         @test size(k1.density) == (length(k1.x), length(k1.y))
         @test all(k1.density .>= 0.0)
-        @test_approx_eq sum(k1.density)*step(k1.x)*step(k1.y) 1.0
+        @test sum(k1.density)*step(k1.x)*step(k1.y) ≈ 1.0
 
-        k2 = conv(k1,kernel_dist((@compat Tuple{D,D}),(0.1,0.1)))
+        k2 = conv(k1,kernel_dist(Tuple{D,D}, (0.1,0.1)))
         @test isa(k2,BivariateKDE)
         @test size(k2.density) == (length(k2.x), length(k2.y))
         @test all(k2.density .>= 0.0)
-        @test_approx_eq sum(k2.density)*step(k2.x)*step(k2.y) 1.0
+        @test sum(k2.density)*step(k2.x)*step(k2.y) ≈ 1.0
 
         k3 = kde((X,X);kernel=D)
         @test isa(k3,BivariateKDE)
         @test size(k3.density) == (length(k3.x), length(k3.y))
         @test all(k3.density .>= 0.0)
-        @test_approx_eq sum(k3.density)*step(k3.x)*step(k3.y) 1.0
+        @test sum(k3.density)*step(k3.x)*step(k3.y) ≈ 1.0
 
         k4 = kde((X,X),(r,r);kernel=D)
         @test isa(k4,BivariateKDE)
         @test size(k4.density) == (length(k4.x), length(k4.y))
         @test all(k4.density .>= 0.0)
-        @test_approx_eq sum(k4.density)*step(k4.x)*step(k4.y) 1.0
+        @test sum(k4.density)*step(k4.x)*step(k4.y) ≈ 1.0
 
         k5 = kde([X X];kernel=D)
         @test isa(k5,BivariateKDE)
         @test size(k5.density) == (length(k5.x), length(k5.y))
         @test all(k5.density .>= 0.0)
-        @test_approx_eq sum(k5.density)*step(k5.x)*step(k5.y) 1.0
+        @test sum(k5.density)*step(k5.x)*step(k5.y) ≈ 1.0
 
     end
 end

test/interp.jl

@@ -5,7 +5,7 @@ X = randn(100)
 Y = randn(100)
 
 k = kde(X)
-@test_approx_eq pdf(k, k.x) k.density
+@test pdf(k, k.x) ≈ k.density
 
 k = kde((X,Y))
-@test_approx_eq pdf(k, k.x, k.y) k.density
+@test pdf(k, k.x, k.y) ≈ k.density

test/univariate.jl

@@ -8,7 +8,7 @@ for D in [Normal,Uniform,Logistic]
     d = kernel_dist(D,0.5)
     @test isa(d,D)
     @test mean(d) == 0.0
-    @test_approx_eq std(d) 0.5
+    @test std(d) ≈ 0.5
 end
 
 r = kde_range((-2.0,2.0), 128)
@@ -27,31 +27,31 @@ for X in ([0.0], [0.0,0.0], [0.0,0.5], [-0.5:0.1:0.5;])
         @test isa(k1,UnivariateKDE)
         @test length(k1.density) == length(k1.x)
         @test all(k1.density .>= 0.0)
-        @test_approx_eq sum(k1.density)*step(k1.x) 1.0
+        @test sum(k1.density)*step(k1.x) ≈ 1.0
 
         k2 = conv(k1,kernel_dist(D,0.1))
         @test isa(k2,UnivariateKDE)
         @test length(k2.density) == length(k2.x)
         @test all(k2.density .>= 0.0)
-        @test_approx_eq sum(k2.density)*step(k2.x) 1.0
+        @test sum(k2.density)*step(k2.x) ≈ 1.0
 
         k3 = kde(X;kernel=D)
         @test isa(k3,UnivariateKDE)
         @test length(k3.density) == length(k3.x)
         @test all(k3.density .>= 0.0)
-        @test_approx_eq sum(k3.density)*step(k3.x) 1.0
+        @test sum(k3.density)*step(k3.x) ≈ 1.0
 
         k4 = kde(X,r;kernel=D)
         @test isa(k4,UnivariateKDE)
         @test length(k4.density) == length(k4.x)
         @test all(k4.density .>= 0.0)
-        @test_approx_eq sum(k4.density)*step(k4.x) 1.0
+        @test sum(k4.density)*step(k4.x) ≈ 1.0
 
         k5 = kde_lscv(X)
         @test isa(k5,UnivariateKDE)
         @test length(k5.density) == length(k5.x)
         @test all(k5.density .>= 0.0)
-        @test_approx_eq sum(k5.density)*step(k5.x) 1.0
+        @test sum(k5.density)*step(k5.x) ≈ 1.0
 
         k6 = kde(X,r;kernel=D, weights=ones(X)/length(X)))
         @test_approx_eq k4.density k6.density