Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Clarify which are is modified in mul/div. #24698

Closed
wants to merge 2 commits into from
Closed

Clarify which are is modified in mul/div. #24698

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
f0e48ff
Clarify which are is modified in mul/div.
simonbyrne Nov 22, 2017
01ff20b
fix ambiguity warnings
simonbyrne Nov 22, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
107 changes: 107 additions & 0 deletions base/deprecated.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2211,6 +2211,113 @@ end
finalizer(f::Ptr{Void}, o::Ptr{Void}) = invoke(finalizer, Tuple{Ptr{Void}, Any}, f, o)
finalizer(f::Ptr{Void}, o::Function) = invoke(finalizer, Tuple{Ptr{Void}, Any}, f, o)

# A_mul_B!
import .LinAlg: A_mul_B!, A_mul_Bt!, A_mul_Bc!, At_mul_B!, Ac_mul_B!,
A_ldiv_B!, At_ldiv_B!, Ac_ldiv_B!, A_rdiv_B!, A_rdiv_Bt!, A_rdiv_Bc!

@deprecate A_ldiv_B!(A, B) A_ldiv_B!2(A, B)
@deprecate At_ldiv_B!(A, B) At_ldiv_B!2(A, B)
@deprecate Ac_ldiv_B!(A, B) Ac_ldiv_B!2(A, B)

@deprecate A_rdiv_B!(A, B) A_rdiv_B!1(A, B)
@deprecate A_rdiv_Bt!(A, B) A_rdiv_Bt!1(A, B)
@deprecate A_rdiv_Bc!(A, B) A_rdiv_Bc!1(A, B)

# linalg/diagonal.jl

function A_mul_B!(A::Diagonal,B::Diagonal)
depwarn("`A_mul_B!(A::Diagonal,B::Diagonal)` should be replaced with `A_mul_B!1(A, B)` or `A_mul_B!2(A, B)`.", :A_mul_B!)
throw(MethodError(A_mul_B!, Tuple{Diagonal,Diagonal}))
end

@deprecate A_mul_B!(A::Diagonal,B::AbstractMatrix) A_mul_B!2(A,B)
@deprecate At_mul_B!(A::Diagonal,B::AbstractMatrix) At_mul_B!2(A,B)
@deprecate Ac_mul_B!(A::Diagonal,B::AbstractMatrix) Ac_mul_B!2(A,B)
@deprecate A_mul_B!(A::AbstractMatrix,B::Diagonal) A_mul_B!1(A,B)
@deprecate A_mul_Bt!(A::AbstractMatrix,B::Diagonal) A_mul_Bt!1(A,B)
@deprecate A_mul_Bc!(A::AbstractMatrix,B::Diagonal) A_mul_Bc!1(A,B)

# linalg/givens.jl
@deprecate A_mul_B!(G::LinAlg.Givens, A::AbstractVecOrMat) A_mul_B!2(G, A)
@deprecate A_mul_Bc!(A::AbstractMatrix, G::LinAlg.Givens) A_mul_Bc!1(A, G)
@deprecate A_mul_B!(G::LinAlg.Givens, R::LinAlg.Rotation) A_mul_B!2(G, R)
@deprecate A_mul_B!(R::LinAlg.Rotation, A::AbstractMatrix) A_mul_B!2(R, A)
@deprecate A_mul_Bc!(A::AbstractMatrix, R::LinAlg.Rotation) A_mul_Bc!1(A, R)

# linalg/hessenberg.jl
@deprecate A_mul_B!(Q::LinAlg.HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:LinAlg.BlasFloat} A_mul_B!2(Q, X)
@deprecate A_mul_B!(X::StridedMatrix{T}, Q::LinAlg.HessenbergQ{T}) where {T<:LinAlg.BlasFloat} A_mul_B!1(X, Q)
@deprecate Ac_mul_B!(Q::LinAlg.HessenbergQ{T}, X::StridedVecOrMat{T}) where {T<:LinAlg.BlasFloat} Ac_mul_B!2(Q, X)
@deprecate A_mul_Bc!(X::StridedMatrix{T}, Q::LinAlg.HessenbergQ{T}) where {T<:LinAlg.BlasFloat} A_mul_Bc!1(X, Q)

