Deprecate getindex(::Factorization, ::Symbol) in favor of dot overloa…

…ding

base/deprecated.jl

@@ -3423,6 +3423,16 @@ workspace() = error("workspace() is discontinued, check out Revise.jl for an alt
 # PR #25113
 @deprecate_binding CartesianRange CartesianIndices
 
+# Use getproperty instead of getindex for Factorizations
+function getindex(F::Factorization, s::Symbol)
+    depwarn("`F[:$s]` is deprecated, use `F.$s` instead.", :getindex)
+    return getproperty(F, s)
+end
+
+@eval Base.LinAlg begin
+    @deprecate getq(F::Factorization) F.Q
+end
+
 # END 0.7 deprecations
 
 # BEGIN 1.0 deprecations

base/linalg/bunchkaufman.jl

@@ -86,8 +86,8 @@ convert(::Type{BunchKaufman{T}}, B::BunchKaufman) where {T} =
 convert(::Type{Factorization{T}}, B::BunchKaufman{T}) where {T} = B
 convert(::Type{Factorization{T}}, B::BunchKaufman) where {T} = convert(BunchKaufman{T}, B)
 
-size(B::BunchKaufman) = size(B.LD)
-size(B::BunchKaufman, d::Integer) = size(B.LD, d)
+size(B::BunchKaufman) = size(getfield(B, :LD))
+size(B::BunchKaufman, d::Integer) = size(getfield(B, :LD), d)
 issymmetric(B::BunchKaufman) = B.symmetric
 ishermitian(B::BunchKaufman) = !B.symmetric
 
@@ -115,7 +115,7 @@ function _ipiv2perm_bk(v::AbstractVector{T}, maxi::Integer, uplo::Char) where T
 end
 
 """
-    getindex(B::BunchKaufman, d::Symbol)
+    getproperty(B::BunchKaufman, d::Symbol)
 
 Extract the factors of the Bunch-Kaufman factorization `B`. The factorization can take the
 two forms `L*D*L'` or `U*D*U'` (or `L*D*Transpose(L)` in the complex symmetric case) where `L` is a
@@ -153,43 +153,43 @@ permutation:
  3
  2
 
-julia> F[:L]*F[:D]*F[:L]' - A[F[:p], F[:p]]
+julia> F.L*F.D*F.L' - A[F.p, F.p]
 3×3 Array{Float64,2}:
  0.0  0.0  0.0
  0.0  0.0  0.0
  0.0  0.0  0.0
 
 julia> F = bkfact(Symmetric(A));
 
-julia> F[:U]*F[:D]*F[:U]' - F[:P]*A*F[:P]'
+julia> F.U*F.D*F.U' - F.P*A*F.P'
 3×3 Array{Float64,2}:
  0.0  0.0  0.0
  0.0  0.0  0.0
  0.0  0.0  0.0
 ```
 """
-function getindex(B::BunchKaufman{T}, d::Symbol) where {T<:BlasFloat}
+function getproperty(B::BunchKaufman{T}, d::Symbol) where {T<:BlasFloat}
     n = size(B, 1)
     if d == :p
-        return _ipiv2perm_bk(B.ipiv, n, B.uplo)
+        return _ipiv2perm_bk(getfield(B, :ipiv), n, getfield(B, :uplo))
     elseif d == :P
-        return Matrix{T}(I, n, n)[:,invperm(B[:p])]
+        return Matrix{T}(I, n, n)[:,invperm(B.p)]
     elseif d == :L || d == :U || d == :D
-        if B.rook
-            LUD, od = LAPACK.syconvf_rook!(B.uplo, 'C', copy(B.LD), B.ipiv)
+        if getfield(B, :rook)
+            LUD, od = LAPACK.syconvf_rook!(getfield(B, :uplo), 'C', copy(getfield(B, :LD)), getfield(B, :ipiv))
         else
-            LUD, od = LAPACK.syconv!(B.uplo, copy(B.LD), B.ipiv)
+            LUD, od = LAPACK.syconv!(getfield(B, :uplo), copy(getfield(B, :LD)), getfield(B, :ipiv))
         end
         if d == :D
-            if B.uplo == 'L'
+            if getfield(B, :uplo) == 'L'
                 odl = od[1:n - 1]
-                return Tridiagonal(odl, diag(LUD), B.symmetric ? odl : conj.(odl))
+                return Tridiagonal(odl, diag(LUD), getfield(B, :symmetric) ? odl : conj.(odl))
             else # 'U'
                 odu = od[2:n]
-                return Tridiagonal(B.symmetric ? odu : conj.(odu), diag(LUD), odu)
+                return Tridiagonal(getfield(B, :symmetric) ? odu : conj.(odu), diag(LUD), odu)
             end
         elseif d == :L
-            if B.uplo == 'L'
+            if getfield(B, :uplo) == 'L'
                 return UnitLowerTriangular(LUD)
             else
                 throw(ArgumentError("factorization is U*D*Transpose(U) but you requested L"))
@@ -202,7 +202,7 @@ function getindex(B::BunchKaufman{T}, d::Symbol) where {T<:BlasFloat}
             end
         end
     else
-        throw(KeyError(d))
+        getfield(B, d)
     end
 end
 
@@ -212,11 +212,11 @@ function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, B::BunchKaufman)
     if issuccess(B)
         println(io, summary(B))
         println(io, "D factor:")
