Defaults for Banded Matrices

Project.toml

@@ -1,7 +1,7 @@
 name = "LinearSolve"
 uuid = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae"
 authors = ["SciML"]
-version = "2.10.0"
+version = "2.11.0"
 
 [deps]
 ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
@@ -31,6 +31,7 @@ SuiteSparse = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
 UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
 
 [weakdeps]
+BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
 BlockDiagonals = "0a1fb500-61f7-11e9-3c65-f5ef3456f9f0"
 Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9"
 CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
@@ -42,6 +43,7 @@ Metal = "dde4c033-4e86-420c-a63e-0dd931031962"
 Pardiso = "46dd5b70-b6fb-5a00-ae2d-e8fea33afaf2"
 
 [extensions]
+LinearSolveBandedMatricesExt = "BandedMatrices"
 LinearSolveBlockDiagonalsExt = "BlockDiagonals"
 LinearSolveCUDAExt = "CUDA"
 LinearSolveEnzymeExt = "Enzyme"
@@ -54,6 +56,7 @@ LinearSolvePardisoExt = "Pardiso"
 
 [compat]
 ArrayInterface = "7.4.11"
+BandedMatrices = "1"
 BlockDiagonals = "0.1"
 ConcreteStructs = "0.2"
 DocStringExtensions = "0.8, 0.9"

ext/LinearSolveBandedMatricesExt.jl

@@ -0,0 +1,21 @@
+module LinearSolveBandedMatricesExt
+
+using BandedMatrices, LinearAlgebra, LinearSolve
+import LinearSolve: defaultalg, do_factorization, init_cacheval, DefaultLinearSolver,
+    DefaultAlgorithmChoice
+
+# Defaults for BandedMatrices
+function defaultalg(A::BandedMatrix, b, ::OperatorAssumptions)
+    return QRFactorization()
+    # return DefaultLinearSolver(DefaultAlgorithmChoice.QRFactorization)
+end
+
+function defaultalg(A::Symmetric{<:Number, <:BandedMatrix}, b, ::OperatorAssumptions)
+    return CholeskyFactorization()
+    # return DefaultLinearSolver(DefaultAlgorithmChoice.CholeskyFactorization)
+end
+
+# BandedMatrices `qr` doesn't allow other args without causing an ambiguity
+do_factorization(alg::QRFactorization, A::BandedMatrix, b, u) = alg.inplace ? qr!(A) : qr(A)
+
+end

src/common.jl

@@ -14,7 +14,7 @@ However, in practice this computation is very expensive and thus not possible fo
 Therefore, OperatorCondition lets one share to LinearSolve the expected conditioning. The higher the
 expected condition number, the safer the algorithm needs to be and thus there is a trade-off between
 numerical performance and stability. By default the method assumes the operator may be ill-conditioned
-for the standard linear solvers to converge (such as LU-factorization), though more extreme 
+for the standard linear solvers to converge (such as LU-factorization), though more extreme
 ill-conditioning or well-conditioning could be the case and specified through this assumption.
 """
 EnumX.@enumx OperatorCondition begin

src/default.jl

@@ -163,7 +163,7 @@ function defaultalg(A, b, assump::OperatorAssumptions)
                     DefaultAlgorithmChoice.GenericLUFactorization
                 elseif VERSION >= v"1.8" && appleaccelerate_isavailable()
                     DefaultAlgorithmChoice.AppleAccelerateLUFactorization
-                elseif (length(b) <= 100 || (isopenblas() && length(b) <= 500) || 
+                elseif (length(b) <= 100 || (isopenblas() && length(b) <= 500) ||
                        (usemkl && length(b) <= 200)) &&
                        (A === nothing ? eltype(b) <: Union{Float32, Float64} :
                         eltype(A) <: Union{Float32, Float64})