Merge pull request #14 from PalladiumConsulting/sg/tuple

update to v0.4 tuple syntax using @compat macro

Author: simonbyrne

REQUIRE

@@ -3,3 +3,4 @@ StatsBase
 Distributions 0.4.6
 Optim
 Grid
+Compat

src/KernelDensity.jl

@@ -4,6 +4,7 @@ using StatsBase
 using Distributions
 using Optim
 using Grid
+using Compat
 
 import Base: conv
 import StatsBase: RealVector, RealMatrix

src/bivariate.jl

@@ -5,20 +5,26 @@ type BivariateKDE{Rx<:Range,Ry<:Range}
     density::Matrix{Float64}
 end
 
-function kernel_dist{D<:UnivariateDistribution}(::Type{D},w::(Real,Real))
+function kernel_dist{D<:UnivariateDistribution}(::Type{D},w::(@compat Tuple{Real,Real}))
     kernel_dist(D,w[1]), kernel_dist(D,w[2])
 end
-function kernel_dist{Dx<:UnivariateDistribution,Dy<:UnivariateDistribution}(::Type{(Dx,Dy)},w::(Real,Real))
+function kernel_dist{Dx<:UnivariateDistribution,Dy<:UnivariateDistribution}(::Type{(@compat Tuple{Dx, Dy})},w::(@compat Tuple{Real,Real}))
     kernel_dist(Dx,w[1]), kernel_dist(Dy,w[2])
 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}))
+    kernel_dist(d[1],w[1]), kernel_dist(d[2],w[2])
+end
+
 # TODO: there are probably better choices.
-function default_bandwidth(data::(RealVector,RealVector))
+function default_bandwidth(data::(@compat Tuple{RealVector,RealVector}))
     default_bandwidth(data[1]), default_bandwidth(data[2])
 end
 
 # tabulate data for kde
-function tabulate(data::(RealVector, RealVector), midpoints::(Range, Range))
+function tabulate(data::(@compat Tuple{RealVector, RealVector}), midpoints::(@compat Tuple{Range, Range}))
     xdata, ydata = data
     ndata = length(xdata)
     length(ydata) == ndata || error("data vectors must be of same length")
@@ -48,7 +54,7 @@ function tabulate(data::(RealVector, RealVector), midpoints::(Range, Range))
 end
 
 # convolution with product distribution of two univariates distributions
-function conv(k::BivariateKDE, dist::(UnivariateDistribution,UnivariateDistribution) )
+function conv(k::BivariateKDE, dist::(@compat Tuple{UnivariateDistribution,UnivariateDistribution}) )
     # Transform to Fourier basis
     Kx, Ky = size(k.density)
     ft = rfft(k.density)
@@ -73,37 +79,37 @@ function conv(k::BivariateKDE, dist::(UnivariateDistribution,UnivariateDistribut
     BivariateKDE(k.x, k.y, dens)
 end
 
-typealias BivariateDistribution Union(MultivariateDistribution,(UnivariateDistribution,UnivariateDistribution))
+typealias BivariateDistribution Union(MultivariateDistribution,(@compat Tuple{UnivariateDistribution,UnivariateDistribution}))
 
-function kde(data::(RealVector, RealVector), midpoints::(Range, Range), dist::BivariateDistribution)
+function kde(data::(@compat Tuple{RealVector, RealVector}), midpoints::(@compat Tuple{Range, Range}), dist::BivariateDistribution)
     k = tabulate(data,midpoints)
     conv(k,dist)
 end
 
-function kde(data::(RealVector, RealVector), dist::BivariateDistribution;
-             boundary::((Real,Real),(Real,Real)) = (kde_boundary(data[1],std(dist[1])),
+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])),
                                                      kde_boundary(data[2],std(dist[2]))),
-             npoints::(Int,Int)=(256,256))
+             npoints::(@compat Tuple{Int,Int})=(256,256))
 
     xmid = kde_range(boundary[1],npoints[1])
     ymid = kde_range(boundary[2],npoints[2])
 
     kde(data,(xmid,ymid),dist)
 end
 
