update code to be rid of dep warnings on v0.6

Author: Hua-Zhou

src/VarianceComponentModels.jl

@@ -23,7 +23,7 @@ model.
 - `lb`: lower bounds for `vec(B)`
 - `ub`: upper bounds for `vec(B)`
 """
-type VarianceComponentModel{T <: AbstractFloat, M,
+mutable struct VarianceComponentModel{T <: AbstractFloat, M,
   BT <: AbstractVecOrMat, ΣT <: AbstractMatrix}
   # model parameters
   B::BT
@@ -34,12 +34,6 @@ type VarianceComponentModel{T <: AbstractFloat, M,
   b::Union{T, Vector{T}}
   lb::Union{T, Vector{T}}
   ub::Union{T, Vector{T}}
-  # inner constructor
-  function VarianceComponentModel(B::AbstractVecOrMat{T},
-    Σ::NTuple{M, AbstractMatrix{T}}, A::Matrix{T}, sense::Union{Char, Vector{Char}},
-    b::Union{T, Vector{T}}, lb::Union{T, Vector{T}}, ub::Union{T, Vector{T}})
-    new(B, Σ, A, sense, b, lb, ub)
-  end
 end
 
 """
@@ -48,15 +42,15 @@ end
 
 Default constructor of [`VarianceComponentModel`](@ref) type.
 """
-function VarianceComponentModel{M}(
+function VarianceComponentModel(
   B::AbstractVecOrMat,
   Σ::NTuple{M, AbstractMatrix},
   A::Matrix = zeros(eltype(B), 0, length(B)),
   sense::Union{Char, Vector{Char}} = Array{Char}(0),
   b::Union{Number, Vector} = zeros(eltype(B), 0),
   lb::Union{Number, Vector} = convert(eltype(B), -Inf),
   ub::Union{Number, Vector} = convert(eltype(B), Inf),
-  )
+  ) where {M}
 
   VarianceComponentModel{eltype(B), M, typeof(B), eltype(Σ)}(B, Σ, A, sense, b,
     lb, ub)
@@ -67,7 +61,7 @@ end
 
 Construct [`VarianceComponentModel`](@ref) from `Σ` alone. `B` is treated empty.
 """
-function VarianceComponentModel{M}(Σ::NTuple{M, AbstractMatrix})
+function VarianceComponentModel(Σ::NTuple{M, AbstractMatrix}) where {M}
   B = zeros(eltype(Σ[1]), 0, size(Σ[1], 1))
   VarianceComponentModel(B, Σ)
 end
@@ -81,15 +75,11 @@ end
 - `eigvec`: eigenvectors of `eig(Σ[1], Σ[2])`
 - `logdetΣ2`: log-determinant of `Σ[2]`
 """
-immutable TwoVarCompModelRotate{T <: AbstractFloat, BT <: AbstractVecOrMat}
+struct TwoVarCompModelRotate{T <: AbstractFloat, BT <: AbstractVecOrMat}
   Brot::BT
   eigval::Vector{T}
   eigvec::Matrix{T}
   logdetΣ2::T
-  function TwoVarCompModelRotate(Brot::AbstractVecOrMat{T},
-    eigval::Vector{T}, eigvec::Matrix{T}, logdetΣ2::T)
-    new(Brot, eigval, eigvec, logdetΣ2)
-  end
 end
 
 """
@@ -137,17 +127,12 @@ model.
 - `X`: `n x p` predictors
 - `V`: tuple of `n x n` covariance matrices
 """
-type VarianceComponentVariate{T <: AbstractFloat, M,
+mutable struct VarianceComponentVariate{T <: AbstractFloat, M,
   YT <: AbstractVecOrMat, XT <: AbstractVecOrMat, VT <: AbstractMatrix}
   # data
   Y::YT
   X::XT
   V::NTuple{M, VT}
-  # inner constructor
-  function VarianceComponentVariate(Y::AbstractVecOrMat{T},
-    X::AbstractVecOrMat{T}, V::NTuple{M, AbstractMatrix{T}})
-    new(Y, X, V)
-  end
 end
 
 """