# linalg/lq.jl
@deprecate A_mul_B!(A::LQ{T}, B::StridedVecOrMat{T}) where {T<:LinAlg.BlasFloat} A_mul_B!2(A, B)
@deprecate A_mul_B!(A::LQ{T}, B::QR{T}) where {T<:LinAlg.BlasFloat} A*B
@deprecate A_mul_B!(A::QR{T}, B::LQ{T}) where {T<:LinAlg.BlasFloat} A*B

@deprecate A_mul_B!(A::LinAlg.LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:LinAlg.BlasFloat} A_mul_B!2(A, B)
@deprecate Ac_mul_B!(A::LinAlg.LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:LinAlg.BlasReal} Ac_mul_B!2(A, B)
@deprecate Ac_mul_B!(A::LinAlg.LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:LinAlg.BlasComplex} Ac_mul_B!2(A, B)

@deprecate A_mul_B!(A::StridedMatrix{T}, B::LinAlg.LQPackedQ{T}) where {T<:LinAlg.BlasFloat} A_mul_B!1(A, B)
@deprecate A_mul_Bc!(A::StridedMatrix{T}, B::LinAlg.LQPackedQ{T}) where {T<:LinAlg.BlasReal} A_mul_Bc!1(A, B)
@deprecate A_mul_Bc!(A::StridedMatrix{T}, B::LinAlg.LQPackedQ{T}) where {T<:LinAlg.BlasComplex} A_mul_Bc!1(A, B)

@deprecate A_ldiv_B!(A::LQ{T}, B::StridedVecOrMat{T}) where {T} A_ldiv_B!2(A, B)

# linalg/qr.jl
@deprecate A_mul_B!(A::LinAlg.QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:LinAlg.BlasFloat, S<:StridedMatrix} A_mul_B!2(A, B)
@deprecate A_mul_B!(A::LinAlg.QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:LinAlg.BlasFloat, S<:StridedMatrix} A_mul_B!2(A, B)
@deprecate A_mul_B!(A::LinAlg.QRPackedQ, B::AbstractVecOrMat) A_mul_B!2(A, B)

@deprecate Ac_mul_B!(A::LinAlg.QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:LinAlg.BlasReal,S<:StridedMatrix} Ac_mul_B!2(A, B)
@deprecate Ac_mul_B!(A::LinAlg.QRCompactWYQ{T,S}, B::StridedVecOrMat{T}) where {T<:LinAlg.BlasComplex,S<:StridedMatrix} Ac_mul_B!2(A, B)
@deprecate Ac_mul_B!(A::LinAlg.QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:LinAlg.BlasReal,S<:StridedMatrix} Ac_mul_B!2(A, B)
@deprecate Ac_mul_B!(A::LinAlg.QRPackedQ{T,S}, B::StridedVecOrMat{T}) where {T<:LinAlg.BlasComplex,S<:StridedMatrix} Ac_mul_B!2(A, B)
@deprecate Ac_mul_B!(A::LinAlg.QRPackedQ, B::AbstractVecOrMat) Ac_mul_B!2(A, B)

@deprecate A_mul_B!(A::StridedVecOrMat{T}, B::LinAlg.QRCompactWYQ{T,S}) where {T<:LinAlg.BlasFloat,S<:StridedMatrix} A_mul_B!1(A,B)
@deprecate A_mul_B!(A::StridedVecOrMat{T}, B::LinAlg.QRPackedQ{T,S}) where {T<:LinAlg.BlasFloat,S<:StridedMatrix} A_mul_B!1(A,B)
@deprecate A_mul_B!(A::StridedMatrix,Q::LinAlg.QRPackedQ) A_mul_B!1(A,B)

@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::LinAlg.QRCompactWYQ{T}) where {T<:LinAlg.BlasReal} A_mul_Bc!1(A, B)
@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::LinAlg.QRCompactWYQ{T}) where {T<:LinAlg.BlasComplex} A_mul_Bc!1(A, B)
@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::LinAlg.QRPackedQ{T}) where {T<:LinAlg.BlasReal} A_mul_Bc!1(A, B)
@deprecate A_mul_Bc!(A::StridedVecOrMat{T}, B::LinAlg.QRPackedQ{T}) where {T<:LinAlg.BlasComplex} A_mul_Bc!1(A, B)
@deprecate A_mul_Bc!(A::StridedMatrix,Q::LinAlg.QRPackedQ) A_mul_Bc!1(A, B)

