Merge pull request #417 from yuyichao/0.4-binding

Fix 0.4 deprecation warnings
JuliaStats · Sep 20, 2015 · 3bf11d1 · 3bf11d1
2 parents 0fa0e23 + ba5787d
commit 3bf11d1
Show file tree

Hide file tree

Showing 11 changed files with 38 additions and 41 deletions.
diff --git a/.travis.yml b/.travis.yml
@@ -3,7 +3,8 @@ os:
   - linux
   - osx
 julia:
-  - release
+  - 0.3
+  - 0.4
   - nightly
 notifications:
   email: false

diff --git a/doc/source/multivariate.rst b/doc/source/multivariate.rst
@@ -144,7 +144,7 @@ We realize that the mean vector and the covariance often have special forms in p
 
 .. code-block:: julia
 
-    immutable MvNormal{Cov<:AbstractPDMat,Mean<:Union(Vector{Float64},ZeroVector{Float64})} <: AbstractMvNormal
+    immutable MvNormal{Cov<:AbstractPDMat,Mean<:Union{Vector{Float64},ZeroVector{Float64}}} <: AbstractMvNormal
         μ::Mean
         Σ::Cov
     end
@@ -237,7 +237,7 @@ The canonical parameterization is widely used in Bayesian analysis. We provide a
 
 .. code:: julia
 
-    immutable MvNormalCanon{P<:AbstractPDMat,V<:Union(Vector{Float64},ZeroVector{Float64})} <: AbstractMvNormal
+    immutable MvNormalCanon{P<:AbstractPDMat,V<:Union{Vector{Float64},ZeroVector{Float64}}} <: AbstractMvNormal
         μ::V    # the mean vector
         h::V    # potential vector, i.e. inv(Σ) * μ
         J::P    # precision matrix, i.e. inv(Σ)

diff --git a/doc/source/types.rst b/doc/source/types.rst
@@ -106,7 +106,7 @@ To simplify the use in practice, we introduce a series of type alias as follows:
     typealias UnivariateDistribution{S<:ValueSupport}   Distribution{Univariate,S}
     typealias MultivariateDistribution{S<:ValueSupport} Distribution{Multivariate,S}
     typealias MatrixDistribution{S<:ValueSupport}       Distribution{Matrixvariate,S}
-    typealias NonMatrixDistribution Union(UnivariateDistribution, MultivariateDistribution)
+    typealias NonMatrixDistribution Union{UnivariateDistribution, MultivariateDistribution}
 
     typealias DiscreteDistribution{F<:VariateForm}   Distribution{F,Discrete}
     typealias ContinuousDistribution{F<:VariateForm} Distribution{F,Continuous}

diff --git a/src/common.jl b/src/common.jl
@@ -41,7 +41,7 @@ abstract Distribution{F<:VariateForm,S<:ValueSupport} <: Sampleable{F,S}
 typealias UnivariateDistribution{S<:ValueSupport}   Distribution{Univariate,S}
 typealias MultivariateDistribution{S<:ValueSupport} Distribution{Multivariate,S}
 typealias MatrixDistribution{S<:ValueSupport}       Distribution{Matrixvariate,S}
-typealias NonMatrixDistribution Union(UnivariateDistribution, MultivariateDistribution)
+@compat typealias NonMatrixDistribution Union{UnivariateDistribution, MultivariateDistribution}
 
 typealias DiscreteDistribution{F<:VariateForm}   Distribution{F,Discrete}
 typealias ContinuousDistribution{F<:VariateForm} Distribution{F,Continuous}
@@ -64,4 +64,4 @@ abstract SufficientStats
 abstract IncompleteDistribution
 
 typealias DistributionType{D<:Distribution} Type{D}
-typealias IncompleteFormulation Union(DistributionType,IncompleteDistribution)
+@compat typealias IncompleteFormulation Union{DistributionType,IncompleteDistribution}
diff --git a/src/multivariate/dirichlet.jl b/src/multivariate/dirichlet.jl
@@ -143,7 +143,7 @@ end
 
 # sampling
 
-function _rand!{T<:Real}(d::Union(Dirichlet,DirichletCanon), x::AbstractVector{T})
+@compat function _rand!{T<:Real}(d::Union{Dirichlet,DirichletCanon}, x::AbstractVector{T})
     s = 0.0
     n = length(x)
     α = d.alpha

