Fix 0.4 deprecations

Also change tests for show for power divergence to show to IOBuffer

REQUIRE

@@ -1,3 +1,4 @@
 Distributions
 Roots
 StatsBase
+Compat

src/HypothesisTests.jl

@@ -24,9 +24,7 @@
 
 module HypothesisTests
 
-using Distributions
-using Roots
-using StatsBase
+using Distributions, Roots, StatsBase, Compat
 
 export testname, pvalue, ci
 abstract HypothesisTest

src/b.jl

@@ -32,7 +32,7 @@ immutable BTest <: HypothesisTest
     stderr::Float64  # standard error
 end
 
-function BTest{T<:Real, S<:Real}(X::AbstractMatrix{T}, Y::AbstractMatrix{S}; kernel::Symbol=:rbf, blocksize::Int=int(floor(sqrt(size(X,1)))))
+function BTest{T<:Real, S<:Real}(X::AbstractMatrix{T}, Y::AbstractMatrix{S}; kernel::Symbol=:rbf, blocksize::Int=floor(Int, sqrt(size(X,1))))
     n = size(X,1)
     check_blocksize(blocksize, n)
     check_same_size(X, Y)

src/binomial.jl

@@ -35,7 +35,7 @@ immutable BinomialTest <: HypothesisTest
 end
 
 BinomialTest(x::AbstractVector{Bool}, p=0.5) =
-	BinomialTest(sum(x), length(x), float64(p))
+	BinomialTest(sum(x), length(x), p)
 
 testname(::BinomialTest) = "Binomial test"
 population_param_of_interest(x::BinomialTest) = ("Probability of success", x.p, x.x/x.n) # parameter of interest: name, value under h0, point estimate
@@ -124,7 +124,7 @@ immutable SignTest <: HypothesisTest
 end
 
 SignTest{T<:Real}(x::AbstractVector{T}, median::Real=0) =
-	SignTest(float64(median), sum(x .> median), sum(x .!= median), sort(x))
+	SignTest(median, sum(x .> median), sum(x .!= median), sort(x))
 SignTest{T<:Real, S<:Real}(x::AbstractVector{T}, y::AbstractVector{S}) = SignTest(x - y, 0.0)
 
 testname(::SignTest) = "Sign Test"
@@ -142,17 +142,17 @@ end
 pvalue(x::SignTest; tail=:both) = pvalue(Binomial(x.n, 0.5), x.x; tail=tail)
 
 # confidence interval by inversion
-function ci(x::SignTest, alpha::Float64=0.05; tail=:both)
+@compat function ci(x::SignTest, alpha::Float64=0.05; tail=:both)
 	check_alpha(alpha)
 
 	if tail == :left
-		q = quantile(Binomial(x.n, 0.5), alpha)
+		q = Int(quantile(Binomial(x.n, 0.5), alpha))
 		(x.data[q+1], x.median)
 	elseif tail == :right
-		q = quantile(Binomial(x.n, 0.5), alpha)
+		q = Int(quantile(Binomial(x.n, 0.5), alpha))
 		(x.median, x.data[end-q])
 	elseif tail == :both
-		q = quantile(Binomial(x.n, 0.5), alpha/2)
+		q = Int(quantile(Binomial(x.n, 0.5), alpha/2))
 		(x.data[q+1], x.data[end-q])
 	else
 		throw(ArgumentError("tail=$(tail) is invalid"))

src/circular.jl

@@ -39,13 +39,13 @@ immutable RayleighTest <: HypothesisTest
 	n::Int        # number of observations
 end
 function RayleighTest{S <: Complex}(samples::Vector{S})
-	s = float64(abs(sum(samples./abs(samples))))
+	s = @compat Float64(abs(sum(samples./abs(samples))))
 	n = length(samples)
 	Rbar = s/n
 	RayleighTest(Rbar, n)
 end
 function RayleighTest{S <: Real}(samples::Vector{S})
-	s = float64(abs(sum(exp(im*samples))))
+	s = @compat Float64(abs(sum(exp(im*samples))))
 	n = length(samples)
 	Rbar = s/n
 	RayleighTest(Rbar, n)