@deprecate A_ldiv_B!(A::QRPivoted{T}, B::StridedMatrix{T}, rcond::Real) where {T<:LinAlg.BlasFloat} A_ldiv_B!(A,B, rcond)
A_mul_B!(A::Base.LinAlg.QRPackedQ, D::Diagonal) = throw(MethodError(A_mul_B!, Tuple{Diagonal,Diagonal}))

# linalg/special.jl
@deprecate A_mul_Bc!(A::LinAlg.AbstractTriangular, B::Union{LinAlg.QRCompactWYQ,LinAlg.QRPackedQ}) A_mul_Bc!1(A, B)

# linalg/triangular.jl
@deprecate A_mul_B!(A::Tridiagonal, B::LinAlg.AbstractTriangular) A*B

@deprecate A_mul_B!(A::LinAlg.AbstractTriangular, b::StridedVector) A_mul_B!2(A,b)
@deprecate A_mul_B!(A::LinAlg.AbstractTriangular, B::StridedMatrix) A_mul_B!2(A,B)
@deprecate At_mul_B!(A::LinAlg.AbstractTriangular, b::StridedVector) At_mul_B!2(A,b)
@deprecate At_mul_B!(A::LinAlg.AbstractTriangular, B::StridedMatrix) At_mul_B!2(A,B)
@deprecate Ac_mul_B!(A::LinAlg.AbstractTriangular, b::StridedVector) Ac_mul_B!2(A,b)
@deprecate Ac_mul_B!(A::LinAlg.AbstractTriangular, B::StridedMatrix) Ac_mul_B!2(A,B)

@deprecate A_mul_B!(A::StridedMatrix, B::LinAlg.AbstractTriangular) A_mul_B!1(A,B)
@deprecate A_mul_Bt!(A::StridedMatrix, B::LinAlg.AbstractTriangular) A_mul_Bt!1(A,B)
@deprecate A_mul_Bc!(A::StridedMatrix, B::LinAlg.AbstractTriangular) A_mul_Bc!1(A,B)

@deprecate At_mul_B!(A::LinAlg.AbstractTriangular, B::LinAlg.AbstractTriangular) At_mul_B!2(A,B)
@deprecate Ac_mul_B!(A::LinAlg.AbstractTriangular, B::LinAlg.AbstractTriangular) Ac_mul_B!2(A,B)
@deprecate A_mul_Bt!(A::LinAlg.AbstractTriangular, B::LinAlg.AbstractTriangular) A_mul_Bt!1(A,B)
@deprecate A_mul_Bc!(A::LinAlg.AbstractTriangular, B::LinAlg.AbstractTriangular) A_mul_Bc!1(A,B)

# sparse/spqr.jl
@deprecate A_mul_B!(Q::SparseArrays.SPQR.QRSparseQ, A::StridedVecOrMat) A_mul_B!2(Q, A)
@deprecate A_mul_B!(A::StridedMatrix, Q::SparseArrays.SPQR.QRSparseQ) A_mul_B!1(A, Q)
@deprecate Ac_mul_B!(Q::SparseArrays.SPQR.QRSparseQ, A::StridedVecOrMat) Ac_mul_B!2(Q, A)
@deprecate A_mul_Bc!(A::StridedMatrix, Q::SparseArrays.SPQR.QRSparseQ) A_mul_Bc!1(A, Q)


# END 0.7 deprecations

# BEGIN 1.0 deprecations
Expand Down
18 changes: 9 additions & 9 deletions base/linalg/bidiag.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -494,10 +494,10 @@ for func in (:*, :Ac_mul_B, :A_mul_Bc, :/, :A_rdiv_Bc)
end