-        show(io, mime, B[:D])
+        show(io, mime, B.D)
         println(io, "\n$(B.uplo) factor:")
-        show(io, mime, B[Symbol(B.uplo)])
+        show(io, mime, B.uplo == 'L' ? B.L : B.U)
         println(io, "\npermutation:")
-        show(io, mime, B[:p])
+        show(io, mime, B.p)
     else
         print(io, "Failed factorization of type $(typeof(B))")
     end

base/linalg/cholesky.jl

@@ -285,7 +285,7 @@ end
 Compute the Cholesky factorization of a dense symmetric positive definite matrix `A`
 and return a `Cholesky` factorization. The matrix `A` can either be a [`Symmetric`](@ref) or [`Hermitian`](@ref)
 `StridedMatrix` or a *perfectly* symmetric or Hermitian `StridedMatrix`.
-The triangular Cholesky factor can be obtained from the factorization `F` with: `F[:L]` and `F[:U]`.
+The triangular Cholesky factor can be obtained from the factorization `F` with: `F.L` and `F.U`.
 The following functions are available for `Cholesky` objects: [`size`](@ref), [`\\`](@ref),
 [`inv`](@ref), [`det`](@ref), [`logdet`](@ref) and [`isposdef`](@ref).
 
@@ -305,19 +305,19 @@ U factor:
   ⋅   1.0   5.0
   ⋅    ⋅    3.0
 
-julia> C[:U]
+julia> C.U
 3×3 UpperTriangular{Float64,Array{Float64,2}}:
  2.0  6.0  -8.0
   ⋅   1.0   5.0
   ⋅    ⋅    3.0
 
-julia> C[:L]
+julia> C.L
 3×3 LowerTriangular{Float64,Array{Float64,2}}:
   2.0   ⋅    ⋅
   6.0  1.0   ⋅
  -8.0  5.0  3.0
 