-function kde(data::(RealVector, RealVector), midpoints::(Range, Range);
+function kde(data::(@compat Tuple{RealVector, RealVector}), midpoints::(@compat Tuple{Range, Range});
              bandwidth=default_bandwidth(data), kernel=Normal)
 
     dist = kernel_dist(kernel,bandwidth)
     kde(data,midpoints,dist)
 end
 
-function kde(data::(RealVector, RealVector);
+function kde(data::(@compat Tuple{RealVector, RealVector});
              bandwidth=default_bandwidth(data),
              kernel=Normal,
-             boundary::((Real,Real),(Real,Real)) = (kde_boundary(data[1],bandwidth[1]),
+             boundary::(@compat Tuple{(@compat Tuple{Real,Real}),(@compat Tuple{Real,Real})}) = (kde_boundary(data[1],bandwidth[1]),
                                                      kde_boundary(data[2],bandwidth[2])),
-             npoints::(Int,Int)=(256,256))
+             npoints::(@compat Tuple{Int,Int})=(256,256))
 
     dist = kernel_dist(kernel,bandwidth)
     xmid = kde_range(boundary[1],npoints[1])

src/univariate.jl

@@ -58,7 +58,7 @@ function kde_boundary(data::RealVector, bandwidth::Real)
 end
 
 # convert boundary and npoints to Range object
-function kde_range(boundary::(Real,Real), npoints::Int)
+function kde_range(boundary::(@compat Tuple{Real,Real}), npoints::Int)
     lo, hi = boundary
     lo < hi || error("boundary (a,b) must have a < b")
 
@@ -125,7 +125,7 @@ function kde(data::RealVector, midpoints::Range, dist::UnivariateDistribution)
 end
 
 function kde(data::RealVector, dist::UnivariateDistribution;
-             boundary::(Real,Real)=kde_boundary(data,std(dist)), npoints::Int=2048)
+             boundary::(@compat Tuple{Real,Real})=kde_boundary(data,std(dist)), npoints::Int=2048)
 
     midpoints = kde_range(boundary,npoints)
     kde(data,midpoints,dist)
@@ -139,7 +139,7 @@ function kde(data::RealVector, midpoints::Range;
 end
 
 function kde(data::RealVector; bandwidth=default_bandwidth(data), kernel=Normal,
-             npoints::Int=2048, boundary::(Real,Real)=kde_boundary(data,bandwidth))
+             npoints::Int=2048, boundary::(@compat Tuple{Real,Real})=kde_boundary(data,bandwidth))
     bandwidth > 0.0 || error("Bandwidth must be positive")
     dist = kernel_dist(kernel,bandwidth)
     kde(data,dist;boundary=boundary,npoints=npoints)
@@ -152,7 +152,7 @@ end
 
 function kde_lscv(data::RealVector, midpoints::Range;
                   kernel=Normal,
-                  bandwidth_range::(Real,Real)=(h=default_bandwidth(data); (0.25*h,1.5*h)))
+                  bandwidth_range::(@compat Tuple{Real,Real})=(h=default_bandwidth(data); (0.25*h,1.5*h)))
 
     ndata = length(data)
     k = tabulate(data, midpoints)
@@ -191,10 +191,10 @@ function kde_lscv(data::RealVector, midpoints::Range;
 end
 
 function kde_lscv(data::RealVector;
-                  boundary::(Real,Real)=kde_boundary(data,default_bandwidth(data)),
+                  boundary::(@compat Tuple{Real,Real})=kde_boundary(data,default_bandwidth(data)),
                   npoints::Int=2048,
                   kernel=Normal,
-                  bandwidth_range::(Real,Real)=(h=default_bandwidth(data); (0.25*h,1.5*h)))
+                  bandwidth_range::(@compat Tuple{Real,Real})=(h=default_bandwidth(data); (0.25*h,1.5*h)))
 
     midpoints = kde_range(boundary,npoints)
     kde_lscv(data,midpoints; kernel=kernel, bandwidth_range=bandwidth_range)

test/bivariate.jl

@@ -1,12 +1,13 @@
 using Base.Test
 using Distributions
 using KernelDensity
+using Compat
 
 import KernelDensity: kernel_dist, default_bandwidth, kde_boundary, kde_range, tabulate
 
-for D in [(Normal,Normal),(Uniform,Uniform),(Logistic,Logistic)]
-    d = kernel_dist(D,(0.5,0.5))
-    @test isa(d,D)
+for D in [(@compat Tuple{Normal,Normal}),(@compat Tuple{Uniform,Uniform}),(@compat 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
@@ -17,7 +18,7 @@ end
 r = kde_range((-2.0,2.0), 128)
 @test step(r) > 0
 
-for X in ([0.0], [0.0,0.0], [0.0,0.5], [-0.5:0.1:0.5])
+for X in ([0.0], [0.0,0.0], [0.0,0.5], [-0.5:0.1:0.5;])
     w = default_bandwidth(X)
     @test w > 0
     lo, hi = kde_boundary(X,w)
@@ -32,7 +33,7 @@ for X in ([0.0], [0.0,0.0], [0.0,0.5], [-0.5:0.1:0.5])
         @test all(k1.density .>= 0.0)
         @test_approx_eq sum(k1.density)*step(k1.x)*step(k1.y) 1.0
 
-        k2 = conv(k1,kernel_dist((D,D),(0.1,0.1)))
+        k2 = conv(k1,kernel_dist((@compat 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/univariate.jl

@@ -14,7 +14,7 @@ end
 r = kde_range((-2.0,2.0), 128)
 @test step(r) > 0
 
-for X in ([0.0], [0.0,0.0], [0.0,0.5], [-0.5:0.1:0.5])
+for X in ([0.0], [0.0,0.0], [0.0,0.5], [-0.5:0.1:0.5;])
     w = default_bandwidth(X)
     @test w > 0
     lo, hi = kde_boundary(X,w)