Merge pull request #55 from JuliaStats/anj/06

Various 0.6 fixes
JuliaStats · Jan 17, 2017 · 0fddb9f · 0fddb9f
2 parents e4cb47a + 30eaeb1
commit 0fddb9f
Show file tree

Hide file tree

Showing 5 changed files with 57 additions and 63 deletions.
diff --git a/src/generics.jl b/src/generics.jl
@@ -39,10 +39,10 @@ unwhiten(a::AbstractPDMat, x::StridedVecOrMat) = unwhiten!(similar(x), a, x)
 
 function quad{T<:Real, S<:Real}(a::AbstractPDMat{T}, x::StridedMatrix{S})
     @check_argdims dim(a) == size(x, 1)
-    quad!(Array(promote_type(T, S), size(x,2)), a, x)
+    quad!(Array{promote_type(T, S)}(size(x,2)), a, x)
 end
 
 function invquad{T<:Real, S<:Real}(a::AbstractPDMat{T}, x::StridedMatrix{S})
     @check_argdims dim(a) == size(x, 1)
-    invquad!(Array(promote_type(T, S), size(x,2)), a, x)
+    invquad!(Array{promote_type(T, S)}(size(x,2)), a, x)
 end
diff --git a/src/scalmat.jl b/src/scalmat.jl
@@ -68,8 +68,8 @@ end
 
 ### quadratic forms
 
-quad(a::ScalMat, x::Vector) = sumabs2(x) * a.value
-invquad(a::ScalMat, x::Vector) = sumabs2(x) * a.inv_value
+quad(a::ScalMat, x::Vector) = sum(abs2, x) * a.value
+invquad(a::ScalMat, x::Vector) = sum(abs2, x) * a.inv_value
 
 quad!(r::AbstractArray, a::ScalMat, x::Matrix) = colwise_sumsq!(r, x, a.value)
 invquad!(r::AbstractArray, a::ScalMat, x::Matrix) = colwise_sumsq!(r, x, a.inv_value)

diff --git a/src/testutils.jl b/src/testutils.jl
@@ -4,7 +4,7 @@
 #       the implementation of a subtype of AbstractPDMat
 #
 