src/power_divergence.jl

@@ -1,5 +1,7 @@
 export PowerDivergenceTest, ChisqTest, MultinomialLRT
 
+typealias Levels{T} @compat(Tuple{UnitRange{T},UnitRange{T}})
+
 function boundproportion{T<:Real}(x::T)
   max(min(x,1),0)
 end
@@ -254,7 +256,7 @@ end
 #convenience functions
 
 #PDT
-function PowerDivergenceTest{T<: Integer, U<: FloatingPoint}(x::AbstractVector{T}, y::AbstractVector{T}, levels::(Range1{T},Range1{T}); lambda::U=1.0)
+function PowerDivergenceTest{T<: Integer, U<: FloatingPoint}(x::AbstractVector{T}, y::AbstractVector{T}, levels::Levels{T}; lambda::U=1.0)
   d = counts(x,y,levels)
   PowerDivergenceTest(d,lambda=lambda)
 end
@@ -272,7 +274,7 @@ function ChisqTest{T<: Integer}(x::AbstractMatrix{T})
   PowerDivergenceTest(x,lambda=1.0)
 end
 
-function ChisqTest{T<: Integer}(x::AbstractVector{T}, y::AbstractVector{T}, levels::(Range1{T},Range1{T}))
+function ChisqTest{T<: Integer}(x::AbstractVector{T}, y::AbstractVector{T}, levels::Levels{T})
   d = counts(x,y,levels)
   PowerDivergenceTest(d,lambda=1.0)
 end
@@ -290,7 +292,7 @@ function MultinomialLRT{T<: Integer}(x::AbstractMatrix{T})
   PowerDivergenceTest(x,lambda=0.0)
 end
 
-function MultinomialLRT{T<: Integer}(x::AbstractVector{T}, y::AbstractVector{T}, levels::(Range1{T},Range1{T}))
+function MultinomialLRT{T<: Integer}(x::AbstractVector{T}, y::AbstractVector{T}, levels::Levels{T})
   d = counts(x,y,levels)
   PowerDivergenceTest(d,lambda=0.0)
 end

test/power_divergence.jl

@@ -29,27 +29,27 @@ c0 =
 m = PowerDivergenceTest(d,lambda=0.0)
 testname(m)
 pvalue(m)
-show(m)
+show(IOBuffer(), m)
 
 m = PowerDivergenceTest(d,lambda=-1.0)
 testname(m)
 pvalue(m)
-show(m)
+show(IOBuffer(), m)
 
 m = PowerDivergenceTest(d,lambda=-2.0)
 testname(m)
 pvalue(m)
-show(m)
+show(IOBuffer(), m)
 
 m = PowerDivergenceTest(d,lambda=-0.5)
 testname(m)
 pvalue(m)
-show(m)
+show(IOBuffer(), m)
 
 m = PowerDivergenceTest(d,lambda=2/3)
 testname(m)
 pvalue(m)
-show(m)
+show(IOBuffer(), m)
 
 m = ChisqTest(d)
 m = MultinomialLRT(d)
@@ -101,27 +101,27 @@ c0 = [(0.04999999999999999,0.5833301356192295),(0.0,0.49999680228589616),(0.1333
 m = PowerDivergenceTest(d,lambda=0.0)
 testname(m)
 pvalue(m)
-show(m)
+show(IOBuffer(), m)
 
 m = PowerDivergenceTest(d,lambda=-1.0)
 testname(m)
 pvalue(m)
-show(m)
+show(IOBuffer(), m)
 
 m = PowerDivergenceTest(d,lambda=-2.0)
 testname(m)
 pvalue(m)
-show(m)
+show(IOBuffer(), m)
 
 m = PowerDivergenceTest(d,lambda=-0.5)
 testname(m)
 pvalue(m)
-show(m)
+show(IOBuffer(), m)
 
 m = PowerDivergenceTest(d,lambda=2/3)
 testname(m)
 pvalue(m)
-show(m)
+show(IOBuffer(), m)
 
 m = ChisqTest(d)
 m = MultinomialLRT(d)