#Linear solvers
A_ldiv_B!(A::Union{Bidiagonal, AbstractTriangular}, b::AbstractVector) = naivesub!(A, b)
At_ldiv_B!(A::Bidiagonal, b::AbstractVector) = A_ldiv_B!(transpose(A), b)
Ac_ldiv_B!(A::Bidiagonal, b::AbstractVector) = A_ldiv_B!(adjoint(A), b)
function A_ldiv_B!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix)
A_ldiv_B!2(A::Union{Bidiagonal, AbstractTriangular}, b::AbstractVector) = naivesub!(A, b)
At_ldiv_B!2(A::Bidiagonal, b::AbstractVector) = A_ldiv_B!2(transpose(A), b)
Ac_ldiv_B!2(A::Bidiagonal, b::AbstractVector) = A_ldiv_B!2(adjoint(A), b)
function A_ldiv_B!2(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix)
nA,mA = size(A)
tmp = similar(B,size(B,1))
n = size(B, 1)
Expand All @@ -506,12 +506,12 @@ function A_ldiv_B!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix)
end
for i = 1:size(B,2)
copy!(tmp, 1, B, (i - 1)*n + 1, n)
A_ldiv_B!(A, tmp)
A_ldiv_B!2(A, tmp)
copy!(B, (i - 1)*n + 1, tmp, 1, n) # Modify this when array view are implemented.
end
B
end
for func in (:Ac_ldiv_B!, :At_ldiv_B!)
for func in (:Ac_ldiv_B!2, :At_ldiv_B!2)
@eval function ($func)(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix)
nA,mA = size(A)
tmp = similar(B,size(B,1))
Expand Down Expand Up @@ -550,13 +550,13 @@ function naivesub!(A::Bidiagonal{T}, b::AbstractVector, x::AbstractVector = b) w
end

### Generic promotion methods and fallbacks
for (f,g) in ((:\, :A_ldiv_B!), (:At_ldiv_B, :At_ldiv_B!), (:Ac_ldiv_B, :Ac_ldiv_B!))
for (f,f!2) in ((:\, :A_ldiv_B!2), (:At_ldiv_B, :At_ldiv_B!2), (:Ac_ldiv_B, :Ac_ldiv_B!2))
@eval begin
function ($f)(A::Bidiagonal{TA}, B::AbstractVecOrMat{TB}) where {TA<:Number,TB<:Number}
TAB = typeof((zero(TA)*zero(TB) + zero(TA)*zero(TB))/one(TA))
($g)(convert(AbstractArray{TAB}, A), copy_oftype(B, TAB))
($f!2)(convert(AbstractArray{TAB}, A), copy_oftype(B, TAB))
end
($f)(A::Bidiagonal, B::AbstractVecOrMat) = ($g)(A, copy(B))
($f)(A::Bidiagonal, B::AbstractVecOrMat) = ($f!2)(A, copy(B))
end
end

Expand Down
8 changes: 4 additions & 4 deletions base/linalg/bunchkaufman.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -232,7 +232,7 @@ function inv(B::BunchKaufman{<:BlasComplex})
end
end