-import Base.Test: @test, @test_approx_eq
+import Base.Test: @test
 
 ## driver function
 function test_pdmat(C::AbstractPDMat, Cmat::Matrix;
@@ -81,7 +81,7 @@ function pdtest_cmat(C::AbstractPDMat, Cmat::Matrix, cmat_eq::Bool, verbose::Int
     if cmat_eq
         @test full(C) == Cmat
     else
-        @test_approx_eq full(C) Cmat
+        @test full(C) ≈ Cmat
     end
 end
 
@@ -91,47 +91,47 @@ function pdtest_diag(C::AbstractPDMat, Cmat::Matrix, cmat_eq::Bool, verbose::Int
     if cmat_eq
         @test diag(C) == diag(Cmat)
     else
-        @test_approx_eq diag(C) diag(Cmat)
+        @test diag(C) ≈ diag(Cmat)
     end
 end
 
 
 function pdtest_scale(C::AbstractPDMat, Cmat::Matrix, verbose::Int)
     _pdt(verbose, "scale")
-    @test_approx_eq full(C * convert(eltype(C),2)) Cmat * convert(eltype(C),2)
-    @test_approx_eq full(convert(eltype(C),2) * C) convert(eltype(C),2) * Cmat
+    @test full(C * convert(eltype(C),2)) ≈ Cmat * convert(eltype(C),2)
+    @test full(convert(eltype(C),2) * C) ≈ convert(eltype(C),2) * Cmat
 end
 
 
 function pdtest_add(C::AbstractPDMat, Cmat::Matrix, verbose::Int)
     M = rand(eltype(C),size(Cmat))
     _pdt(verbose, "add")
-    @test_approx_eq C + M Cmat + M
-    @test_approx_eq M + C M + Cmat
+    @test C + M ≈ Cmat + M
+    @test M + C ≈ M + Cmat
 
     _pdt(verbose, "add_scal")
-    @test_approx_eq pdadd(M, C, convert(eltype(C),2)) M + Cmat * convert(eltype(C),2)
+    @test pdadd(M, C, convert(eltype(C),2)) ≈ M + Cmat * convert(eltype(C),2)
 
     _pdt(verbose, "add_scal!")
     R = M + Cmat * convert(eltype(C),2)
     Mr = pdadd!(M, C, convert(eltype(C),2))
     @test Mr === M
-    @test_approx_eq Mr R
+    @test Mr ≈ R
 end
 
 
 function pdtest_logdet(C::AbstractPDMat, Cmat::Matrix, verbose::Int)
     _pdt(verbose, "logdet")
-    @test_approx_eq logdet(C) logdet(Cmat)
+    @test logdet(C) ≈ logdet(Cmat)
 end
 
 
 function pdtest_eig(C::AbstractPDMat, Cmat::Matrix, verbose::Int)
     _pdt(verbose, "eigmax")
-    @test_approx_eq eigmax(C) eigmax(Cmat)
+    @test eigmax(C) ≈ eigmax(Cmat)
 
     _pdt(verbose, "eigmin")
-    @test_approx_eq eigmin(C) eigmin(Cmat)
+    @test eigmin(C) ≈ eigmin(Cmat)
 end
 
 
@@ -140,33 +140,33 @@ function pdtest_mul(C::AbstractPDMat, Cmat::Matrix, verbose::Int)
     X = rand(eltype(C),dim(C), n)
 
     _pdt(verbose, "multiply")
-    @test_approx_eq C * X Cmat * X
+    @test C * X ≈ Cmat * X
 
     for i = 1:n
         xi = vec(copy(X[:,i]))
-        @test_approx_eq C * xi Cmat * xi
+        @test C * xi ≈ Cmat * xi
     end
 end
 
 
 function pdtest_mul(C::AbstractPDMat, Cmat::Matrix, X::Matrix, verbose::Int)
     _pdt(verbose, "multiply")
-    @test_approx_eq C * X Cmat * X
+    @test C * X ≈ Cmat * X
 
     for i = 1:size(X,2)
         xi = vec(copy(X[:,i]))
-        @test_approx_eq C * xi Cmat * xi
+        @test C * xi ≈ Cmat * xi
     end
 end
 
 
 function pdtest_rdiv(C::AbstractPDMat, Imat::Matrix, X::Matrix, verbose::Int)
     _pdt(verbose, "rdivide")
-    @test_approx_eq C \ X Imat * X
+    @test C \ X ≈ Imat * X
 
     for i = 1:size(X,2)
         xi = vec(copy(X[:,i]))
-        @test_approx_eq C \ xi Imat * xi
+        @test C \ xi ≈ Imat * xi
     end
 end
 
@@ -179,70 +179,70 @@ function pdtest_quad(C::AbstractPDMat, Cmat::Matrix, Imat::Matrix, X::Matrix, ve
     for i = 1:n
         xi = vec(X[:,i])
         r_quad[i] = dot(xi, Cmat * xi)
-        @test_approx_eq quad(C, xi) r_quad[i]
+        @test quad(C, xi) ≈ r_quad[i]
     end
-    @test_approx_eq quad(C, X) r_quad
+    @test quad(C, X) ≈ r_quad
 
     _pdt(verbose, "invquad")
     r_invquad = zeros(eltype(C),n)
     for i = 1:n
         xi = vec(X[:,i])
         r_invquad[i] = dot(xi, Imat * xi)
-        @test_approx_eq invquad(C, xi) r_invquad[i]
+        @test invquad(C, xi) ≈ r_invquad[i]
     end
-    @test_approx_eq invquad(C, X) r_invquad
+    @test invquad(C, X) ≈ r_invquad
 end
 
 
 function pdtest_triprod(C::AbstractPDMat, Cmat::Matrix, Imat::Matrix, X::Matrix, verbose::Int)
     Xt = copy(transpose(X))
 
     _pdt(verbose, "X_A_Xt")
-    @test_approx_eq X_A_Xt(C, Xt) Xt * Cmat * X
+    @test X_A_Xt(C, Xt) ≈ Xt * Cmat * X
 
     _pdt(verbose, "Xt_A_X")
-    @test_approx_eq Xt_A_X(C, X) Xt * Cmat * X
+    @test Xt_A_X(C, X) ≈ Xt * Cmat * X
 
     _pdt(verbose, "X_invA_Xt")
-    @test_approx_eq X_invA_Xt(C, Xt) Xt * Imat * X
+    @test X_invA_Xt(C, Xt) ≈ Xt * Imat * X
 
     _pdt(verbose, "Xt_invA_X")
-    @test_approx_eq Xt_invA_X(C, X) Xt * Imat * X
+    @test Xt_invA_X(C, X) ≈ Xt * Imat * X
 end
 
 
 function pdtest_whiten(C::AbstractPDMat, Cmat::Matrix, verbose::Int)
     Y = chol_lower(Cmat)
     Q = qr(convert(Array{eltype(C),2},randn(size(Cmat))))[1]
     Y = Y * Q'                    # generate a matrix Y such that Y * Y' = C
-    @test_approx_eq Y * Y' Cmat
+    @test Y * Y' ≈ Cmat
     d = dim(C)
 
     _pdt(verbose, "whiten")
     Z = whiten(C, Y)
-    @test_approx_eq Z * Z' eye(eltype(C),d)
+    @test Z * Z' ≈ eye(eltype(C),d)
     for i = 1:d
-        @test_approx_eq whiten(C, Y[:,i]) Z[:,i]
+        @test whiten(C, Y[:,i]) ≈ Z[:,i]
     end
 
     _pdt(verbose, "whiten!")
     Z2 = copy(Y)
     whiten!(C, Z2)
-    @test_approx_eq Z Z2
+    @test Z ≈ Z2
 
     _pdt(verbose, "unwhiten")
     X = unwhiten(C, Z)
-    @test_approx_eq X * X' Cmat
+    @test X * X' ≈ Cmat
     for i = 1:d
-        @test_approx_eq unwhiten(C, Z[:,i]) X[:,i]
+        @test unwhiten(C, Z[:,i]) ≈ X[:,i]
     end
 
     _pdt(verbose, "unwhiten!")
     X2 = copy(Z)
     unwhiten!(C, X2)
-    @test_approx_eq X X2
+    @test X ≈ X2
 
     _pdt(verbose, "whiten-unwhiten")
-    @test_approx_eq unwhiten(C, whiten(C, eye(eltype(C),d))) eye(eltype(C),d)
-    @test_approx_eq whiten(C, unwhiten(C, eye(eltype(C),d))) eye(eltype(C),d)
+    @test unwhiten(C, whiten(C, eye(eltype(C),d))) ≈ eye(eltype(C),d)
+    @test whiten(C, unwhiten(C, eye(eltype(C),d))) ≈ eye(eltype(C),d)
 end
diff --git a/test/addition.jl b/test/addition.jl
@@ -22,17 +22,17 @@ for T in [Float64,Float32]
   for p1 in pmats, p2 in pmats
 	  pr = p1 + p2
 	  @test size(pr) == size(p1)
-	  @test_approx_eq full(pr) full(p1) + full(p2)
+	  @test full(pr) ≈ full(p1) + full(p2)
 
 	  pr = pdadd(p1, p2, convert(T,1.5))
 	  @test size(pr) == size(p1)
-	  @test_approx_eq full(pr) full(p1) + full(p2) * convert(T,1.5)
+	  @test full(pr) ≈ full(p1) + full(p2) * convert(T,1.5)
   end
 
   for p1 in pmats
         pr = p1 + pm4
         @test size(pr) == size(p1)
-        @test_approx_eq full(pr) full(p1) + pm4
+        @test full(pr) ≈ full(p1) + pm4
   end
 end
 

diff --git a/test/pdmtypes.jl b/test/pdmtypes.jl
@@ -4,25 +4,23 @@ using Base.Test
 
 call_test_pdmat(p::AbstractPDMat,m::Matrix) = test_pdmat(p,m,cmat_eq=true,verbose=1)
 
-for T in [Float64,Float32]
-  #test that all external constructors are accessible
-  m = eye(T,2) ; @test PDMat(m,cholfact(m)).mat == PDMat(Symmetric(m)).mat == PDMat(m).mat == PDMat(cholfact(m)).mat
-  d = ones(T,2) ; @test PDiagMat(d,d).inv_diag == PDiagMat(d).inv_diag
-  x = one(T) ; @test ScalMat(2,x,x).inv_value == ScalMat(2,x).inv_value
-  #for Julia v0.3, do not test sparse matrices with Float32 (see issue #14076)
-  (T == Float64 || VERSION >= v"0.4.2") && (s = speye(T,2,2) ; @test PDSparseMat(s,cholfact(s)).mat == PDSparseMat(s).mat == PDSparseMat(cholfact(s)).mat)
+for T in [Float64, Float32]
+    #test that all external constructors are accessible
+    m = eye(T,2)
+    @test PDMat(m, cholfact(m)).mat == PDMat(Symmetric(m)).mat == PDMat(m).mat == PDMat(cholfact(m)).mat
+    d = ones(T,2)
+    @test PDiagMat(d,d).inv_diag == PDiagMat(d).inv_diag
+    x = one(T)
+    @test ScalMat(2,x,x).inv_value == ScalMat(2,x).inv_value
 
+    #test the functionality
+    M = convert(Array{T,2}, [4. -2. -1.; -2. 5. -1.; -1. -1. 6.])
+    V = convert(Array{T,1}, [1.5, 2.5, 2.0])
+    X = convert(T,2.0)
 
-  #test the functionality
-  M = convert(Array{T,2},[4. -2. -1.; -2. 5. -1.; -1. -1. 6.])
-  V = convert(Array{T,1},[1.5, 2.5, 2.0])
-  X = convert(T,2.0)
-
-  call_test_pdmat(PDMat(M),M) #tests of PDMat
-  call_test_pdmat(PDiagMat(V),diagm(V)) #tests of PDiagMat
-  call_test_pdmat(ScalMat(3,x),x*eye(T,3)) #tests of ScalMat
-  #for Julia v0.3, do not test sparse matrices with Float32 (see issue #14076)
-  (T == Float64 || VERSION >= v"0.4.2") && call_test_pdmat(PDSparseMat(sparse(M)),M)
+    call_test_pdmat(PDMat(M), M) #tests of PDMat
+    call_test_pdmat(PDiagMat(V), diagm(V)) #tests of PDiagMat
+    call_test_pdmat(ScalMat(3,x), x*eye(T,3)) #tests of ScalMat
 end
 
 m = eye(Float32,2)
@@ -31,7 +29,3 @@ m = ones(Float32,2)
 @test convert(PDiagMat{Float64}, PDiagMat(m)).diag == PDiagMat(convert(Array{Float64}, m)).diag
 x = one(Float32); d = 4
 @test convert(ScalMat{Float64}, ScalMat(d, x)).value == ScalMat(d, convert(Float64, x)).value
-if VERSION >= v"0.4.2"
-    s = speye(Float32, 2, 2)
-    @test convert(PDSparseMat{Float64}, PDSparseMat(s)).mat == PDSparseMat(convert(SparseMatrixCSC{Float64}, s)).mat
-end