diff --git a/src/multivariate/mvnormal.jl b/src/multivariate/mvnormal.jl
@@ -60,7 +60,7 @@ _pdf!{T<:Real}(r::DenseArray, d::AbstractMvNormal, x::AbstractMatrix{T}) = exp!(
 #
 ###########################################################
 
-immutable MvNormal{Cov<:AbstractPDMat,Mean<:Union(Vector{Float64},ZeroVector{Float64})} <: AbstractMvNormal
+@compat immutable MvNormal{Cov<:AbstractPDMat,Mean<:Union{Vector{Float64},ZeroVector{Float64}}} <: AbstractMvNormal
     μ::Mean
     Σ::Cov
 end

diff --git a/src/multivariate/mvnormalcanon.jl b/src/multivariate/mvnormalcanon.jl
@@ -2,50 +2,50 @@
 
 ### Generic types
 
-immutable MvNormalCanon{P<:AbstractPDMat,V<:Union(Vector{Float64},ZeroVector{Float64})} <: AbstractMvNormal
+@compat immutable MvNormalCanon{P<:AbstractPDMat,V<:Union{Vector{Float64},ZeroVector{Float64}}} <: AbstractMvNormal
     μ::V    # the mean vector
     h::V    # potential vector, i.e. inv(Σ) * μ
     J::P    # precision matrix, i.e. inv(Σ)
 end
 
-typealias FullNormalCanon MvNormalCanon{PDMat,Vector{Float64}} 
-typealias DiagNormalCanon MvNormalCanon{PDiagMat,Vector{Float64}} 
+typealias FullNormalCanon MvNormalCanon{PDMat,Vector{Float64}}
+typealias DiagNormalCanon MvNormalCanon{PDiagMat,Vector{Float64}}
 typealias IsoNormalCanon  MvNormalCanon{ScalMat,Vector{Float64}}
 
-typealias ZeroMeanFullNormalCanon MvNormalCanon{PDMat,ZeroVector{Float64}} 
-typealias ZeroMeanDiagNormalCanon MvNormalCanon{PDiagMat,ZeroVector{Float64}} 
+typealias ZeroMeanFullNormalCanon MvNormalCanon{PDMat,ZeroVector{Float64}}
+typealias ZeroMeanDiagNormalCanon MvNormalCanon{PDiagMat,ZeroVector{Float64}}
 typealias ZeroMeanIsoNormalCanon  MvNormalCanon{ScalMat,ZeroVector{Float64}}
 
 
 ### Constructors
 
-function MvNormalCanon{P<:AbstractPDMat}(μ::Vector{Float64}, h::Vector{Float64}, J::P) 
+function MvNormalCanon{P<:AbstractPDMat}(μ::Vector{Float64}, h::Vector{Float64}, J::P)
     length(μ) == length(h) == dim(J) || throw(DimensionMismatch("Inconsistent argument dimensions"))
     MvNormalCanon{P,Vector{Float64}}(μ, h, J)
 end
 
-function MvNormalCanon{P<:AbstractPDMat}(J::P) 
+function MvNormalCanon{P<:AbstractPDMat}(J::P)
     z = ZeroVector(Float64, dim(J))
     MvNormalCanon{P,ZeroVector{Float64}}(z, z, J)
 end
 
-function MvNormalCanon{P<:AbstractPDMat}(h::Vector{Float64}, J::P) 
+function MvNormalCanon{P<:AbstractPDMat}(h::Vector{Float64}, J::P)
     length(h) == dim(J) || throw(DimensionMismatch("Inconsistent argument dimensions"))
     MvNormalCanon{P,Vector{Float64}}(J \ h, h, J)
 end
 
 MvNormalCanon(h::Vector{Float64}, J::Matrix{Float64}) = MvNormalCanon(h, PDMat(J))
 MvNormalCanon(h::Vector{Float64}, prec::Vector{Float64}) = MvNormalCanon(h, PDiagMat(prec))
-MvNormalCanon(h::Vector{Float64}, prec::Float64) = MvNormalCanon(h, ScalMat(length(h), prec)) 
+MvNormalCanon(h::Vector{Float64}, prec::Float64) = MvNormalCanon(h, ScalMat(length(h), prec))
 
 MvNormalCanon(J::Matrix{Float64}) = MvNormalCanon(PDMat(J))
 MvNormalCanon(prec::Vector{Float64}) = MvNormalCanon(PDiagMat(prec))
-MvNormalCanon(d::Int, prec::Float64) = MvNormalCanon(ScalMat(d, prec)) 
+MvNormalCanon(d::Int, prec::Float64) = MvNormalCanon(ScalMat(d, prec))
 
 
 ### Show
 
-distrname(d::IsoNormalCanon) = "IsoNormalCanon"  
+distrname(d::IsoNormalCanon) = "IsoNormalCanon"
 distrname(d::DiagNormalCanon) = "DiagNormalCanon"
 distrname(d::FullNormalCanon) = "FullNormalCanon"
 
@@ -85,5 +85,3 @@ unwhiten_winv!(J::PDiagMat, x::DenseVecOrMat) = whiten!(J, x)
 unwhiten_winv!(J::ScalMat, x::DenseVecOrMat) = whiten!(J, x)
 
 _rand!(d::MvNormalCanon, x::DenseVecOrMat) = add!(unwhiten_winv!(d.J, randn!(x)), d.μ)
-
-
diff --git a/src/multivariates.jl b/src/multivariates.jl
@@ -1,16 +1,15 @@
-
 ##### Generic methods #####
 
 ## sampling
 
 function rand!(d::MultivariateDistribution, x::DenseVector)
-    length(x) == length(d) || 
+    length(x) == length(d) ||
         throw(DimensionMismatch("Output size inconsistent with sample length."))
     _rand!(d, x)
 end
 
 function rand!(d::MultivariateDistribution, A::DenseMatrix)
-    size(A,1) == length(d) || 
+    size(A,1) == length(d) ||
         throw(DimensionMismatch("Output size inconsistent with sample length."))
     _rand!(sampler(d), A)
 end
@@ -20,7 +19,7 @@ rand(d::MultivariateDistribution, n::Int) = _rand!(sampler(d), Array(eltype(d),
 
 ## domain
 
-function insupport!{D<:MultivariateDistribution}(r::AbstractArray, d::Union(D,Type{D}), X::AbstractMatrix)
+@compat function insupport!{D<:MultivariateDistribution}(r::AbstractArray, d::Union{D,Type{D}}, X::AbstractMatrix)
     n = length(r)
     size(X) == (length(d),n) ||
         throw(DimensionMismatch("Inconsistent array dimensions."))
@@ -30,7 +29,7 @@ function insupport!{D<:MultivariateDistribution}(r::AbstractArray, d::Union(D,Ty
     return r
 end
 
-insupport{D<:MultivariateDistribution}(d::Union(D,Type{D}), X::AbstractMatrix) = 
+@compat insupport{D<:MultivariateDistribution}(d::Union{D,Type{D}}, X::AbstractMatrix) =
     insupport!(BitArray(size(X,2)), d, X)
 
 ## statistics

diff --git a/src/truncate.jl b/src/truncate.jl
@@ -1,4 +1,3 @@
-
 immutable Truncated{D<:UnivariateDistribution, S<:ValueSupport} <: UnivariateDistribution{S}
     untruncated::D      # the original distribution (untruncated)
     lower::Float64      # lower bound
@@ -30,7 +29,7 @@ isupperbounded(d::Truncated) = isupperbounded(d.untruncated) || isfinite(d.upper
 minimum(d::Truncated) = max(minimum(d.untruncated), d.lower)
 maximum(d::Truncated) = min(maximum(d.untruncated), d.upper)
 
-insupport{D<:UnivariateDistribution}(d::Truncated{D,Union(Discrete,Continuous)}, x::Real) =
+@compat insupport{D<:UnivariateDistribution}(d::Truncated{D,Union{Discrete,Continuous}}, x::Real) =
     d.lower <= x <= d.upper && insupport(d.untruncated, x)
 
 

diff --git a/src/univariates.jl b/src/univariates.jl
@@ -11,15 +11,15 @@ minimum(r::RealInterval) = r.lb
 maximum(r::RealInterval) = r.ub
 @compat in(x::Real, r::RealInterval) = (r.lb <= Float64(x) <= r.ub)
 
-isbounded{D<:UnivariateDistribution}(d::Union(D,Type{D})) = isupperbounded(d) && islowerbounded(d)
+@compat isbounded{D<:UnivariateDistribution}(d::Union{D,Type{D}}) = isupperbounded(d) && islowerbounded(d)
 
-islowerbounded{D<:UnivariateDistribution}(d::Union(D,Type{D})) = minimum(d) > -Inf
-isupperbounded{D<:UnivariateDistribution}(d::Union(D,Type{D})) = maximum(d) < +Inf
+@compat islowerbounded{D<:UnivariateDistribution}(d::Union{D,Type{D}}) = minimum(d) > -Inf
+@compat isupperbounded{D<:UnivariateDistribution}(d::Union{D,Type{D}}) = maximum(d) < +Inf
 
-hasfinitesupport{D<:DiscreteUnivariateDistribution}(d::Union(D,Type{D})) = isbounded(d)
-hasfinitesupport{D<:ContinuousUnivariateDistribution}(d::Union(D,Type{D})) = false
+@compat hasfinitesupport{D<:DiscreteUnivariateDistribution}(d::Union{D,Type{D}}) = isbounded(d)
+@compat hasfinitesupport{D<:ContinuousUnivariateDistribution}(d::Union{D,Type{D}}) = false
 
-function insupport!{D<:UnivariateDistribution}(r::AbstractArray, d::Union(D,Type{D}), X::AbstractArray)
+@compat function insupport!{D<:UnivariateDistribution}(r::AbstractArray, d::Union{D,Type{D}}, X::AbstractArray)
     length(r) == length(X) ||
         throw(DimensionMismatch("Inconsistent array dimensions."))
     for i in 1 : length(X)
@@ -28,22 +28,22 @@ function insupport!{D<:UnivariateDistribution}(r::AbstractArray, d::Union(D,Type
     return r
 end
 
-insupport{D<:UnivariateDistribution}(d::Union(D,Type{D}), X::AbstractArray) =
+@compat insupport{D<:UnivariateDistribution}(d::Union{D,Type{D}}, X::AbstractArray) =
      insupport!(BitArray(size(X)), d, X)
 
-insupport{D<:ContinuousUnivariateDistribution}(d::Union(D,Type{D}),x::Real) = minimum(d) <= x <= maximum(d)
-insupport{D<:DiscreteUnivariateDistribution}(d::Union(D,Type{D}),x::Real) = isinteger(x) && minimum(d) <= x <= maximum(d)
+@compat insupport{D<:ContinuousUnivariateDistribution}(d::Union{D,Type{D}},x::Real) = minimum(d) <= x <= maximum(d)
+@compat insupport{D<:DiscreteUnivariateDistribution}(d::Union{D,Type{D}},x::Real) = isinteger(x) && minimum(d) <= x <= maximum(d)
 
-support{D<:ContinuousUnivariateDistribution}(d::Union(D,Type{D})) = RealInterval(minimum(d), maximum(d))
-support{D<:DiscreteUnivariateDistribution}(d::Union(D,Type{D})) = round(Int, minimum(d)):round(Int, maximum(d))
+@compat support{D<:ContinuousUnivariateDistribution}(d::Union{D,Type{D}}) = RealInterval(minimum(d), maximum(d))
+@compat support{D<:DiscreteUnivariateDistribution}(d::Union{D,Type{D}}) = round(Int, minimum(d)):round(Int, maximum(d))
 
 ## macros to declare support
 
 macro distr_support(D, lb, ub)
     D_has_constantbounds = (isa(ub, Number) || ub == :Inf) &&
                            (isa(lb, Number) || lb == :(-Inf))
 
-    paramdecl = D_has_constantbounds ? :(d::Union($D, Type{$D})) : :(d::$D)
+    @compat paramdecl = D_has_constantbounds ? :(d::Union{$D, Type{$D}}) : :(d::$D)
 
     # overall
     esc(quote

diff --git a/src/utils.jl b/src/utils.jl
@@ -66,7 +66,7 @@ end
 
 isprobvec(p::Vector{Float64}) = allnonneg(p) && isapprox(sum(p), 1.0)
 
-function pnormalize!{T<:FloatingPoint}(v::AbstractVector{T})
+function pnormalize!{T<:AbstractFloat}(v::AbstractVector{T})
     s = 0.
     n = length(v)
     for i = 1:n