Deprecate methods that convert from Diagonal and Bidiagonal to <:Abst…

…ractTriangular. Remove tests of those convert methods.
JuliaLang · Aug 23, 2016 · 1018a55 · 1018a55
1 parent 2390055
commit 1018a55
Show file tree

Hide file tree

Showing 4 changed files with 67 additions and 31 deletions.
diff --git a/base/deprecated.jl b/base/deprecated.jl
@@ -795,4 +795,62 @@ end
 @deprecate (-)(J::UniformScaling, x::Number) J.λ - x
 @deprecate (-)(x::Number, J::UniformScaling) x - J.λ
 
+# Deprecate methods that convert Diagonal and Bidiagonal to <:AbstractTriangular.
+function convert(::Type{UpperTriangular}, A::Diagonal)
+    depwarn(string("`convert(::Type{UpperTriangular}, A::Diagonal)` and other methods ",
+        "that convert `Diagonal`/`Bidiagonal` to `<:AbstractTriangular` are deprecated. ",
+        "Consider calling the `UpperTriangular` constructor directly ",
+        "(`UpperTriangular(A)`) instead."), :convert)
+    UpperTriangular(A)
+end
+function convert(::Type{LowerTriangular}, A::Diagonal)
+    depwarn(string("`convert(::Type{LowerTriangular}, A::Diagonal)` and other methods ",
+        "that convert `Diagonal`/`Bidiagonal` to `<:AbstractTriangular` are deprecated. ",
+        "Consider calling the `LowerTriangular` constructor directly ",
+        "(`LowerTriangular(A)`) instead."), :convert)
+    LowerTriangular(A)
+end
+function convert(::Type{Base.LinAlg.UnitUpperTriangular}, A::Diagonal)
+    depwarn(string("`convert(::Type{UnitUpperTriangular}, A::Diagonal)` and other methods ",
+        "that convert `Diagonal`/`Bidiagonal` to `<:AbstractTriangular` are deprecated. ",
+        "Consider calling the `UnitUpperTriangular` constructor directly ",
+        "(`Base.LinAlg.UnitUpperTriangular(A)`) instead."), :convert)
+    if !all(A.diag .== one(eltype(A)))
+        throw(ArgumentError("matrix cannot be represented as UnitUpperTriangular"))
+    end
+    Base.LinAlg.UnitUpperTriangular(full(A))
+end
+function convert(::Type{Base.LinAlg.UnitLowerTriangular}, A::Diagonal)
+    depwarn(string("`convert(::Type{UnitLowerTriangular}, A::Diagonal)` and other methods ",
+        "that convert `Diagonal`/`Bidiagonal` to `<:AbstractTriangular` are deprecated. ",
+        "Consider calling the `UnitLowerTriangular` constructor directly ",
+        "(`Base.LinAlg.UnitLowerTriangular(A)`) instead."), :convert)
+    if !all(A.diag .== one(eltype(A)))
+        throw(ArgumentError("matrix cannot be represented as UnitLowerTriangular"))
+    end
+    Base.LinAlg.UnitLowerTriangular(full(A))
+end
+function convert(::Type{LowerTriangular}, A::Bidiagonal)
+    depwarn(string("`convert(::Type{LowerTriangular}, A::Bidiagonal)` and other methods ",
+        "that convert `Diagonal`/`Bidiagonal` to `<:AbstractTriangular` are deprecated. ",
+        "Consider calling the `LowerTriangular` constructor directly (`LowerTriangular(A)`) ",
+        "instead."), :convert)
+    if !A.isupper
+        LowerTriangular(full(A))
+    else
+        throw(ArgumentError("Bidiagonal matrix must have lower off diagonal to be converted to LowerTriangular"))
+    end
+end
+function convert(::Type{UpperTriangular}, A::Bidiagonal)
+    depwarn(string("`convert(::Type{UpperTriangular}, A::Bidiagonal)` and other methods ",
+        "that convert `Diagoinal`/`Bidiagonal` to `<:AbstractTriangular` are deprecated. ",
+        "Consider calling the `UpperTriangular` constructor directly (`UpperTriangular(A)`) ",
+        "instead."), :convert)
+    if A.isupper
+        UpperTriangular(full(A))
+    else
+        throw(ArgumentError("Bidiagonal matrix must have upper off diagonal to be converted to UpperTriangular"))
+    end
+end
+
 # End deprecations scheduled for 0.6
diff --git a/base/linalg/diagonal.jl b/base/linalg/diagonal.jl
@@ -21,8 +21,6 @@ Diagonal(V::AbstractVector) = Diagonal(collect(V))
 convert{T}(::Type{Diagonal{T}}, D::Diagonal{T}) = D
 convert{T}(::Type{Diagonal{T}}, D::Diagonal) = Diagonal{T}(convert(Vector{T}, D.diag))
 convert{T}(::Type{AbstractMatrix{T}}, D::Diagonal) = convert(Diagonal{T}, D)
-convert{T}(::Type{UpperTriangular}, A::Diagonal{T}) = UpperTriangular(A)
-convert{T}(::Type{LowerTriangular}, A::Diagonal{T}) = LowerTriangular(A)
 convert(::Type{Matrix}, D::Diagonal) = diagm(D.diag)
 convert(::Type{Array}, D::Diagonal) = convert(Matrix, D)
 full(D::Diagonal) = convert(Array, D)