@@ -189,20 +174,14 @@ end
 - `eigvec`: eigenvectors of `eig(V[1], V[2])`
 - `logdetV2`: log-determinant of `V[2]`
 """
-immutable TwoVarCompVariateRotate{T <: AbstractFloat, YT <: AbstractVecOrMat,
+struct TwoVarCompVariateRotate{T <: AbstractFloat, YT <: AbstractVecOrMat,
   XT <: AbstractVecOrMat}
   # data
   Yrot::YT
   Xrot::XT
   eigval::Vector{T}
   eigvec::Matrix{T}
   logdetV2::T
-
-  # inner constructor
-  function TwoVarCompVariateRotate(Yrot::AbstractVecOrMat{T},
-    Xrot::AbstractVecOrMat{T}, eigval::Vector{T}, eigvec::Matrix{T}, logdetV2::T)
-    new(Yrot, Xrot, eigval, eigvec, logdetV2)
-  end
 end
 
 """
@@ -268,7 +247,7 @@ Construct a [`VarianceComponentModel`](@ref) instance from a [`VarianceComponent
 instance. `B` is initialized to zero; `Σ` is initialized to a tupe of identity
 matrices.
 """
-function VarianceComponentModel{T, M}(vcobs::VarianceComponentVariate{T, M})
+function VarianceComponentModel(vcobs::VarianceComponentVariate{T, M}) where {T, M}
 
   p, d, m = size(vcobs.X, 2), size(vcobs.Y, 2), length(vcobs.V)
   B = zeros(T, p, d)
@@ -295,7 +274,7 @@ end
 Auxillary data for variance component model. This can be used as pre-allocated
 intermediate variable in iterative algorithm.
 """
-immutable VarianceComponentAuxData{
+struct VarianceComponentAuxData{
   T1 <: AbstractMatrix,
   T2 <: AbstractVector
   }
@@ -485,10 +464,10 @@ function residual(vcm::VarianceComponentModel, vcobs::VarianceComponentVariate)
   return isempty(vcobs.X)? vcobs.Y : vcobs.Y - vcobs.X * vcm.B
 end
 
-function residual{T1 <: VarianceComponentModel, T2 <: VarianceComponentVariate}(
+function residual(
   vcm::T1,
   vcdata::Array{T2}
-  )
+  ) where {T1 <: VarianceComponentModel, T2 <: VarianceComponentVariate}
 
   map(x -> residual(vcm, x), vcdata)
 end
@@ -509,11 +488,11 @@ function residual!(
   resid
 end
 
-function residual!{T1 <: VarianceComponentModel, T2 <: VarianceComponentVariate}(
+function residual!(
   resid::AbstractArray,
   vcm::T1,
   vcdata::Array{T2}
-  )
+  ) where {T1 <: VarianceComponentModel, T2 <: VarianceComponentVariate}
 
   map(x -> residual!(x[1], vcm, x[2]), zip(resid, vcdata))
 end
@@ -531,10 +510,10 @@ function residual(vcmrot::TwoVarCompModelRotate, vcobsrot::TwoVarCompVariateRota
   end
 end
 
-function residual{T1 <: TwoVarCompModelRotate, T2 <: TwoVarCompVariateRotate}(
+function residual(
   vcmrot::T1,
   vcdatarot::Array{T2}
-  )
+  ) where {T1 <: TwoVarCompModelRotate, T2 <: TwoVarCompVariateRotate}
 
   map(x -> residual(vcmrot, x), vcdatarot)
 end
@@ -556,10 +535,10 @@ function residual!(
   resid
 end
 
-function residual!{T1 <: TwoVarCompModelRotate, T2 <: TwoVarCompVariateRotate}(
+function residual!(
   resid::Array{AbstractMatrix},
   vcmrot::T1,
-  vcdatarot::Array{T2})
+  vcdatarot::Array{T2}) where {T1 <: TwoVarCompModelRotate, T2 <: TwoVarCompVariateRotate}
 
   map!(x -> residual(vcmrot, x), resid, vcdatarot)
 end

src/multivariate_calculus.jl

@@ -115,14 +115,14 @@ duplication(M::AbstractMatrix) = duplication(eltype(M), size(M, 1))
 Compute the gradient `d / d vec(X)` from a vector of derivatives `dM` where
 `M=X⊗Y`, `n, q = size(X)`, and `p, r = size(Y)`.
 """
-function kron_gradient!{T <: Real}(g::VecOrMat{T}, dM::VecOrMat{T},
-  Y::Matrix{T}, n::Integer, q::Integer)
+function kron_gradient!(g::VecOrMat{T}, dM::VecOrMat{T},
+  Y::Matrix{T}, n::Integer, q::Integer) where {T <: Real}
   p, r = size(Y)
   A_mul_B!(g, kron(speye(n * q), vec(Y)'),
     (kron(speye(q), spcommutation(n, r), speye(p)) * dM))
 end
-function kron_gradient{T <: Real}(dM::VecOrMat{T}, Y::Matrix{T},
-  n::Integer, q::Integer)
+function kron_gradient(dM::VecOrMat{T}, Y::Matrix{T},
+  n::Integer, q::Integer) where {T <: Real}
   if ndims(dM) == 1
     g = zeros(T, n * q)
   else
@@ -138,13 +138,13 @@ Compute the gradient `d / d vech(L)` from a vector of derivatives `dM` where
 `M=L*L'`.
 # TODO make it more memory efficient
 """
-function chol_gradient!{T <: Real}(g::AbstractVecOrMat{T},
-  dM::AbstractVecOrMat{T}, L::AbstractMatrix{T})
+function chol_gradient!(g::AbstractVecOrMat{T},
+  dM::AbstractVecOrMat{T}, L::AbstractMatrix{T}) where {T <: Real}
   n = size(L, 1)
   At_mul_B!(g, spduplication(n),
     kron(L', speye(n)) * (dM + spcommutation(n) * dM))
 end
-function chol_gradient{T <: Real}(dM::AbstractVecOrMat{T}, L::AbstractMatrix{T})
+function chol_gradient(dM::AbstractVecOrMat{T}, L::AbstractMatrix{T}) where {T <: Real}
   n = size(L, 1)
   if ndims(dM) == 1 # vector
     g = zeros(T, binomial(n + 1, 2))
@@ -159,8 +159,8 @@ end
 
 Overwrites `Y` with `A ⊗ X + Y`. Same as `Y += kron(A, X)` but more efficient.
 """
-function kronaxpy!{T <: Real}(A::AbstractVecOrMat{T},
-  X::AbstractVecOrMat{T}, Y::AbstractVecOrMat{T})
+function kronaxpy!(A::AbstractVecOrMat{T},
+  X::AbstractVecOrMat{T}, Y::AbstractVecOrMat{T}) where {T <: Real}
 
   # retrieve matrix sizes
   m, n = size(A, 1), size(A, 2)
@@ -182,7 +182,7 @@ end
 """
 Add `ϵ` to the diagonal entries of matrix `A`.
 """
-function bump_diagonal!{T}(A::Matrix{T}, ϵ::T)
+function bump_diagonal!(A::Matrix{T}, ϵ::T) where {T}
   @inbounds @simd for i in 1:minimum(size(A))
     A[i, i] += ϵ
   end
@@ -192,7 +192,7 @@ end
 """
 Clamp the diagonal entries of matrix `A` to `[lo, hi]`.
 """
-function clamp_diagonal!{T}(A::Matrix{T}, lo::T, hi::T)
+function clamp_diagonal!(A::Matrix{T}, lo::T, hi::T) where {T}
   @inbounds @simd for i in 1:minimum(size(A))
     A[i, i] = clamp(A[i, i], lo, hi)
   end