-julia> C[:L] * C[:U] == A
+julia> C.L * C.U == A
 true
 ```
 """
@@ -332,7 +332,7 @@ cholfact(A::Union{StridedMatrix,RealHermSymComplexHerm{<:Real,<:StridedMatrix}},
 Compute the pivoted Cholesky factorization of a dense symmetric positive semi-definite matrix `A`
 and return a `CholeskyPivoted` factorization. The matrix `A` can either be a [`Symmetric`](@ref)
 or [`Hermitian`](@ref) `StridedMatrix` or a *perfectly* symmetric or Hermitian `StridedMatrix`.
-The triangular Cholesky factor can be obtained from the factorization `F` with: `F[:L]` and `F[:U]`.
+The triangular Cholesky factor can be obtained from the factorization `F` with: `F.L` and `F.U`.
 The following functions are available for `PivotedCholesky` objects:
 [`size`](@ref), [`\\`](@ref), [`inv`](@ref), [`det`](@ref), and [`rank`](@ref).
 The argument `tol` determines the tolerance for determining the rank.
@@ -361,14 +361,14 @@ convert(::Type{CholeskyPivoted{T}},C::CholeskyPivoted) where {T} =
 convert(::Type{Factorization{T}}, C::CholeskyPivoted{T}) where {T} = C
 convert(::Type{Factorization{T}}, C::CholeskyPivoted) where {T} = convert(CholeskyPivoted{T}, C)
 
-convert(::Type{AbstractMatrix}, C::Cholesky) = C.uplo == 'U' ? C[:U]'C[:U] : C[:L]*C[:L]'
+convert(::Type{AbstractMatrix}, C::Cholesky) = C.uplo == 'U' ? C.U'C.U : C.L*C.L'
 convert(::Type{AbstractArray}, C::Cholesky) = convert(AbstractMatrix, C)
 convert(::Type{Matrix}, C::Cholesky) = convert(Array, convert(AbstractArray, C))
 convert(::Type{Array}, C::Cholesky) = convert(Matrix, C)
 
 function convert(::Type{AbstractMatrix}, F::CholeskyPivoted)
-    ip = invperm(F[:p])
-    (F[:L] * F[:U])[ip,ip]
+    ip = invperm(F.p)
+    (F.L * F.U)[ip,ip]
 end
 convert(::Type{AbstractArray}, F::CholeskyPivoted) = convert(AbstractMatrix, F)
 convert(::Type{Matrix}, F::CholeskyPivoted) = convert(Array, convert(AbstractArray, F))
@@ -380,43 +380,56 @@ copy(C::CholeskyPivoted) = CholeskyPivoted(copy(C.factors), C.uplo, C.piv, C.ran
 size(C::Union{Cholesky, CholeskyPivoted}) = size(C.factors)
 size(C::Union{Cholesky, CholeskyPivoted}, d::Integer) = size(C.factors, d)
 
-function getindex(C::Cholesky, d::Symbol)
-    d == :U && return UpperTriangular(Symbol(C.uplo) == d ? C.factors : adjoint(C.factors))
-    d == :L && return LowerTriangular(Symbol(C.uplo) == d ? C.factors : adjoint(C.factors))
-    d == :UL && return Symbol(C.uplo) == :U ? UpperTriangular(C.factors) : LowerTriangular(C.factors)
-    throw(KeyError(d))
-end
-function getindex(C::CholeskyPivoted{T}, d::Symbol) where T<:BlasFloat
-    d == :U && return UpperTriangular(Symbol(C.uplo) == d ? C.factors : adjoint(C.factors))
-    d == :L && return LowerTriangular(Symbol(C.uplo) == d ? C.factors : adjoint(C.factors))
-    d == :p && return C.piv
-    if d == :P
+function getproperty(C::Cholesky, d::Symbol)
+    Cfactors = getfield(C, :factors)
+    Cuplo    = getfield(C, :uplo)
+    if d == :U
+        return UpperTriangular(Symbol(Cuplo) == d ? Cfactors : adjoint(Cfactors))
+    elseif d == :L
+        return LowerTriangular(Symbol(Cuplo) == d ? Cfactors : adjoint(Cfactors))
+    elseif d == :UL
+        return Symbol(Cuplo) == :U ? UpperTriangular(Cfactors) : LowerTriangular(Cfactors)
+    else
+        return getfield(C, d)
+    end
+end
+function getproperty(C::CholeskyPivoted{T}, d::Symbol) where T<:BlasFloat
+    Cfactors = getfield(C, :factors)
+    Cuplo    = getfield(C, :uplo)
+    if d == :U
+        return UpperTriangular(Symbol(Cuplo) == d ? Cfactors : adjoint(Cfactors))
+    elseif d == :L
+        return LowerTriangular(Symbol(Cuplo) == d ? Cfactors : adjoint(Cfactors))
+    elseif d == :p
+        return getfield(C, :piv)
+    elseif d == :P
         n = size(C, 1)
         P = zeros(T, n, n)
         for i = 1:n
-            P[C.piv[i],i] = one(T)
+            P[getfield(C, :piv)[i], i] = one(T)
         end
         return P
+    else
+        return getfield(C, d)
     end
-    throw(KeyError(d))
 end
 
 issuccess(C::Cholesky) = C.info == 0
 
 function show(io::IO, mime::MIME{Symbol("text/plain")}, C::Cholesky{<:Any,<:AbstractMatrix})
     if issuccess(C)
         println(io, summary(C), "\n$(C.uplo) factor:")
-        show(io, mime, C[:UL])
+        show(io, mime, C.UL)
     else
         print(io, "Failed factorization of type $(typeof(C))")
     end
 end
 
 function show(io::IO, mime::MIME{Symbol("text/plain")}, C::CholeskyPivoted{<:Any,<:AbstractMatrix})
     println(io, summary(C), "\n$(C.uplo) factor with rank $(rank(C)):")
-    show(io, mime, C.uplo == 'U' ? C[:U] : C[:L])
+    show(io, mime, C.uplo == 'U' ? C.U : C.L)
     println(io, "\npermutation:")
-    show(io, mime, C[:p])
+    show(io, mime, C.p)
 end
 
 ldiv!(C::Cholesky{T,<:AbstractMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
@@ -534,8 +547,8 @@ rank(C::CholeskyPivoted) = C.rank
 """
     lowrankupdate!(C::Cholesky, v::StridedVector) -> CC::Cholesky
 
-Update a Cholesky factorization `C` with the vector `v`. If `A = C[:U]'C[:U]` then
-`CC = cholfact(C[:U]'C[:U] + v*v')` but the computation of `CC` only uses `O(n^2)`
+Update a Cholesky factorization `C` with the vector `v`. If `A = C.U'C.U` then
+`CC = cholfact(C.U'C.U + v*v')` but the computation of `CC` only uses `O(n^2)`
 operations. The input factorization `C` is updated in place such that on exit `C == CC`.
 The vector `v` is destroyed during the computation.
 """
@@ -580,8 +593,8 @@ end
 """
     lowrankdowndate!(C::Cholesky, v::StridedVector) -> CC::Cholesky
 