diff --git a/base/linalg/special.jl b/base/linalg/special.jl
@@ -6,22 +6,6 @@
 convert{T}(::Type{Bidiagonal}, A::Diagonal{T})=Bidiagonal(A.diag, zeros(T, size(A.diag,1)-1), true)
 convert{T}(::Type{SymTridiagonal}, A::Diagonal{T})=SymTridiagonal(A.diag, zeros(T, size(A.diag,1)-1))
 convert{T}(::Type{Tridiagonal}, A::Diagonal{T})=Tridiagonal(zeros(T, size(A.diag,1)-1), A.diag, zeros(T, size(A.diag,1)-1))
-convert(::Type{LowerTriangular}, A::Bidiagonal) = !A.isupper ? LowerTriangular(full(A)) : throw(ArgumentError("Bidiagonal matrix must have lower off diagonal to be converted to LowerTriangular"))
-convert(::Type{UpperTriangular}, A::Bidiagonal) = A.isupper ? UpperTriangular(full(A)) : throw(ArgumentError("Bidiagonal matrix must have upper off diagonal to be converted to UpperTriangular"))
-
-function convert(::Type{UnitUpperTriangular}, A::Diagonal)
-    if !all(A.diag .== one(eltype(A)))
-        throw(ArgumentError("matrix cannot be represented as UnitUpperTriangular"))
-    end
-    UnitUpperTriangular(full(A))
-end
-
-function convert(::Type{UnitLowerTriangular}, A::Diagonal)
-    if !all(A.diag .== one(eltype(A)))
-        throw(ArgumentError("matrix cannot be represented as UnitLowerTriangular"))
-    end
-    UnitLowerTriangular(full(A))
-end
 
 function convert(::Type{Diagonal}, A::Union{Bidiagonal, SymTridiagonal})
     if !all(A.ev .== 0)
@@ -147,8 +131,8 @@ for op in (:+, :-)
                                           (:LowerTriangular,:LowerTriangular),
                                           (:UnitLowerTriangular,:LowerTriangular))
             @eval begin
-                ($op)(A::($matrixtype1), B::($matrixtype2)) = ($op)(convert(($matrixtype3), A), B)
-                ($op)(A::($matrixtype2), B::($matrixtype1)) = ($op)(A, convert(($matrixtype3), B))
+                ($op)(A::($matrixtype1), B::($matrixtype2)) = ($op)(($matrixtype3)(A), B)
+                ($op)(A::($matrixtype2), B::($matrixtype1)) = ($op)(A, ($matrixtype3)(B))
             end
         end
     end

diff --git a/test/linalg/special.jl b/test/linalg/special.jl
@@ -9,30 +9,30 @@ srand(1)
 debug && println("Test interconversion between special matrix types")
 let a=[1.0:n;]
    A=Diagonal(a)
-   for newtype in [Diagonal, Bidiagonal, SymTridiagonal, Tridiagonal, LowerTriangular, UpperTriangular, Matrix]
+   for newtype in [Diagonal, Bidiagonal, SymTridiagonal, Tridiagonal, Matrix]
        debug && println("newtype is $(newtype)")
        @test full(convert(newtype, A)) == full(A)
    end
-   for newtype in [Base.LinAlg.UnitUpperTriangular, Base.LinAlg.UnitLowerTriangular]
-       @test_throws ArgumentError convert(newtype, A)
-       @test full(convert(newtype, Diagonal(ones(n)))) == eye(n)
-   end
 
    for isupper in (true, false)
        debug && println("isupper is $(isupper)")
        A=Bidiagonal(a, [1.0:n-1;], isupper)
-       for newtype in [Bidiagonal, Tridiagonal, isupper ? UpperTriangular : LowerTriangular, Matrix]
+       for newtype in [Bidiagonal, Tridiagonal, Matrix]
            debug && println("newtype is $(newtype)")
            @test full(convert(newtype, A)) == full(A)
            @test full(newtype(A)) == full(A)
        end
        @test_throws ArgumentError convert(SymTridiagonal, A)
+       tritype = isupper ? UpperTriangular : LowerTriangular
+       @test full(tritype(A)) == full(A)
+
        A=Bidiagonal(a, zeros(n-1), isupper) #morally Diagonal
-       for newtype in [Diagonal, Bidiagonal, SymTridiagonal, Tridiagonal, isupper ? UpperTriangular : LowerTriangular, Matrix]
+       for newtype in [Diagonal, Bidiagonal, SymTridiagonal, Tridiagonal, Matrix]
            debug && println("newtype is $(newtype)")
            @test full(convert(newtype, A)) == full(A)
            @test full(newtype(A)) == full(A)
        end
+       @test full(tritype(A)) == full(A)
    end
 
    A = SymTridiagonal(a, [1.0:n-1;])
@@ -78,10 +78,6 @@ let a=[1.0:n;]
    for newtype in [Diagonal, Bidiagonal, Tridiagonal, SymTridiagonal]
        @test_throws ArgumentError convert(newtype,A)
    end
-   A = Diagonal(a)
-   for newtype in [UpperTriangular, LowerTriangular]
-       @test full(convert(newtype,A)) == full(A)
-   end
 end
 
 # Binary ops among special types