From 1018a55c7fca9e756395b98102f6424cc5fa932d Mon Sep 17 00:00:00 2001 From: Sacha Verweij Date: Fri, 29 Jul 2016 17:37:23 -0700 Subject: [PATCH] Deprecate methods that convert from Diagonal and Bidiagonal to <:AbstractTriangular. Remove tests of those convert methods. --- base/deprecated.jl | 58 +++++++++++++++++++++++++++++++++++++++++ base/linalg/diagonal.jl | 2 -- base/linalg/special.jl | 20 ++------------ test/linalg/special.jl | 18 +++++-------- 4 files changed, 67 insertions(+), 31 deletions(-) diff --git a/base/deprecated.jl b/base/deprecated.jl index 0bac394c53cef..60d06e6e44e6d 100644 --- 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 index aff8735e4c7ca..0b385e1480bb3 100644 --- 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 index f70d67130807b..69b13517045f5 100644 --- 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 index 05105acd149a8..6194dcdbbafbb 100644 --- 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