-Downdate a Cholesky factorization `C` with the vector `v`. If `A = C[:U]'C[:U]` then
-`CC = cholfact(C[:U]'C[:U] - v*v')` but the computation of `CC` only uses `O(n^2)`
+Downdate a Cholesky factorization `C` with the vector `v`. If `A = C.U'C.U` then
+`CC = cholfact(C.U'C.U - v*v')` but the computation of `CC` only uses `O(n^2)`
 operations. The input factorization `C` is updated in place such that on exit `C == CC`.
 The vector `v` is destroyed during the computation.
 """
@@ -633,17 +646,17 @@ end
 """
     lowrankupdate(C::Cholesky, v::StridedVector) -> CC::Cholesky
 
-Update a Cholesky factorization `C` with the vector `v`. If `A = C[:U]'C[:U]`
-then `CC = cholfact(C[:U]'C[:U] + v*v')` but the computation of `CC` only uses
+Update a Cholesky factorization `C` with the vector `v`. If `A = C.U'C.U`
+then `CC = cholfact(C.U'C.U + v*v')` but the computation of `CC` only uses
 `O(n^2)` operations.
 """
 lowrankupdate(C::Cholesky, v::StridedVector) = lowrankupdate!(copy(C), copy(v))
 
 """
     lowrankdowndate(C::Cholesky, v::StridedVector) -> CC::Cholesky
 
-Downdate a Cholesky factorization `C` with the vector `v`. If `A = C[:U]'C[:U]`
-then `CC = cholfact(C[:U]'C[:U] - v*v')` but the computation of `CC` only uses
+Downdate a Cholesky factorization `C` with the vector `v`. If `A = C.U'C.U`
+then `CC = cholfact(C.U'C.U - v*v')` but the computation of `CC` only uses
 `O(n^2)` operations.
 """
 lowrankdowndate(C::Cholesky, v::StridedVector) = lowrankdowndate!(copy(C), copy(v))

base/linalg/dense.jl

@@ -709,8 +709,8 @@ function sqrt(A::StridedMatrix{<:Real})
         return triu!(parent(sqrt(UpperTriangular(A))))
     else
         SchurF = schurfact(complex(A))
-        R = triu!(parent(sqrt(UpperTriangular(SchurF[:T])))) # unwrapping unnecessary?
-        return SchurF[:vectors] * R * SchurF[:vectors]'
+        R = triu!(parent(sqrt(UpperTriangular(SchurF.T)))) # unwrapping unnecessary?
+        return SchurF.vectors * R * SchurF.vectors'
     end
 end
 function sqrt(A::StridedMatrix{<:Complex})
@@ -723,8 +723,8 @@ function sqrt(A::StridedMatrix{<:Complex})
         return triu!(parent(sqrt(UpperTriangular(A))))
     else
         SchurF = schurfact(A)
-        R = triu!(parent(sqrt(UpperTriangular(SchurF[:T])))) # unwrapping unnecessary?
-        return SchurF[:vectors] * R * SchurF[:vectors]'
+        R = triu!(parent(sqrt(UpperTriangular(SchurF.T)))) # unwrapping unnecessary?
+        return SchurF.vectors * R * SchurF.vectors'
     end
 end
 

base/linalg/eigen.jl

@@ -20,13 +20,6 @@ end
 GeneralizedEigen(values::AbstractVector{V}, vectors::AbstractMatrix{T}) where {T,V} =
     GeneralizedEigen{T,V,typeof(vectors),typeof(values)}(values, vectors)
 
-
-function getindex(A::Union{Eigen,GeneralizedEigen}, d::Symbol)
-    d == :values && return A.values
-    d == :vectors && return A.vectors
-    throw(KeyError(d))
-end
-
 isposdef(A::Union{Eigen,GeneralizedEigen}) = isreal(A.values) && all(x -> x > 0, A.values)
 
 """
