Merge branch 'main' into abstractsparse

Author: j-fu

Project.toml

@@ -1,10 +1,10 @@
 name = "LinearSolve"
 uuid = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae"
 authors = ["SciML"]
-version = "1.35.0"
+version = "1.36.0"
 
 [deps]
-ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
+ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
 FastLapackInterface = "29a986be-02c6-4525-aec4-84b980013641"
 GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"
@@ -32,7 +32,7 @@ HYPRE = "b5ffcf37-a2bd-41ab-a3da-4bd9bc8ad771"
 LinearSolveHYPRE = "HYPRE"
 
 [compat]
-ArrayInterfaceCore = "0.1.1"
+ArrayInterface = "6, 7"
 DocStringExtensions = "0.8, 0.9"
 FastLapackInterface = "1"
 GPUArraysCore = "0.1"

docs/src/advanced/developing.md

@@ -46,7 +46,7 @@ is what is called at `init` time to create the first `cacheval`. Note that this
 should match the type of the cache later used in `solve` as many algorithms, like
 those in OrdinaryDiffEq.jl, expect type-groundedness in the linear solver definitions.
 While there are cheaper ways to obtain this type for LU factorizations (specifically,
-`ArrayInterfaceCore.lu_instance(A)`), for a demonstration, this just performs an
+`ArrayInterface.lu_instance(A)`), for a demonstration, this just performs an
 LU-factorization to get an `LU{T, Matrix{T}}` which it puts into the `cacheval`
 so it is typed for future use.
 

src/LinearSolve.jl

@@ -3,7 +3,7 @@ if isdefined(Base, :Experimental) &&
    isdefined(Base.Experimental, Symbol("@max_methods"))
     @eval Base.Experimental.@max_methods 1
 end
-using ArrayInterfaceCore
+using ArrayInterface
 using RecursiveFactorization
 using Base: cache_dependencies, Bool
 using LinearAlgebra

src/default.jl

@@ -142,7 +142,7 @@ function defaultalg(A, b, ::OperatorAssumptions{true})
     # whether MKL or OpenBLAS is being used
     if (A === nothing && !(b isa GPUArraysCore.AbstractGPUArray)) || A isa Matrix
         if (A === nothing || eltype(A) <: Union{Float32, Float64, ComplexF32, ComplexF64}) &&
-           ArrayInterfaceCore.can_setindex(b)
+           ArrayInterface.can_setindex(b)
             if length(b) <= 10
                 alg = GenericLUFactorization()
             elseif (length(b) <= 100 || (isopenblas() && length(b) <= 500)) &&
@@ -160,7 +160,7 @@ function defaultalg(A, b, ::OperatorAssumptions{true})
 
         # This catches the cases where a factorization overload could exist
         # For example, BlockBandedMatrix
-    elseif A !== nothing && ArrayInterfaceCore.isstructured(A)
+    elseif A !== nothing && ArrayInterface.isstructured(A)
         alg = GenericFactorization()
 
         # Not factorizable operator, default to only using A*x

src/factorization.jl

@@ -69,7 +69,7 @@ end
 function init_cacheval(alg::Union{LUFactorization, GenericLUFactorization}, A, b, u, Pl, Pr,
                        maxiters::Int, abstol, reltol, verbose::Bool,
                        assumptions::OperatorAssumptions)
-    ArrayInterfaceCore.lu_instance(convert(AbstractMatrix, A))
+    ArrayInterface.lu_instance(convert(AbstractMatrix, A))
 end
 
 ## QRFactorization
@@ -131,25 +131,25 @@ end
 function init_cacheval(alg::GenericFactorization{typeof(lu)}, A, b, u, Pl, Pr,
                        maxiters::Int,
                        abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
-    ArrayInterfaceCore.lu_instance(convert(AbstractMatrix, A))
+    ArrayInterface.lu_instance(convert(AbstractMatrix, A))
 end
 function init_cacheval(alg::GenericFactorization{typeof(lu!)}, A, b, u, Pl, Pr,
                        maxiters::Int,
                        abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
-    ArrayInterfaceCore.lu_instance(convert(AbstractMatrix, A))
+    ArrayInterface.lu_instance(convert(AbstractMatrix, A))
 end
 
 function init_cacheval(alg::GenericFactorization{typeof(lu)},
                        A::StridedMatrix{<:LinearAlgebra.BlasFloat}, b, u, Pl, Pr,
                        maxiters::Int,
                        abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
-    ArrayInterfaceCore.lu_instance(A)
+    ArrayInterface.lu_instance(A)
 end
 function init_cacheval(alg::GenericFactorization{typeof(lu!)},
                        A::StridedMatrix{<:LinearAlgebra.BlasFloat}, b, u, Pl, Pr,
                        maxiters::Int,
                        abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
-    ArrayInterfaceCore.lu_instance(A)
+    ArrayInterface.lu_instance(A)
 end
 function init_cacheval(alg::GenericFactorization{typeof(lu)}, A::Diagonal, b, u, Pl, Pr,
                        maxiters::Int, abstol, reltol, verbose::Bool,
@@ -159,7 +159,7 @@ end
 function init_cacheval(alg::GenericFactorization{typeof(lu)}, A::Tridiagonal, b, u, Pl, Pr,
                        maxiters::Int, abstol, reltol, verbose::Bool,
                        assumptions::OperatorAssumptions)
-    ArrayInterfaceCore.lu_instance(A)
+    ArrayInterface.lu_instance(A)
 end
 function init_cacheval(alg::GenericFactorization{typeof(lu!)}, A::Diagonal, b, u, Pl, Pr,
                        maxiters::Int, abstol, reltol, verbose::Bool,
@@ -169,7 +169,7 @@ end
 function init_cacheval(alg::GenericFactorization{typeof(lu!)}, A::Tridiagonal, b, u, Pl, Pr,
                        maxiters::Int, abstol, reltol, verbose::Bool,
                        assumptions::OperatorAssumptions)
-    ArrayInterfaceCore.lu_instance(A)
+    ArrayInterface.lu_instance(A)
 end
 
 function init_cacheval(alg::GenericFactorization, A::Diagonal, b, u, Pl, Pr, maxiters::Int,
@@ -179,7 +179,7 @@ end
 function init_cacheval(alg::GenericFactorization, A::Tridiagonal, b, u, Pl, Pr,
                        maxiters::Int,
                        abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
-    ArrayInterfaceCore.lu_instance(A)
+    ArrayInterface.lu_instance(A)
 end
 function init_cacheval(alg::GenericFactorization, A::SymTridiagonal{T, V}, b, u, Pl, Pr,
                        maxiters::Int, abstol, reltol, verbose::Bool,
@@ -369,7 +369,7 @@ end
 function init_cacheval(alg::RFLUFactorization, A, b, u, Pl, Pr, maxiters::Int,
                        abstol, reltol, verbose::Bool, assumptions::OperatorAssumptions)
     ipiv = Vector{LinearAlgebra.BlasInt}(undef, min(size(A)...))
-    ArrayInterfaceCore.lu_instance(convert(AbstractMatrix, A)), ipiv
+    ArrayInterface.lu_instance(convert(AbstractMatrix, A)), ipiv
 end
 
 function SciMLBase.solve(cache::LinearCache, alg::RFLUFactorization{P, T};