_ql -> ql_layout and add reversecholesky_layout (#63)

* _ql -> ql_layout and add reversecholesky_layout

* Update reversecholesky.jl

* Update reversecholesky.jl

* ul_layout

* v2.2

Author: dlfivefifty

Project.toml

@@ -1,6 +1,6 @@
 name = "MatrixFactorizations"
 uuid = "a3b82374-2e81-5b9e-98ce-41277c0e4c87"
-version = "2.1.3"
+version = "2.2"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"

src/ql.jl

@@ -72,7 +72,6 @@ end
 @inline qlfactUnblocked!(A::StridedMatrix{T}) where T<:BlasFloat = QL(LAPACK.geqlf!(A)...)
 
 
-
 # Generic fallbacks
 
 """
@@ -112,10 +111,10 @@ Stacktrace:
 [...]
 ```
 """
-@inline _ql!(layout, axes, A, ::Val{false}) = qlfactUnblocked!(A)
-@inline _ql!(layout, axes, A) = ql!(A, Val(false))
-@inline ql!(A::AbstractMatrix; kwds...) = _ql!(MemoryLayout(typeof(A)), axes(A), A; kwds...)
-@inline ql!(A::AbstractMatrix, val; kwds...) = _ql!(MemoryLayout(typeof(A)), axes(A), A, val; kwds...)
+@inline ql_layout!(layout, axes, A, ::Val{false}) = qlfactUnblocked!(A)
+@inline ql_layout!(layout, axes, A) = ql!(A, Val(false))
+@inline ql!(A::AbstractMatrix; kwds...) = ql_layout!(MemoryLayout(typeof(A)), axes(A), A; kwds...)
+@inline ql!(A::AbstractMatrix, val; kwds...) = ql_layout!(MemoryLayout(typeof(A)), axes(A), A, val; kwds...)
 
 @inline _qleltype(::Type{T}) where T = typeof(zero(T)/sqrt(abs2(one(T))))
 
@@ -177,9 +176,9 @@ julia> F.Q * F.L == A
 true
 ```
 """
-@inline ql(A::AbstractMatrix, args...; kwds...) = _ql(MemoryLayout(typeof(A)), axes(A), A, args...; kwds...)
+@inline ql(A::AbstractMatrix, args...; kwds...) = ql_layout(MemoryLayout(typeof(A)), axes(A), A, args...; kwds...)
 
-function _ql(layout, axes, A, args...; kwds...)
+function ql_layout(layout, axes, A, args...; kwds...)
     require_one_based_indexing(A)
     AA = similar(A, _qleltype(eltype(A)), size(A))
     copyto!(AA, A)
@@ -191,6 +190,10 @@ end
     ql(reshape(v, (length(v), 1)), args...; kwds...)
 end
 
+# for backward compatability
+const _ql! = ql_layout!
+const _ql = ql_layout
+
 # Conversions
 QL{T}(A::QL) where {T} = QL(convert(AbstractMatrix{T}, A.factors), convert(AbstractVector{T}, A.τ))
 Factorization{T}(A::QL{T}) where {T} = A

src/reversecholesky.jl

@@ -39,7 +39,7 @@ Base.iterate(C::ReverseCholesky, ::Val{:U}) = (C.L, Val(:done))
 Base.iterate(C::ReverseCholesky, ::Val{:done}) = nothing
 
 ## Non BLAS/LAPACK element types (generic)
-function _reverse_chol!(A::AbstractMatrix, ::Type{UpperTriangular})
+function reversecholesky_layout!(_, A::AbstractMatrix, ::Type{UpperTriangular})
     require_one_based_indexing(A)
     n = checksquare(A)
     realdiag = eltype(A) <: Complex
@@ -52,7 +52,7 @@ function _reverse_chol!(A::AbstractMatrix, ::Type{UpperTriangular})
                 Akk -= realdiag ? abs2(A[k,j]) : A[k,j]'A[k,j]
             end
             A[k,k] = Akk
-            Akk, info = _reverse_chol!(Akk, UpperTriangular)
+            Akk, info = reversecholesky_layout!(MemoryLayout(Akk), Akk, UpperTriangular)
             if info != 0
                 return UpperTriangular(A), info
             end
@@ -72,7 +72,7 @@ function _reverse_chol!(A::AbstractMatrix, ::Type{UpperTriangular})
     return UpperTriangular(A), convert(BlasInt, 0)
 end
 
-function _reverse_chol!(A::AbstractMatrix, ::Type{LowerTriangular})
+function reversecholesky_layout!(_, A::AbstractMatrix, ::Type{LowerTriangular})
     require_one_based_indexing(A)
     n = checksquare(A)
     realdiag = eltype(A) <: Complex
@@ -85,7 +85,7 @@ function _reverse_chol!(A::AbstractMatrix, ::Type{LowerTriangular})
                 Akk -= realdiag ? abs2(A[i,k]) : A[i,k]'A[i,k]
             end
             A[k,k] = Akk
-            Akk, info = _reverse_chol!(Akk, LowerTriangular)
+            Akk, info = reversecholesky_layout!(MemoryLayout(Akk), Akk, LowerTriangular)
             if info != 0
                 return LowerTriangular(A), info
             end
@@ -103,15 +103,15 @@ function _reverse_chol!(A::AbstractMatrix, ::Type{LowerTriangular})
 end
 
 ## Numbers
-_reverse_chol!(x::Number, uplo) = LinearAlgebra._chol!(x, uplo)
+reversecholesky_layout!(_, x::Number, uplo) = LinearAlgebra._chol!(x, uplo)
 
 ## for StridedMatrices, check that matrix is symmetric/Hermitian
 
 # cholesky!. Destructive methods for computing Cholesky factorization of real symmetric
 # or Hermitian matrix
 ## No pivoting (default)
 function reversecholesky!(A::RealHermSymComplexHerm, ::NoPivot = NoPivot(); check::Bool = true)
-    C, info = _reverse_chol!(A.data, A.uplo == 'U' ? UpperTriangular : LowerTriangular)
+    C, info = reversecholesky_layout!(MemoryLayout(A.data), A.data, A.uplo == 'U' ? UpperTriangular : LowerTriangular)
     check && checkpositivedefinite(info)
     return ReverseCholesky(C.data, A.uplo, info)
 end
@@ -174,8 +174,10 @@ and return a [`ReverseCholesky`](@ref) factorization. The matrix `A` can either
 The triangular ReverseCholesky factor can be obtained from the factorization `F` via `F.L` and `F.U`,
 where `A ≈ F.U * F.U' ≈ F.L' * F.L`.
 """
-reversecholesky(A::AbstractMatrix, ::NoPivot=NoPivot(); check::Bool = true) =
-    reversecholesky!(reversecholcopy(A); check)
+reversecholesky(A::AbstractMatrix, piv::NoPivot=NoPivot(); check::Bool = true) =
+    reversecholesky_layout(MemoryLayout(A), axes(A), A, piv; check)
+
+reversecholesky_layout(lay, ax, A, piv; kwds...) = reversecholesky!(reversecholcopy(A); kwds...)
 
 function reversecholesky(A::AbstractMatrix{Float16}, ::NoPivot=NoPivot(); check::Bool = true)
     X = reversecholesky!(reversecholcopy(A); check = check)
@@ -185,11 +187,12 @@ end
 
 ## Number
 function reversecholesky(x::Number, uplo::Symbol=:U)
-    C, info = _reverse_chol!(x, uplo)
+    C, info = reversecholesky_layout!(MemoryLayout(x), x, uplo)
     xf = fill(C, 1, 1)
     ReverseCholesky(xf, uplo, info)
 end
 
+_reverse_chol!(A, T) = reversecholesky_layout!(MemoryLayout(A), A, T)
 
 function ReverseCholesky{T}(C::ReverseCholesky) where T
     Cnew = convert(AbstractMatrix{T}, C.factors)

src/ul.jl

@@ -283,12 +283,14 @@ julia> l == F.L && u == F.U && p == F.p
 true
 ```
 """
-function _ul(layout, A::AbstractMatrix{T}, pivot::Union{Val{false}, Val{true}}=Val(true);
+function ul_layout(layout, A::AbstractMatrix{T}, pivot::Union{Val{false}, Val{true}}=Val(true);
             check::Bool = true) where T
     S = ultype(T)
     ul!(copy_oftype(A, S), pivot; check = check)
 end
 
+const _ul = ul_layout
+
 ul(A::AbstractMatrix{T}, pivot::Union{Val{false}, Val{true}}=Val(true); check::Bool = true) where T = 
     _ul(MemoryLayout(A), A, pivot; check=check)