A few mini tests for linalg (#20613)

* Tests for missing broadcast methods

* Tests for a few more ConjArray features

* More tests for LU too

* Broadcast and rowvec tests for bidiag

* Add throw for RowVectors and choleskys and tests

* Add type stability tests for tridiag

* copy! and logabsdet tests for triangular

Author: kshyatt

test/linalg/bidiag.jl

@@ -134,6 +134,12 @@ srand(1)
             @test_throws DimensionMismatch T \ ones(elty,n+1,2)
             @test_throws DimensionMismatch T.' \ ones(elty,n+1,2)
             @test_throws DimensionMismatch T' \ ones(elty,n+1,2)
+
+            @test_throws DimensionMismatch T \ RowVector(ones(elty,n+1))
+            @test_throws DimensionMismatch T.' \ RowVector(ones(elty,n+1))
+            @test_throws DimensionMismatch T' \ RowVector(ones(elty,n+1))
+            @test_throws DimensionMismatch Base.LinAlg.At_ldiv_B(T, RowVector(ones(elty,n+1)))
+            @test_throws DimensionMismatch Base.LinAlg.Ac_ldiv_B(T, RowVector(ones(elty,n+1)))
             let bb = b, cc = c
                 for atype in ("Array", "SubArray")
                     if atype == "Array"
@@ -168,6 +174,14 @@ srand(1)
                 @test isa(round.(Int, T), Bidiagonal)
                 @test ceil.(Int,T) == Bidiagonal(ceil.(Int,T.dv), ceil.(Int,T.ev), T.isupper)
                 @test isa(ceil.(Int,T), Bidiagonal)
+                @test floor.(T) == Bidiagonal(floor.(T.dv), floor.(T.ev), T.isupper)
+                @test isa(floor.(T), Bidiagonal)
+                @test trunc.(T) == Bidiagonal(trunc.(T.dv), trunc.(T.ev), T.isupper)
+                @test isa(trunc.(T), Bidiagonal)
+                @test round.(T) == Bidiagonal(round.(T.dv), round.(T.ev), T.isupper)
+                @test isa(round.(T), Bidiagonal)
+                @test ceil.(T) == Bidiagonal(ceil.(T.dv), ceil.(T.ev), T.isupper)
+                @test isa(ceil.(T), Bidiagonal)
             end
         end
 

test/linalg/cholesky.jl

@@ -169,6 +169,7 @@ debug && println("\ntype of a: ", eltya, " type of b: ", eltyb, "\n")
                     @test norm(apd * (lapd\b) - b)/norm(b) <= ε*κ*n
                     @test norm(apd * (lapd\b[1:n]) - b[1:n])/norm(b[1:n]) <= ε*κ*n
                 end
+                @test_throws DimensionMismatch lapd\RowVector(ones(n))
 
 debug && println("pivoted Cholesky decomposition")
                 if eltya != BigFloat && eltyb != BigFloat # Note! Need to implement pivoted Cholesky decomposition in julia
@@ -179,6 +180,8 @@ debug && println("pivoted Cholesky decomposition")
                     lpapd = cholfact(apd, :L, Val{true})
                     @test norm(apd * (lpapd\b) - b)/norm(b) <= ε*κ*n # Ad hoc, revisit
                     @test norm(apd * (lpapd\b[1:n]) - b[1:n])/norm(b[1:n]) <= ε*κ*n
+
+                    @test_throws BoundsError lpapd\RowVector(ones(n))
                 end
             end
         end

test/linalg/conjarray.jl

@@ -2,12 +2,17 @@
 
 @testset "Core" begin
     m = [1+im 2; 2 4-im]
-    cm = ConjArray(m)
+    cm = ConjMatrix(m)
     @test cm[1,1] == 1-im
+    @test cm[1] == 1-im
     @test trace(cm*m) == 27
+    @test cm' == m
+
+    cm[:,2] = [3; 3-im] #setindex! with a vector
+    @test conj(cm) == [1+im 3; 2 3+im]
 
     v = [[1+im], [1-im]]
-    cv = ConjArray(v)
+    cv = ConjVector(v)
     @test cv[1] == [1-im]
 end
 

test/linalg/lu.jl

@@ -64,6 +64,10 @@ debug && println("(Automatic) Square LU decomposition. eltya: $eltya, eltyb: $el
         @test l*u ≈ a[p,:]
         @test (l*u)[invperm(p),:] ≈ a
         @test a * inv(lua) ≈ eye(n)
+
+        lstring = sprint(show,l)
+        ustring = sprint(show,u)
+        @test sprint(show,lua) == "$(typeof(lua)) with factors L and U:\n$lstring\n$ustring"
         let Bs = b, Cs = c
             for atype in ("Array", "SubArray")
                 if atype == "Array"
@@ -102,6 +106,7 @@ debug && println("Tridiagonal LU")
         @test_throws DimensionMismatch lud\f
         @test_throws DimensionMismatch lud.'\f
         @test_throws DimensionMismatch lud'\f
+        @test_throws DimensionMismatch Base.LinAlg.At_ldiv_B!(lud, f)
         let Bs = b
             for atype in ("Array", "SubArray")
                 if atype == "Array"
@@ -113,6 +118,9 @@ debug && println("Tridiagonal LU")
                 @test norm(d*(lud\b) - b, 1) < ε*κd*n*2 # Two because the right hand side has two columns
                 if eltya <: Real
                     @test norm((lud.'\b) - Array(d.')\b, 1) < ε*κd*n*2 # Two because the right hand side has two columns
+                    if eltya != Int && eltyb != Int
+                        @test norm(Base.LinAlg.At_ldiv_B!(lud, copy(b)) - Array(d.')\b, 1) < ε*κd*n*2
+                    end
                 end
                 if eltya <: Complex
                     @test norm((lud'\b) - Array(d')\b, 1) < ε*κd*n*2 # Two because the right hand side has two columns

test/linalg/triangular.jl

@@ -45,6 +45,11 @@ for elty1 in (Float32, Float64, BigFloat, Complex64, Complex128, Complex{BigFloa
         @test isa(similar(A1, (3,2)), Matrix{elty1})
         @test isa(similar(A1, Int, (3,2)), Matrix{Int})
 
+        #copy!
+        simA1 = similar(A1)
+        copy!(simA1, A1)
+        @test simA1 == A1
+
         # getindex
         ## Linear indexing
         for i = 1:length(A1)
@@ -226,6 +231,10 @@ for elty1 in (Float32, Float64, BigFloat, Complex64, Complex128, Complex{BigFloa
         # Determinant
         @test det(A1) ≈ det(lufact(full(A1))) atol=sqrt(eps(real(float(one(elty1)))))*n*n
         @test logdet(A1) ≈ logdet(lufact(full(A1))) atol=sqrt(eps(real(float(one(elty1)))))*n*n
+        lada, ladb = logabsdet(A1)
+        flada, fladb = logabsdet(lufact(full(A1)))
+        @test lada ≈ flada atol=sqrt(eps(real(float(one(elty1)))))*n*n
+        @test ladb ≈ fladb atol=sqrt(eps(real(float(one(elty1)))))*n*n
 
         # Matrix square root
         @test sqrtm(A1) |> t -> t*t ≈ A1

test/linalg/tridiag.jl

@@ -50,9 +50,29 @@ for elty in (Float32, Float64, Complex64, Complex128, Int)
     @test ctranspose(T) == Tridiagonal(conj(du), conj(d), conj(dl))
 
     @test abs.(T) == Tridiagonal(abs.(dl),abs.(d),abs.(du))
+    if elty <: Real
+        @test round.(T) == Tridiagonal(round.(dl),round.(d),round.(du))
+        @test isa(round.(T), Tridiagonal)
+        @test trunc.(T) == Tridiagonal(trunc.(dl),trunc.(d),trunc.(du))
+        @test isa(trunc.(T), Tridiagonal)
+        @test floor.(T) == Tridiagonal(floor.(dl),floor.(d),floor.(du))
+        @test isa(floor.(T), Tridiagonal)
+        @test ceil.(T) == Tridiagonal(ceil.(dl),ceil.(d),ceil.(du))
+        @test isa(ceil.(T), Tridiagonal)
+    end
     @test real(T) == Tridiagonal(real(dl),real(d),real(du))
     @test imag(T) == Tridiagonal(imag(dl),imag(d),imag(du))
     @test abs.(Ts) == SymTridiagonal(abs.(d),abs.(dl))
+    if elty <: Real
+        @test round.(Ts) == SymTridiagonal(round.(d),round.(dl))
+        @test isa(round.(Ts), SymTridiagonal)
+        @test trunc.(Ts) == SymTridiagonal(trunc.(d),trunc.(dl))
+        @test isa(trunc.(Ts), SymTridiagonal)
+        @test floor.(Ts) == SymTridiagonal(floor.(d),floor.(dl))
+        @test isa(floor.(Ts), SymTridiagonal)
+        @test ceil.(Ts) == SymTridiagonal(ceil.(d),ceil.(dl))
+        @test isa(ceil.(Ts), SymTridiagonal)
+    end
     @test real(Ts) == SymTridiagonal(real(d),real(dl))
     @test imag(Ts) == SymTridiagonal(imag(d),imag(dl))