function A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where T<:BlasReal
function A_ldiv_B!2(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where T<:BlasReal
if !issuccess(B)
throw(SingularException(B.info))
end
Expand All @@ -243,7 +243,7 @@ function A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where T<:BlasReal
LAPACK.sytrs!(B.uplo, B.LD, B.ipiv, R)
end
end
function A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where T<:BlasComplex
function A_ldiv_B!2(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where T<:BlasComplex
if !issuccess(B)
throw(SingularException(B.info))
end
Expand All @@ -263,9 +263,9 @@ function A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{T}) where T<:BlasCompl
end
end
# There is no fallback solver for Bunch-Kaufman so we'll have to promote to same element type
function A_ldiv_B!(B::BunchKaufman{T}, R::StridedVecOrMat{S}) where {T,S}
function A_ldiv_B!2(B::BunchKaufman{T}, R::StridedVecOrMat{S}) where {T,S}
TS = promote_type(T,S)
return A_ldiv_B!(convert(BunchKaufman{TS}, B), convert(AbstractArray{TS}, R))
return A_ldiv_B!2(convert(BunchKaufman{TS}, B), convert(AbstractArray{TS}, R))
end

function logabsdet(F::BunchKaufman)
Expand Down
32 changes: 16 additions & 16 deletions base/linalg/cholesky.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -419,22 +419,22 @@ function show(io::IO, mime::MIME{Symbol("text/plain")}, C::CholeskyPivoted{<:Any
show(io, mime, C[:p])
end

A_ldiv_B!(C::Cholesky{T,<:AbstractMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
A_ldiv_B!2(C::Cholesky{T,<:AbstractMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
@assertposdef LAPACK.potrs!(C.uplo, C.factors, B) C.info

function A_ldiv_B!(C::Cholesky{<:Any,<:AbstractMatrix}, B::StridedVecOrMat)
function A_ldiv_B!2(C::Cholesky{<:Any,<:AbstractMatrix}, B::StridedVecOrMat)
if C.uplo == 'L'
return Ac_ldiv_B!(LowerTriangular(C.factors), A_ldiv_B!(LowerTriangular(C.factors), B))
return Ac_ldiv_B!2(LowerTriangular(C.factors), A_ldiv_B!2(LowerTriangular(C.factors), B))
else
return A_ldiv_B!(UpperTriangular(C.factors), Ac_ldiv_B!(UpperTriangular(C.factors), B))
return A_ldiv_B!2(UpperTriangular(C.factors), Ac_ldiv_B!2(UpperTriangular(C.factors), B))
end
end

function A_ldiv_B!(C::CholeskyPivoted{T}, B::StridedVector{T}) where T<:BlasFloat
function A_ldiv_B!2(C::CholeskyPivoted{T}, B::StridedVector{T}) where T<:BlasFloat
chkfullrank(C)
ipermute!(LAPACK.potrs!(C.uplo, C.factors, permute!(B, C.piv)), C.piv)
end
function A_ldiv_B!(C::CholeskyPivoted{T}, B::StridedMatrix{T}) where T<:BlasFloat
function A_ldiv_B!2(C::CholeskyPivoted{T}, B::StridedMatrix{T}) where T<:BlasFloat
chkfullrank(C)
n = size(C, 1)
for i=1:size(B, 2)
Expand All @@ -447,23 +447,23 @@ function A_ldiv_B!(C::CholeskyPivoted{T}, B::StridedMatrix{T}) where T<:BlasFloa
B
end

function A_ldiv_B!(C::CholeskyPivoted, B::StridedVector)
function A_ldiv_B!2(C::CholeskyPivoted, B::StridedVector)
if C.uplo == 'L'
Ac_ldiv_B!(LowerTriangular(C.factors),
A_ldiv_B!(LowerTriangular(C.factors), B[C.piv]))[invperm(C.piv)]
Ac_ldiv_B!2(LowerTriangular(C.factors),
A_ldiv_B!2(LowerTriangular(C.factors), B[C.piv]))[invperm(C.piv)]
else
A_ldiv_B!(UpperTriangular(C.factors),
Ac_ldiv_B!(UpperTriangular(C.factors), B[C.piv]))[invperm(C.piv)]
A_ldiv_B!2(UpperTriangular(C.factors),
Ac_ldiv_B!2(UpperTriangular(C.factors), B[C.piv]))[invperm(C.piv)]
end
end

function A_ldiv_B!(C::CholeskyPivoted, B::StridedMatrix)
function A_ldiv_B!2(C::CholeskyPivoted, B::StridedMatrix)
if C.uplo == 'L'
Ac_ldiv_B!(LowerTriangular(C.factors),
A_ldiv_B!(LowerTriangular(C.factors), B[C.piv,:]))[invperm(C.piv),:]
Ac_ldiv_B!2(LowerTriangular(C.factors),
A_ldiv_B!2(LowerTriangular(C.factors), B[C.piv,:]))[invperm(C.piv),:]
else
A_ldiv_B!(UpperTriangular(C.factors),
Ac_ldiv_B!(UpperTriangular(C.factors), B[C.piv,:]))[invperm(C.piv),:]
A_ldiv_B!2(UpperTriangular(C.factors),
Ac_ldiv_B!2(UpperTriangular(C.factors), B[C.piv,:]))[invperm(C.piv),:]
end
end

Expand Down
Loading