Compat not actually needed now that this package is 0.4+ (#43)

Author: tkelman

REQUIRE

@@ -3,4 +3,3 @@ StatsBase
 Distributions
 Optim
 Interpolations
-Compat

src/KernelDensity.jl

@@ -1,12 +1,11 @@
-VERSION >= v"0.4.0-dev+6521" && __precompile__()
+__precompile__()
 
 module KernelDensity
 
 using StatsBase
 using Distributions
 using Optim
 using Interpolations
-using Compat
 
 import Base: conv
 import StatsBase: RealVector, RealMatrix

src/bivariate.jl

@@ -5,26 +5,26 @@ 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
 
 # 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{DataType, DataType}, 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}))
+function tabulate(data::Tuple{RealVector, RealVector}, midpoints::Tuple{Range, Range})
     xdata, ydata = data
     ndata = length(xdata)
     length(ydata) == ndata || error("data vectors must be of same length")
@@ -54,7 +54,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)
@@ -79,37 +79,37 @@ function conv(k::BivariateKDE, dist::(@compat Tuple{UnivariateDistribution,Univa
     BivariateKDE(k.x, k.y, dens)
 end
 
-typealias BivariateDistribution @compat(Union{MultivariateDistribution,Tuple{UnivariateDistribution,UnivariateDistribution}})
+typealias BivariateDistribution Union{MultivariateDistribution,Tuple{UnivariateDistribution,UnivariateDistribution}}
 
-function kde(data::(@compat Tuple{RealVector, RealVector}), midpoints::(@compat Tuple{Range, Range}), dist::BivariateDistribution)
+function kde(data::Tuple{RealVector, RealVector}, midpoints::Tuple{Range, Range}, dist::BivariateDistribution)
     k = tabulate(data,midpoints)
     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))
 
     xmid = kde_range(boundary[1],npoints[1])
     ymid = kde_range(boundary[2],npoints[2])
 
     kde(data,(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)
 
     dist = kernel_dist(kernel,bandwidth)
     kde(data,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))
 
     dist = kernel_dist(kernel,bandwidth)
     xmid = kde_range(boundary[1],npoints[1])

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})
+typealias LocationScale Union{Laplace,Logistic,SymTriangularDist}
 kernel_dist{D}(::Type{D},w::Real) = (s = w/std(D(0.0,1.0)); D(0.0,s))
 
 
@@ -58,7 +58,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")
 
@@ -125,7 +125,7 @@ function kde(data::RealVector, midpoints::Range, dist::UnivariateDistribution)
 end
 
 function kde(data::RealVector, dist::UnivariateDistribution;
-             boundary::(@compat Tuple{Real,Real})=kde_boundary(data,std(dist)), npoints::Int=2048)
+             boundary::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::(@compat Tuple{Real,Real})=kde_boundary(data,bandwidth))
+             npoints::Int=2048, boundary::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::(@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)))
 
     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::(@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)))
 
     midpoints = kde_range(boundary,npoints)
     kde_lscv(data,midpoints; kernel=kernel, bandwidth_range=bandwidth_range)

test/bivariate.jl

@@ -1,11 +1,10 @@
 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
@@ -33,7 +32,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((@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)