Mild AbstractQ review and refactoring (#49714)

stdlib/LinearAlgebra/src/LinearAlgebra.jl

@@ -9,14 +9,14 @@ module LinearAlgebra
 
 import Base: \, /, *, ^, +, -, ==
 import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, asec, asech,
- asin, asinh, atan, atanh, axes, big, broadcast, ceil, cis, conj, convert, copy, copyto!,
- copymutable, cos, cosh, cot, coth, csc, csch, eltype, exp, fill!, floor, getindex, hcat,
- getproperty, imag, inv, isapprox, isequal, isone, iszero, IndexStyle, kron, kron!,
- length, log, map, ndims, one, oneunit, parent, permutedims, power_by_squaring,
- print_matrix, promote_rule, real, round, sec, sech, setindex!, show, similar, sin,
+ asin, asinh, atan, atanh, axes, big, broadcast, ceil, cis, collect, conj, convert, copy,
+ copyto!, copymutable, cos, cosh, cot, coth, csc, csch, eltype, exp, fill!, floor,
+ getindex, hcat, getproperty, imag, inv, isapprox, isequal, isone, iszero, IndexStyle,
+ kron, kron!, length, log, map, ndims, one, oneunit, parent, permutedims,
+ power_by_squaring, promote_rule, real, sec, sech, setindex!, show, similar, sin,
  sincos, sinh, size, sqrt, strides, stride, tan, tanh, transpose, trunc, typed_hcat,
  vec, view, zero
-using Base: IndexLinear, promote_eltype, promote_op, promote_typeof,
+using Base: IndexLinear, promote_eltype, promote_op, promote_typeof, print_matrix,
  @propagate_inbounds, reduce, typed_hvcat, typed_vcat, require_one_based_indexing,
  splat
 using Base.Broadcast: Broadcasted, broadcasted

stdlib/LinearAlgebra/src/abstractq.jl

@@ -35,6 +35,7 @@ convert(::Type{AbstractQ{T}}, adjQ::AdjointQ{T}) where {T} = adjQ
 convert(::Type{AbstractQ{T}}, adjQ::AdjointQ) where {T} = convert(AbstractQ{T}, adjQ.Q)'
 
 # ... to matrix
+collect(Q::AbstractQ) = copyto!(Matrix{eltype(Q)}(undef, size(Q)), Q)
 Matrix{T}(Q::AbstractQ) where {T} = convert(Matrix{T}, Q*I) # generic fallback, yields square matrix
 Matrix{T}(adjQ::AdjointQ{S}) where {T,S} = convert(Matrix{T}, lmul!(adjQ, Matrix{S}(I, size(adjQ))))
 Matrix(Q::AbstractQ{T}) where {T} = Matrix{T}(Q)
@@ -56,6 +57,15 @@ function size(Q::AbstractQ, dim::Integer)
 end
 size(adjQ::AdjointQ) = reverse(size(adjQ.Q))
 
+# comparison
+(==)(Q::AbstractQ, A::AbstractMatrix) = lmul!(Q, Matrix{eltype(Q)}(I, size(A))) == A
+(==)(A::AbstractMatrix, Q::AbstractQ) = Q == A
+(==)(Q::AbstractQ, P::AbstractQ) = Matrix(Q) == Matrix(P)
+isapprox(Q::AbstractQ, A::AbstractMatrix; kwargs...) =
+ isapprox(lmul!(Q, Matrix{eltype(Q)}(I, size(A))), A, kwargs...)
+isapprox(A::AbstractMatrix, Q::AbstractQ; kwargs...) = isapprox(Q, A, kwargs...)
+isapprox(Q::AbstractQ, P::AbstractQ; kwargs...) = isapprox(Matrix(Q), Matrix(P), kwargs...)
+
 # pseudo-array behaviour, required for indexing with `begin` or `end`
 axes(Q::AbstractQ) = map(Base.oneto, size(Q))
 axes(Q::AbstractQ, d::Integer) = d in (1, 2) ? axes(Q)[d] : Base.OneTo(1)
@@ -125,36 +135,60 @@ function show(io::IO, ::MIME{Symbol("text/plain")}, Q::AbstractQ)
 end
 
 # multiplication
+# generically, treat AbstractQ like a matrix with its definite size
+qsize_check(Q::AbstractQ, B::AbstractVecOrMat) =
+ size(Q, 2) == size(B, 1) ||
+ throw(DimensionMismatch("second dimension of Q, $(size(Q,2)), must coincide with first dimension of B, $(size(B,1))"))
+qsize_check(A::AbstractVecOrMat, Q::AbstractQ) =
+ size(A, 2) == size(Q, 1) ||
+ throw(DimensionMismatch("second dimension of A, $(size(A,2)), must coincide with first dimension of Q, $(size(Q,1))"))
+qsize_check(Q::AbstractQ, P::AbstractQ) =
+ size(Q, 2) == size(P, 1) ||
+ throw(DimensionMismatch("second dimension of A, $(size(Q,2)), must coincide with first dimension of B, $(size(P,1))"))
+
 (*)(Q::AbstractQ, J::UniformScaling) = Q*J.λ
 function (*)(Q::AbstractQ, b::Number)
  T = promote_type(eltype(Q), typeof(b))
  lmul!(convert(AbstractQ{T}, Q), Matrix{T}(b*I, size(Q)))
 end
-function (*)(A::AbstractQ, B::AbstractVecOrMat)
- T = promote_type(eltype(A), eltype(B))
- lmul!(convert(AbstractQ{T}, A), copy_similar(B, T))
+function (*)(Q::AbstractQ, B::AbstractVector)
+ T = promote_type(eltype(Q), eltype(B))
+ qsize_check(Q, B)
+ mul!(similar(B, T, size(Q, 1)), convert(AbstractQ{T}, Q), B)
+end
+function (*)(Q::AbstractQ, B::AbstractMatrix)
+ T = promote_type(eltype(Q), eltype(B))
+ qsize_check(Q, B)
+ mul!(similar(B, T, (size(Q, 1), size(B, 2))), convert(AbstractQ{T}, Q), B)
 end
 
 (*)(J::UniformScaling, Q::AbstractQ) = J.λ*Q
 function (*)(a::Number, Q::AbstractQ)
  T = promote_type(typeof(a), eltype(Q))
  rmul!(Matrix{T}(a*I, size(Q)), convert(AbstractQ{T}, Q))
 end
-*(a::AbstractVector, Q::AbstractQ) = reshape(a, length(a), 1) * Q
+function (*)(A::AbstractVector, Q::AbstractQ)
+ T = promote_type(eltype(A), eltype(Q))
+ qsize_check(A, Q)
+ return mul!(similar(A, T, length(A)), A, convert(AbstractQ{T}, Q))
+end
 function (*)(A::AbstractMatrix, Q::AbstractQ)
  T = promote_type(eltype(A), eltype(Q))
- return rmul!(copy_similar(A, T), convert(AbstractQ{T}, Q))
+ qsize_check(A, Q)
+ return mul!(similar(A, T, (size(A, 1), size(Q, 2))), A, convert(AbstractQ{T}, Q))
 end
 (*)(u::AdjointAbsVec, Q::AbstractQ) = (Q'u')'
 
 ### Q*Q (including adjoints)
-*(Q::AbstractQ, P::AbstractQ) = Q * (P*I)
+(*)(Q::AbstractQ, P::AbstractQ) = Q * (P*I)
 
 ### mul!
-function mul!(C::AbstractVecOrMat{T}, Q::AbstractQ{T}, B::Union{AbstractVecOrMat{T},AbstractQ{T}}) where {T}
+function mul!(C::AbstractVecOrMat{T}, Q::AbstractQ{T}, B::Union{AbstractVecOrMat,AbstractQ}) where {T}
  require_one_based_indexing(C, B)
- mB = size(B, 1)
- mC = size(C, 1)
+ mB, nB = size(B, 1), size(B, 2)
+ mC, nC = size(C, 1), size(C, 2)
+ qsize_check(Q, B)
+ nB != nC && throw(DimensionMismatch())
  if mB < mC
  inds = CartesianIndices(axes(B))
  copyto!(view(C, inds), B)
@@ -164,9 +198,21 @@ function mul!(C::AbstractVecOrMat{T}, Q::AbstractQ{T}, B::Union{AbstractVecOrMat
  return lmul!(Q, copyto!(C, B))
  end
 end
-mul!(C::AbstractVecOrMat{T}, A::AbstractVecOrMat{T}, Q::AbstractQ{T}) where {T} = rmul!(copyto!(C, A), Q)
-mul!(C::AbstractVecOrMat{T}, adjQ::AdjointQ{T}, B::AbstractVecOrMat{T}) where {T} = lmul!(adjQ, copyto!(C, B))
-mul!(C::AbstractVecOrMat{T}, A::AbstractVecOrMat{T}, adjQ::AdjointQ{T}) where {T} = rmul!(copyto!(C, A), adjQ)
+function mul!(C::AbstractVecOrMat{T}, A::AbstractVecOrMat, Q::AbstractQ{T}) where {T}
+ require_one_based_indexing(C, A)
+ mA, nA = size(A, 1), size(A, 2)
+ mC, nC = size(C, 1), size(C, 2)
+ mA != mC && throw(DimensionMismatch())
+ qsize_check(A, Q)
+ if nA < nC
+ inds = CartesianIndices(axes(A))
+ copyto!(view(C, inds), A)
+ C[CartesianIndices((axes(C, 1), nA+1:nC))] .= zero(T)
+ return rmul!(C, Q)
+ else
+ return rmul!(copyto!(C, A), Q)
+ end
+end
 
 ### division
 \(Q::AbstractQ, A::AbstractVecOrMat) = Q'*A
@@ -319,7 +365,7 @@ rmul!(A::StridedVecOrMat{T}, B::QRCompactWYQ{T,<:StridedMatrix}) where {T<:BlasF
  LAPACK.gemqrt!('R', 'N', B.factors, B.T, A)
 rmul!(A::StridedVecOrMat{T}, B::QRPackedQ{T,<:StridedMatrix}) where {T<:BlasFloat} =
  LAPACK.ormqr!('R', 'N', B.factors, B.τ, A)
-function rmul!(A::AbstractMatrix, Q::QRPackedQ)
+function rmul!(A::AbstractVecOrMat, Q::QRPackedQ)
  require_one_based_indexing(A)
  mQ, nQ = size(Q.factors)
  mA, nA = size(A,1), size(A,2)
@@ -354,7 +400,7 @@ rmul!(A::StridedVecOrMat{T}, adjQ::AdjointQ{<:Any,<:QRPackedQ{T}}) where {T<:Bla
  (Q = adjQ.Q; LAPACK.ormqr!('R', 'T', Q.factors, Q.τ, A))
 rmul!(A::StridedVecOrMat{T}, adjQ::AdjointQ{<:Any,<:QRPackedQ{T}}) where {T<:BlasComplex} =
  (Q = adjQ.Q; LAPACK.ormqr!('R', 'C', Q.factors, Q.τ, A))
-function rmul!(A::AbstractMatrix, adjQ::AdjointQ{<:Any,<:QRPackedQ})
+function rmul!(A::AbstractVecOrMat, adjQ::AdjointQ{<:Any,<:QRPackedQ})
  require_one_based_indexing(A)
  Q = adjQ.Q
  mQ, nQ = size(Q.factors)
@@ -459,42 +505,12 @@ lmul!(adjQ::AdjointQ{<:Any,<:HessenbergQ{T}}, X::Adjoint{T,<:StridedVecOrMat{T}}
 rmul!(X::Adjoint{T,<:StridedVecOrMat{T}}, adjQ::AdjointQ{<:Any,<:HessenbergQ{T}}) where {T} = lmul!(adjQ', X')'
 
 # flexible left-multiplication (and adjoint right-multiplication)
-function (*)(Q::Union{QRPackedQ,QRCompactWYQ,HessenbergQ}, b::AbstractVector)
- T = promote_type(eltype(Q), eltype(b))
- if size(Q.factors, 1) == length(b)
- bnew = copy_similar(b, T)
- elseif size(Q.factors, 2) == length(b)
- bnew = [b; zeros(T, size(Q.factors, 1) - length(b))]
- else
- throw(DimensionMismatch("vector must have length either $(size(Q.factors, 1)) or $(size(Q.factors, 2))"))
- end
- lmul!(convert(AbstractQ{T}, Q), bnew)
-end
-function (*)(Q::Union{QRPackedQ,QRCompactWYQ,HessenbergQ}, B::AbstractMatrix)
- T = promote_type(eltype(Q), eltype(B))
- if size(Q.factors, 1) == size(B, 1)
- Bnew = copy_similar(B, T)
- elseif size(Q.factors, 2) == size(B, 1)
- Bnew = [B; zeros(T, size(Q.factors, 1) - size(B,1), size(B, 2))]
- else
- throw(DimensionMismatch("first dimension of matrix must have size either $(size(Q.factors, 1)) or $(size(Q.factors, 2))"))
- end
- lmul!(convert(AbstractQ{T}, Q), Bnew)
-end
-function (*)(A::AbstractMatrix, adjQ::AdjointQ{<:Any,<:Union{QRPackedQ,QRCompactWYQ,HessenbergQ}})
- Q = adjQ.Q
- T = promote_type(eltype(A), eltype(adjQ))
- adjQQ = convert(AbstractQ{T}, adjQ)
- if size(A, 2) == size(Q.factors, 1)
- AA = copy_similar(A, T)
- return rmul!(AA, adjQQ)
- elseif size(A, 2) == size(Q.factors, 2)
- return rmul!([A zeros(T, size(A, 1), size(Q.factors, 1) - size(Q.factors, 2))], adjQQ)
- else
- throw(DimensionMismatch("matrix A has dimensions $(size(A)) but Q-matrix B has dimensions $(size(adjQ))"))
- end
-end
-(*)(u::AdjointAbsVec, Q::AdjointQ{<:Any,<:Union{QRPackedQ,QRCompactWYQ,HessenbergQ}}) = (Q'u')'
+qsize_check(Q::Union{QRPackedQ,QRCompactWYQ,HessenbergQ}, B::AbstractVecOrMat) =
+ size(B, 1) in size(Q.factors) ||
+ throw(DimensionMismatch("first dimension of B, $(size(B,1)), must equal one of the dimensions of Q, $(size(Q.factors))"))
+qsize_check(A::AbstractVecOrMat, adjQ::AdjointQ{<:Any,<:Union{QRPackedQ,QRCompactWYQ,HessenbergQ}}) =
+ (Q = adjQ.Q; size(A, 2) in size(Q.factors) ||
+ throw(DimensionMismatch("second dimension of A, $(size(A,2)), must equal one of the dimensions of Q, $(size(Q.factors))")))
 
 det(Q::HessenbergQ) = _det_tau(Q.τ)
 
@@ -518,104 +534,41 @@ convert(::Type{AbstractQ{T}}, Q::LQPackedQ) where {T} = LQPackedQ{T}(Q)
 size(Q::LQPackedQ) = (n = size(Q.factors, 2); return n, n)
 
 ## Multiplication
-### QB / QcB
-lmul!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = LAPACK.ormlq!('L','N',A.factors,A.τ,B)
-lmul!(adjA::AdjointQ{<:Any,<:LQPackedQ{T}}, B::StridedVecOrMat{T}) where {T<:BlasReal} =
- (A = adjA.Q; LAPACK.ormlq!('L', 'T', A.factors, A.τ, B))
-lmul!(adjA::AdjointQ{<:Any,<:LQPackedQ{T}}, B::StridedVecOrMat{T}) where {T<:BlasComplex} =
- (A = adjA.Q; LAPACK.ormlq!('L', 'C', A.factors, A.τ, B))
+# out-of-place right application of LQPackedQs
+#
+# these methods: (1) check whether the applied-to matrix's (A's) appropriate dimension
+# (columns for A_*, rows for Ac_*) matches the number of columns (nQ) of the LQPackedQ (Q),
+# and if so effectively apply Q's square form to A without additional shenanigans; and
+# (2) if the preceding dimensions do not match, check whether the appropriate dimension of
+# A instead matches the number of rows of the matrix of which Q is a factor (i.e.
+# size(Q.factors, 1)), and if so implicitly apply Q's truncated form to A by zero extending
+# A as necessary for check (1) to pass (if possible) and then applying Q's square form
 
-function (*)(adjA::AdjointQ{<:Any,<:LQPackedQ}, B::AbstractVector)
- A = adjA.Q
- T = promote_type(eltype(A), eltype(B))
- if length(B) == size(A.factors, 2)
- C = copy_similar(B, T)
- elseif length(B) == size(A.factors, 1)
- C = [B; zeros(T, size(A.factors, 2) - size(A.factors, 1), size(B, 2))]
- else
- throw(DimensionMismatch("length of B, $(length(B)), must equal one of the dimensions of A, $(size(A))"))
- end
- lmul!(convert(AbstractQ{T}, adjA), C)
-end
-function (*)(adjA::AdjointQ{<:Any,<:LQPackedQ}, B::AbstractMatrix)
- A = adjA.Q
- T = promote_type(eltype(A), eltype(B))
- if size(B,1) == size(A.factors,2)
- C = copy_similar(B, T)
- elseif size(B,1) == size(A.factors,1)
- C = [B; zeros(T, size(A.factors, 2) - size(A.factors, 1), size(B, 2))]
- else
- throw(DimensionMismatch("first dimension of B, $(size(B,1)), must equal one of the dimensions of A, $(size(A))"))
- end
- lmul!(convert(AbstractQ{T}, adjA), C)
-end
+qsize_check(adjQ::AdjointQ{<:Any,<:LQPackedQ}, B::AbstractVecOrMat) =
+ size(B, 1) in size(adjQ.Q.factors) ||
+ throw(DimensionMismatch("first dimension of B, $(size(B,1)), must equal one of the dimensions of Q, $(size(adjQ.Q.factors))"))
+qsize_check(A::AbstractVecOrMat, Q::LQPackedQ) =
+ size(A, 2) in size(Q.factors) ||
+ throw(DimensionMismatch("second dimension of A, $(size(A,2)), must equal one of the dimensions of Q, $(size(Q.factors))"))
 
 # in-place right-application of LQPackedQs
 # these methods require that the applied-to matrix's (A's) number of columns
 # match the number of columns (nQ) of the LQPackedQ (Q) (necessary for in-place
 # operation, and the underlying LAPACK routine (ormlq) treats the implicit Q
 # as its (nQ-by-nQ) square form)
-rmul!(A::StridedMatrix{T}, B::LQPackedQ{T}) where {T<:BlasFloat} =
+rmul!(A::StridedVecOrMat{T}, B::LQPackedQ{T}) where {T<:BlasFloat} =
  LAPACK.ormlq!('R', 'N', B.factors, B.τ, A)
-rmul!(A::StridedMatrix{T}, adjB::AdjointQ{<:Any,<:LQPackedQ{T}}) where {T<:BlasReal} =
+rmul!(A::StridedVecOrMat{T}, adjB::AdjointQ{<:Any,<:LQPackedQ{T}}) where {T<:BlasReal} =
  (B = adjB.Q; LAPACK.ormlq!('R', 'T', B.factors, B.τ, A))
-rmul!(A::StridedMatrix{T}, adjB::AdjointQ{<:Any,<:LQPackedQ{T}}) where {T<:BlasComplex} =
+rmul!(A::StridedVecOrMat{T}, adjB::AdjointQ{<:Any,<:LQPackedQ{T}}) where {T<:BlasComplex} =
  (B = adjB.Q; LAPACK.ormlq!('R', 'C', B.factors, B.τ, A))
 
-# out-of-place right application of LQPackedQs
-#
-# these methods: (1) check whether the applied-to matrix's (A's) appropriate dimension
-# (columns for A_*, rows for Ac_*) matches the number of columns (nQ) of the LQPackedQ (Q),
-# and if so effectively apply Q's square form to A without additional shenanigans; and
-# (2) if the preceding dimensions do not match, check whether the appropriate dimension of
-# A instead matches the number of rows of the matrix of which Q is a factor (i.e.
-# size(Q.factors, 1)), and if so implicitly apply Q's truncated form to A by zero extending
-# A as necessary for check (1) to pass (if possible) and then applying Q's square form
-#
-function (*)(A::AbstractVector, Q::LQPackedQ)
- T = promote_type(eltype(A), eltype(Q))
- if 1 == size(Q.factors, 2)
- C = copy_similar(A, T)
- elseif 1 == size(Q.factors, 1)
- C = zeros(T, length(A), size(Q.factors, 2))
- copyto!(C, 1, A, 1, length(A))
- else
- _rightappdimmismatch("columns")
- end
- return rmul!(C, convert(AbstractQ{T}, Q))
-end
-function (*)(A::AbstractMatrix, Q::LQPackedQ)
- T = promote_type(eltype(A), eltype(Q))
- if size(A, 2) == size(Q.factors, 2)
- C = copy_similar(A, T)
- elseif size(A, 2) == size(Q.factors, 1)
- C = zeros(T, size(A, 1), size(Q.factors, 2))
- copyto!(C, 1, A, 1, length(A))
- else
- _rightappdimmismatch("columns")
- end
- return rmul!(C, convert(AbstractQ{T}, Q))
-end
-function (*)(adjA::AdjointAbsMat, Q::LQPackedQ)
- A = adjA.parent
- T = promote_type(eltype(A), eltype(Q))
- if size(A, 1) == size(Q.factors, 2)
- C = copy_similar(adjA, T)
- elseif size(A, 1) == size(Q.factors, 1)
- C = zeros(T, size(A, 2), size(Q.factors, 2))
- adjoint!(view(C, :, 1:size(A, 1)), A)
- else
- _rightappdimmismatch("rows")
- end
- return rmul!(C, convert(AbstractQ{T}, Q))
-end
-(*)(u::AdjointAbsVec, Q::LQPackedQ) = (Q'u')'
-
-_rightappdimmismatch(rowsorcols) =
- throw(DimensionMismatch(string("the number of $(rowsorcols) of the matrix on the left ",
- "must match either (1) the number of columns of the (LQPackedQ) matrix on the right ",
- "or (2) the number of rows of that (LQPackedQ) matrix's internal representation ",
- "(the factorization's originating matrix's number of rows)")))
+### QB / QcB
+lmul!(A::LQPackedQ{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} = LAPACK.ormlq!('L','N',A.factors,A.τ,B)
+lmul!(adjA::AdjointQ{<:Any,<:LQPackedQ{T}}, B::StridedVecOrMat{T}) where {T<:BlasReal} =
+ (A = adjA.Q; LAPACK.ormlq!('L', 'T', A.factors, A.τ, B))
+lmul!(adjA::AdjointQ{<:Any,<:LQPackedQ{T}}, B::StridedVecOrMat{T}) where {T<:BlasComplex} =
+ (A = adjA.Q; LAPACK.ormlq!('L', 'C', A.factors, A.τ, B))
 
 # In LQ factorization, `Q` is expressed as the product of the adjoint of the
 # reflectors. Thus, `det` has to be conjugated.

stdlib/LinearAlgebra/src/hessenberg.jl

@@ -449,8 +449,7 @@ julia> A = [4. 9. 7.; 4. 4. 1.; 4. 3. 2.]
 
 julia> F = hessenberg(A)
 Hessenberg{Float64, UpperHessenberg{Float64, Matrix{Float64}}, Matrix{Float64}, Vector{Float64}, Bool}
-Q factor:
-3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
+Q factor: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
 H factor:
 3×3 UpperHessenberg{Float64, Matrix{Float64}}:
  4.0 -11.3137 -1.41421
@@ -477,7 +476,7 @@ function show(io::IO, mime::MIME"text/plain", F::Hessenberg)
  if !iszero(F.μ)
  print("\nwith shift μI for μ = ", F.μ)
  end
- println(io, "\nQ factor:")
+ print(io, "\nQ factor: ")
  show(io, mime, F.Q)
  println(io, "\nH factor:")
  show(io, mime, F.H)

stdlib/LinearAlgebra/src/lq.jl

@@ -27,8 +27,7 @@ L factor:
 2×2 Matrix{Float64}:
  -8.60233 0.0
  4.41741 -0.697486
-Q factor:
-2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}
+Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}
 
 julia> S.L * S.Q
 2×2 Matrix{Float64}:
@@ -97,8 +96,7 @@ L factor:
 2×2 Matrix{Float64}:
  -8.60233 0.0
  4.41741 -0.697486
-Q factor:
-2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}
+Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}
 
 julia> S.L * S.Q
 2×2 Matrix{Float64}:
@@ -154,7 +152,7 @@ function show(io::IO, mime::MIME{Symbol("text/plain")}, F::LQ)
  summary(io, F); println(io)
  println(io, "L factor:")
  show(io, mime, F.L)
- println(io, "\nQ factor:")
+ print(io, "\nQ factor: ")
  show(io, mime, F.Q)
 end