Generalize call to Base.LinAlg.chksquare for v"0.5"

src/MixedModels.jl

@@ -1,8 +1,8 @@
-#VERSION >= v"0.4.0-dev+6521" && __precompile__()
+# __precompile__()
 
 module MixedModels
 
-using DataArrays, DataFrames, Distributions, NLopt, Showoff, StatsBase
+using DataArrays, DataFrames, Distributions, NLopt, Showoff, StatsBase, GLM
 
 export ReMat, ScalarReMat,VectorReMat
 
@@ -14,6 +14,7 @@ export LinearMixedModel,
        BIC,        # Schwatz's Bayesian Information Criterion
        bootstrap,  # Create bootstrap replications of a model
        fixef,      # extract the fixed-effects parameter estimates
+       glmm,       # create a GeneralizedLinearMixedModel from formula, data, distribution, link
        lmm,        # create a LinearMixedModel from a formula/data specification
        lowerbd,    # lower bounds on the covariance parameters
        npar,       # total number of parameters in the model
@@ -27,6 +28,8 @@ export LinearMixedModel,
        simulate!,  # simulate a new response and refit the model
        varest      # estimate of the residual variance
 
+chksqr = VERSION < v"0.5-" ? Base.LinAlg.chksquare : Base.LinAlg.checksquare
+
 abstract MixedModel <: RegressionModel # model with fixed and random effects
 
 import Base: ==
@@ -42,7 +45,7 @@ include("inject.jl")
 include("pls.jl")
 include("logdet.jl")
 include("bootstrap.jl")
-include("GLMM/glmtools.jl")
+#include("GLMM/glmtools.jl")
 include("GLMM/PIRLS.jl")
 
 end # module

src/bootstrap.jl

@@ -23,7 +23,7 @@ Regenerate the last column of `m.A` from `m.trms`
 This should be called after updating parts of `m.trms[end]`, typically the response.
 """
 function regenerateAend!(m::LinearMixedModel)
-    n = Base.LinAlg.chksquare(m.A)
+    n = chksqr(m.A)
     trmn = m.trms[n]
     for i in 1:n
         Ac_mul_B!(m.A[i,n],m.trms[i],trmn)

src/cfactor.jl

@@ -5,7 +5,7 @@ Uses `inject!` (as opposed to `copy!`), `downdate!` (as opposed to `syrk!`
     or `gemm!`) and recursive calls to `cfactor!`,
 """
 function cfactor!(A::AbstractMatrix)
-    n = Base.LinAlg.chksquare(A)
+    n = chksqr(A)
     for k = 1:n
         Akk = A[k,k]
         for i in 1:(k - 1)
@@ -135,7 +135,7 @@ end
 
 function downdate!{T}(C::DenseMatrix{T},A::SparseMatrixCSC{T})
     m,n = size(A)
-    if n ≠ Base.LinAlg.chksquare(C)
+    if n ≠ chksqr(C)
         throw(DimensionMismatch("C is not square or size(C,2) ≠ size(A,2)"))
     end
     # FIXME: avoid allocation by caching a transposed matrix and just fill in the new values

src/inflate.jl

@@ -16,7 +16,7 @@ end
 inflate!(D::Diagonal{Float64}) = (d = D.diag; for i in eachindex(d) d[i] += 1 end; D)
 
 function inflate!{T<:AbstractFloat}(A::StridedMatrix{T})
-    n = Base.LinAlg.chksquare(A)
+    n = chksqr(A)
     for i in 1:n
         @inbounds A[i,i] += 1
     end

src/inject.jl

@@ -16,7 +16,7 @@ end
 
 function inject!{T<:Real}(d::StridedMatrix{T}, s::Diagonal{T})
     sd = s.diag
-    if length(sd) ≠ Base.LinAlg.chksquare(d)  # why does d have to be square?
+    if length(sd) ≠ chksqr(d)  # why does d have to be square?
         throw(DimensionMismatch("size(d,2) ≠ size(s,2)"))
     end
     fill!(d,zero(T))

src/linalg.jl