@@ -69,8 +62,8 @@ end
     eigfact(A; permute::Bool=true, scale::Bool=true) -> Eigen
 
 Computes the eigenvalue decomposition of `A`, returning an `Eigen` factorization object `F`
-which contains the eigenvalues in `F[:values]` and the eigenvectors in the columns of the
-matrix `F[:vectors]`. (The `k`th eigenvector can be obtained from the slice `F[:vectors][:, k]`.)
+which contains the eigenvalues in `F.values` and the eigenvectors in the columns of the
+matrix `F.vectors`. (The `k`th eigenvector can be obtained from the slice `F.vectors[:, k]`.)
 
 The following functions are available for `Eigen` objects: [`inv`](@ref), [`det`](@ref), and [`isposdef`](@ref).
 
@@ -84,13 +77,13 @@ make rows and columns more equal in norm. The default is `true` for both options
 julia> F = eigfact([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
 Base.LinAlg.Eigen{Float64,Float64,Array{Float64,2},Array{Float64,1}}([1.0, 3.0, 18.0], [1.0 0.0 0.0; 0.0 1.0 0.0; 0.0 0.0 1.0])
 
-julia> F[:values]
+julia> F.values
 3-element Array{Float64,1}:
   1.0
   3.0
  18.0
 
-julia> F[:vectors]
+julia> F.vectors
 3×3 Array{Float64,2}:
  1.0  0.0  0.0
  0.0  1.0  0.0
@@ -154,9 +147,9 @@ julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
 """
 eigvecs(A::Union{Number, AbstractMatrix}; permute::Bool=true, scale::Bool=true) =
     eigvecs(eigfact(A, permute=permute, scale=scale))
-eigvecs(F::Union{Eigen{T,V,S,U}, GeneralizedEigen{T,V,S,U}}) where {T,V,S,U} = F[:vectors]::S
+eigvecs(F::Union{Eigen, GeneralizedEigen}) = F.vectors
 
-eigvals(F::Union{Eigen{T,V,S,U}, GeneralizedEigen{T,V,S,U}}) where {T,V,S,U} = F[:values]::U
+eigvals(F::Union{Eigen, GeneralizedEigen}) = F.values
 
 """
     eigvals!(A; permute::Bool=true, scale::Bool=true) -> values
@@ -352,8 +345,8 @@ end
 
 Computes the generalized eigenvalue decomposition of `A` and `B`, returning a
 `GeneralizedEigen` factorization object `F` which contains the generalized eigenvalues in
-`F[:values]` and the generalized eigenvectors in the columns of the matrix `F[:vectors]`.
-(The `k`th generalized eigenvector can be obtained from the slice `F[:vectors][:, k]`.)
+`F.values` and the generalized eigenvectors in the columns of the matrix `F.vectors`.
+(The `k`th generalized eigenvector can be obtained from the slice `F.vectors[:, k]`.)
 
 # Examples
 ```jldoctest
@@ -369,12 +362,12 @@ julia> B = [0 1; 1 0]
 
 julia> F = eigfact(A, B);
 
-julia> F[:values]
+julia> F.values
 2-element Array{Complex{Float64},1}:
  0.0 + 1.0im
  0.0 - 1.0im
 
-julia> F[:vectors]
+julia> F.vectors
 2×2 Array{Complex{Float64},2}:
   0.0-1.0im   0.0+1.0im
  -1.0-0.0im  -1.0+0.0im