Fix lu/qr pivot deprecations and allow PivotingStrategy input (#1002)

* Remove deprecation due to lu pivot choice change in v1.7

`lu` on larger static arrays now hits a deprecation in Base.

* fix `Val` deprecations for `lu` & `qr` and allow new `PivotingStrategy` inputs

* fix a test warning

Co-authored-by: Christopher Rackauckas <Contact@ChrisRackauckas.com>

Author: thchr

src/lu.jl

@@ -30,16 +30,21 @@ function Base.show(io::IO, mime::MIME{Symbol("text/plain")}, F::LU)
 end
 
 # LU decomposition
-for pv in (:true, :false)
+pivot_options = if isdefined(LinearAlgebra, :PivotingStrategy) # introduced in Julia v1.7
+    (:(Val{true}), :(Val{false}), :NoPivot, :RowMaximum)
+else
+    (:(Val{true}), :(Val{false}))
+end
+for pv in pivot_options
     # ... define each `pivot::Val{true/false}` method individually to avoid ambiguties
-    @eval function lu(A::StaticMatrix, pivot::Val{$pv}; check = true)
+    @eval function lu(A::StaticMatrix, pivot::$pv; check = true)
         L, U, p = _lu(A, pivot, check)
         LU(L, U, p)
     end
 
     # For the square version, return explicit lower and upper triangular matrices.
     # We would do this for the rectangular case too, but Base doesn't support that.
-    @eval function lu(A::StaticMatrix{N,N}, pivot::Val{$pv}; check = true) where {N}
+    @eval function lu(A::StaticMatrix{N,N}, pivot::$pv; check = true) where {N}
         L, U, p = _lu(A, pivot, check)
         LU(LowerTriangular(L), UpperTriangular(U), p)
     end
@@ -69,18 +74,28 @@ issuccess(F::LU) = _first_zero_on_diagonal(F.U) == 0
 
 @generated function _lu(A::StaticMatrix{M,N,T}, pivot, check) where {M,N,T}
     if M*N ≤ 14*14
+        _pivot = if isdefined(LinearAlgebra, :PivotingStrategy) # v1.7 feature
+            pivot === RowMaximum ? Val(true) : pivot === NoPivot ? Val(false) : pivot()
+        else
+            pivot()
+        end
         quote
-            L, U, P = __lu(A, pivot)
+            L, U, P = __lu(A, $(_pivot))
             if check
                 i = _first_zero_on_diagonal(U)
                 i == 0 || throw(SingularException(i))
             end
             L, U, P
         end
     else
+        _pivot = if isdefined(LinearAlgebra, :PivotingStrategy) # v1.7 feature
+            pivot === Val{true} ? RowMaximum() : pivot === Val{false} ? NoPivot() : pivot()
+        else
+            pivot()
+        end
         quote
             # call through to Base to avoid excessive time spent on type inference for large matrices
-            f = lu(Matrix(A), pivot; check = check)
+            f = lu(Matrix(A), $(_pivot); check = check)
             # Trick to get the output eltype - can't rely on the result of f.L as
             # it's not type inferrable.
             T2 = arithmetic_closure(T)

src/qr.jl

@@ -11,9 +11,14 @@ Base.iterate(S::QR, ::Val{:R}) = (S.R, Val(:p))
 Base.iterate(S::QR, ::Val{:p}) = (S.p, Val(:done))
 Base.iterate(S::QR, ::Val{:done}) = nothing
 
-for pv in (:true, :false)
+pivot_options = if isdefined(LinearAlgebra, :PivotingStrategy) # introduced in Julia v1.7
+    (:(Val{true}), :(Val{false}), :NoPivot, :ColumnNorm)
+else
+    (:(Val{true}), :(Val{false}))
+end
+for pv in pivot_options
     @eval begin
-        @inline function qr(A::StaticMatrix, pivot::Val{$pv})
+        @inline function qr(A::StaticMatrix, pivot::$pv)
             QRp = _qr(Size(A), A, pivot)
             if length(QRp) === 2
                 # create an identity permutation since that is cheap,
@@ -28,7 +33,8 @@ for pv in (:true, :false)
     end
 end
 """
-    qr(A::StaticMatrix, pivot::Union{Val{true}, Val{false}} = Val(false))
+    qr(A::StaticMatrix,
+       pivot::Union{Val{true}, Val{false}, LinearAlgebra.PivotingStrategy} = Val(false))
 
 Compute the QR factorization of `A`. The factors can be obtained by iteration:
 
@@ -58,16 +64,17 @@ end
 
 _qreltype(::Type{T}) where T = typeof(zero(T)/sqrt(abs2(one(T))))
 
-
-@generated function _qr(::Size{sA}, A::StaticMatrix{<:Any, <:Any, TA}, pivot::Union{Val{false}, Val{true}} = Val(false)) where {sA, TA}
+@generated function _qr(::Size{sA}, A::StaticMatrix{<:Any, <:Any, TA},
+                        pivot = Val(false)) where {sA, TA}
 
     SizeQ = Size( sA[1], diagsize(Size(A)) )
     SizeR = Size( diagsize(Size(A)), sA[2] )
 
-    if pivot === Val{true}
+    if pivot === Val{true} || (isdefined(LinearAlgebra, :PivotingStrategy) && pivot === ColumnNorm)
+        _pivot = isdefined(LinearAlgebra, :PivotingStrategy) ? ColumnNorm() : Val(true)
         return quote
             @_inline_meta
-            Q0, R0, p0 = qr(Matrix(A), pivot)
+            Q0, R0, p0 = qr(Matrix(A), $(_pivot))
             T = _qreltype(TA)
             return similar_type(A, T, $(SizeQ))(Matrix(Q0)),
                    similar_type(A, T, $(SizeR))(R0),
@@ -77,12 +84,13 @@ _qreltype(::Type{T}) where T = typeof(zero(T)/sqrt(abs2(one(T))))
         if (sA[1]*sA[1] + sA[1]*sA[2])÷2 * diagsize(Size(A)) < 17*17*17
             return quote
                 @_inline_meta
-                return qr_unrolled(Size(A), A, pivot)
+                return qr_unrolled(Size(A), A, Val(false))
             end
         else
+            _pivot = isdefined(LinearAlgebra, :PivotingStrategy) ? NoPivot() : Val(false)
             return quote
                 @_inline_meta
-                Q0R0 = qr(Matrix(A), pivot)
+                Q0R0 = qr(Matrix(A), $(_pivot))
                 Q0, R0 = Matrix(Q0R0.Q), Q0R0.R
                 T = _qreltype(TA)
                 return similar_type(A, T, $(SizeQ))(Q0),

test/lu.jl

@@ -79,4 +79,12 @@ end
     end
 end
 
+if isdefined(LinearAlgebra, :PivotingStrategy)
+    for N = (3, 15)
+        A = (@SMatrix randn(N,N))
+        @test lu(A, Val(false)) == lu(A, NoPivot())
+        @test lu(A, Val(true)) == lu(A, RowMaximum())
+    end
+end
+
 end # @testset "LU"

test/qr.jl

@@ -27,7 +27,7 @@ Random.seed!(42)
 
         # pivot=true cases has no StaticArrays specific version yet
         # but fallbacks to LAPACK
-        pivot = Val(true)
+        pivot = isdefined(LinearAlgebra, :PivotingStrategy) ? ColumnNorm() : Val(true)
         QRp = @inferred qr(arr, pivot)
         @test QRp isa StaticArrays.QR
         Q, R, p = QRp
@@ -59,6 +59,14 @@ Random.seed!(42)
                ]
         test_qr(arr)
     end
+
+    if isdefined(LinearAlgebra, :PivotingStrategy)
+        for N = (3, 18)
+            A = (@SMatrix randn(N,N))
+            @test qr(A, Val(false)) == qr(A, NoPivot())
+            @test qr(A, Val(true)) == qr(A, ColumnNorm())
+        end
+    end
 end
 
 @testset "QR method ambiguity" begin