@@ -30,7 +30,7 @@ function Base.LinAlg.Ac_ldiv_B!{T}(A::UpperTriangular{T,HBlkDiag{T}},B::DenseMat
     m,n = size(B)
     aa = A.data.arr
     r,s,k = size(aa)
-    if m ≠ Base.LinAlg.chksquare(A)
+    if m ≠ chksqr(A)
         throw(DimensionMismatch("size(A,2) ≠ size(B,1)"))
     end
     scr = Array(T,(r,n))

src/logdet.jl

@@ -22,7 +22,7 @@ end
 
 function LD{T}(d::DenseMatrix{T})
     r = log(one(T))
-    n = Base.LinAlg.chksquare(d)
+    n = chksqr(d)
     for j in 1:n
         r += log(d[j,j])
     end

src/paramlowertriangular.jl

@@ -1,5 +1,5 @@
 nlower(n::Integer) = (n*(n+1))>>1
-nlower{T}(A::LowerTriangular{T,Matrix{T}}) = nlower(Base.LinAlg.chksquare(A))
+nlower{T}(A::LowerTriangular{T,Matrix{T}}) = nlower(chksqr(A))
 
 """
 return the lower triangle as a vector (column-major ordering)
@@ -8,7 +8,7 @@ function Base.getindex{T}(A::LowerTriangular{T,Matrix{T}},s::Symbol)
     if s ≠ :θ
         throw(KeyError(s))
     end
-    n = Base.LinAlg.chksquare(A)
+    n = chksqr(A)
     res = Array(T,nlower(n))
     k = 0
     for j = 1:n, i in j:n
@@ -28,7 +28,7 @@ function Base.setindex!{T}(
     if s ≠ :θ
         throw(KeyError(s))
     end
-    n = Base.LinAlg.chksquare(A)
+    n = chksqr(A)
     if length(v) ≠ nlower(n)
         throw(DimensionMismatch("length(v) ≠ nlower(A)"))
     end
@@ -43,7 +43,7 @@ end
 lower bounds on the parameters (elements in the lower triangle)
 """
 function lowerbd{T}(A::LowerTriangular{T,Matrix{T}})
-    n = Base.LinAlg.chksquare(A)
+    n = chksqr(A)
     res = fill(convert(T,-Inf),nlower(n))
     k = -n
     for j in n+1:-1:2
@@ -71,7 +71,7 @@ scale B using the implicit expansion of A to a homogeneous block diagonal
 function tscale!(A::LowerTriangular,B::HBlkDiag)
     Ba = B.arr
     r,s,k = size(Ba)
-    n = Base.LinAlg.chksquare(A)
+    n = chksqr(A)
     if n ≠ r
         throw(DimensionMismatch("size(A,2) ≠ blocksize of B"))
     end
@@ -80,7 +80,7 @@ function tscale!(A::LowerTriangular,B::HBlkDiag)
 end
 
 function tscale!{T}(A::LowerTriangular{T},B::Diagonal{T})
-    if Base.LinAlg.chksquare(A) ≠ 1
+    if chksqr(A) ≠ 1
         throw(DimensionMismatch("A must be a 1×1 LowerTriangular"))
     end
     scale!(A.data[1],B.diag)
@@ -101,7 +101,7 @@ function LT(A::VectorReMat)
 end
 
 function tscale!{T}(A::LowerTriangular{T},B::DenseVecOrMat{T})
-    if (l = Base.LinAlg.chksquare(A)) == 1
+    if (l = chksqr(A)) == 1
         return scale!(A.data[1],B)
     end
     m,n = size(B,1),size(B,2)  # this sets n = 1 when B is a vector
@@ -114,23 +114,23 @@ function tscale!{T}(A::LowerTriangular{T},B::DenseVecOrMat{T})
 end
 
 function tscale!{T}(A::LowerTriangular{T},B::SparseMatrixCSC{T})
-    if (l = Base.LinAlg.chksquare(A)) ≠ 1
+    if (l = chksqr(A)) ≠ 1
         error("Code not yet written")
     end
     scale!(A.data[1],B.nzval)
     B
 end
 
 function tscale!{T}(A::SparseMatrixCSC{T},B::LowerTriangular)
-    if (l = Base.LinAlg.chksquare(B)) != 1
+    if (l = chksqr(B)) != 1
         error("Code not yet written")
     end
     scale!(A.nzval,B.data[1])
     A
 end
 
 function tscale!{T}(A::Diagonal{T},B::LowerTriangular{T})
-    if (l = Base.LinAlg.chksquare(B)) ≠ 1
+    if (l = chksqr(B)) ≠ 1
         throw(DimensionMismatch(
         "in tscale!(A::Diagonal,B::LowerTriangular) B must be 1×1"))
     end
@@ -148,7 +148,7 @@ function tscale!{T}(A::HBlkDiag{T},B::LowerTriangular{T})
 end
 
 function tscale!{T}(A::StridedMatrix{T},B::LowerTriangular{T})
-    l = Base.LinAlg.chksquare(B)
+    l = chksqr(B)
     l == 1 && return scale!(A,B.data[1])
     m,n = size(A)
     q,r = divrem(n,l)