Abstractsparse (#25)

Implement AbstractSparseMatrixCSC interface.
Remove extension of LinearSolve methods
LinearSolve since 1.37 can handle this.

Author: j-fu

Project.toml

@@ -1,7 +1,7 @@
 name = "ExtendableSparse"
 uuid = "95c220a8-a1cf-11e9-0c77-dbfce5f500b3"
 authors = ["Juergen Fuhrmann <juergen.fuhrmann@wias-berlin.de>"]
-version = "0.9.6"
+version = "0.9.7"
 
 [deps]
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"

docs/src/changes.md

@@ -1,5 +1,9 @@
 # Changes
 
+## v0.9.7, Jan 22, 2023
+
+  - support of AbstractSparseMatrixCSC interface
+
 ## v0.9.6, Jan 22, 2023
 
   - support for LinearSolve.jl

docs/src/linearsolve.md

@@ -2,8 +2,8 @@
 
 Starting with version 0.9.6, ExtendableSparse is compatible
 with [LinearSolve.jl](https://github.com/SciML/LinearSolve.jl).
-For this purpose, it extends the `LinearProblem` constructor and the
-`set_A` function by methods specific for `ExtendableSparseMatrix`.
+Since version 0.9.7, this is facilitated via the
+AbstractSparseMatrixCSC interface.
 
 ```@autodocs
 Modules = [ExtendableSparse]

src/ExtendableSparse.jl

@@ -16,7 +16,7 @@ using Requires
 
 using DocStringExtensions
 
-import SparseArrays: rowvals, getcolptr, nonzeros
+import SparseArrays: AbstractSparseMatrixCSC, rowvals, getcolptr, nonzeros
 
 include("sparsematrixcsc.jl")
 include("sparsematrixlnk.jl")
@@ -47,7 +47,6 @@ function __init__()
     @require Pardiso="46dd5b70-b6fb-5a00-ae2d-e8fea33afaf2" include("pardiso_lu.jl")
     @require IncompleteLU="40713840-3770-5561-ab4c-a76e7d0d7895" include("ilut.jl")
     @require AlgebraicMultigrid="2169fc97-5a83-5252-b627-83903c6c433c" include("amg.jl")
-    @require LinearSolve="7ed4a6bd-45f5-4d41-b270-4a48e9bafcae" include("linearsolve.jl")
 end
 
 export ILUTPreconditioner, AMGPreconditioner

src/amg.jl

@@ -23,7 +23,9 @@ function AMGPreconditioner(; valuetype::Type = Float64, indextype::Type = Int64,
     AMGPreconditioner{valuetype, indextype}(; kwargs...)
 end
 
-@eval begin @makefrommatrix AMGPreconditioner end
+@eval begin
+    @makefrommatrix AMGPreconditioner
+end
 
 function update!(precon::AMGPreconditioner{Tv, Ti}) where {Tv, Ti}
     @inbounds flush!(precon.A)

src/extendable.jl

@@ -7,7 +7,7 @@ either in cscmatrix, or in lnkmatrix, never in both.
 
 $(TYPEDFIELDS)
 """
-mutable struct ExtendableSparseMatrix{Tv, Ti <: Integer} <: AbstractSparseMatrix{Tv, Ti}
+mutable struct ExtendableSparseMatrix{Tv, Ti <: Integer} <: AbstractSparseMatrixCSC{Tv, Ti}
     """
     Final matrix data
     """
@@ -34,6 +34,7 @@ Create empty ExtendableSparseMatrix. This is equivalent to `spzeros(m,n)` for
 `SparseMartrixCSC`.
 
 """
+
 function ExtendableSparseMatrix{Tv, Ti}(m, n) where {Tv, Ti <: Integer}
     ExtendableSparseMatrix{Tv, Ti}(spzeros(Tv, Ti, m, n), nothing, 0)
 end
@@ -56,6 +57,7 @@ $(SIGNATURES)
 
  Create ExtendableSparseMatrix from SparseMatrixCSC
 """
+
 function ExtendableSparseMatrix(csc::SparseMatrixCSC{Tv, Ti}) where {Tv, Ti <: Integer}
     return ExtendableSparseMatrix{Tv, Ti}(csc, nothing, phash(csc))
 end
@@ -154,6 +156,7 @@ A
 
 If `v` is zero, no new entry is created.
 """
+
 function updateindex!(ext::ExtendableSparseMatrix{Tv, Ti},
                       op,
                       v,
@@ -199,7 +202,10 @@ $(SIGNATURES)
 Find index in CSC matrix and set value if it exists. Otherwise,
 set index in extension if `v` is nonzero.
 """
-function Base.setindex!(ext::ExtendableSparseMatrix{Tv, Ti}, v, i, j) where {Tv, Ti}
+function Base.setindex!(ext::ExtendableSparseMatrix{Tv, Ti},
+                        v,
+                        i::Integer,
+                        j::Integer) where {Tv, Ti}
     k = findindex(ext.cscmatrix, i, j)
     if k > 0
         ext.cscmatrix.nzval[k] = v
@@ -217,7 +223,9 @@ $(SIGNATURES)
 Find index in CSC matrix and return value, if it exists.
 Otherwise, return value from extension.
 """
-function Base.getindex(ext::ExtendableSparseMatrix{Tv, Ti}, i, j) where {Tv, Ti <: Integer}
+function Base.getindex(ext::ExtendableSparseMatrix{Tv, Ti},
+                       i::Integer,
+                       j::Integer) where {Tv, Ti <: Integer}
     k = findindex(ext.cscmatrix, i, j)
     if k > 0
         return ext.cscmatrix.nzval[k]
@@ -303,26 +311,28 @@ end
 """
 $(SIGNATURES)
 
+Return element type.
+"""
+Base.eltype(::ExtendableSparseMatrix{Tv, Ti}) where {Tv, Ti} = Tv
+
+"""
+$(SIGNATURES)
+
 [`flush!`](@ref) and return rowvals in ext.cscmatrix.
 """
 function SparseArrays.rowvals(ext::ExtendableSparseMatrix)
     flush!(ext)
     rowvals(ext.cscmatrix)
 end
 
-function SparseArrays.getrowval(S::ExtendableSparseMatrix)
-    flush!(S)
-    getfield(S.cscmatrix, :rowval)
-end
-
 """
 $(SIGNATURES)
 
 [`flush!`](@ref) and return colptr of  in ext.cscmatrix.
 """
 function SparseArrays.getcolptr(ext::ExtendableSparseMatrix)
     flush!(ext)
-    return ext.cscmatrix.colptr
+    return getcolptr(ext.cscmatrix)
 end
 
 """
@@ -335,15 +345,12 @@ function SparseArrays.findnz(ext::ExtendableSparseMatrix)
     return findnz(ext.cscmatrix)
 end
 
-if USE_GPL_LIBS
-    for (Tv) in (:Float64, :ComplexF64)
-        @eval begin function LinearAlgebra.:\(ext::ExtendableSparseMatrix{$Tv, Ti},
-                                              B::AbstractVecOrMat{$Tv}) where {Ti}
-            flush!(ext)
-            ext.cscmatrix \ B
-        end end
+@static if VERSION >= v"1.7"
+    function SparseArrays._checkbuffers(ext::ExtendableSparseMatrix)
+        flush!(ext)
+        SparseArrays._checkbuffers(ext.cscmatrix)
     end
-end # USE_GPL_LIBS
+end
 
 """
     A\b
@@ -353,7 +360,7 @@ are allowed  in the Julia sysimage and the floating point type of the matrix is
 In that case, Julias standard `\` is called, which is realized via UMFPACK.
 """
 function LinearAlgebra.:\(ext::ExtendableSparseMatrix{Tv, Ti},
-                          b::AbstractVector{Tv}) where {Tv, Ti}
+                          b::AbstractVector) where {Tv, Ti}
     flush!(ext)
     SparspakLU(ext) \ b
 end
@@ -364,16 +371,8 @@ $(SIGNATURES)
 [`\\`](@ref) for Symmetric{ExtendableSparse}
 """
 function LinearAlgebra.:\(symm_ext::Symmetric{Tm, ExtendableSparseMatrix{Tm, Ti}},
-                          B::AbstractVector{T} where {T}) where {Tm, Ti}
-    flush!(symm_ext.data)
-    symm_csc = Symmetric(symm_ext.data.cscmatrix, Symbol(symm_ext.uplo))
-    symm_csc \ B
-end
-function LinearAlgebra.:\(symm_ext::Symmetric{Tm, ExtendableSparseMatrix{Tm, Ti}},
-                          B::AbstractMatrix{T} where {T}) where {Tm, Ti}
-    flush!(symm_ext.data)
-    symm_csc = Symmetric(symm_ext.data.cscmatrix, Symbol(symm_ext.uplo))
-    symm_csc \ B
+                          b::AbstractVector) where {Tm, Ti}
+    symm_ext.data \ b # no ldlt yet ...
 end
 
 """
@@ -382,18 +381,42 @@ $(SIGNATURES)
 [`\\`](@ref) for Hermitian{ExtendableSparse}
 """
 function LinearAlgebra.:\(symm_ext::Hermitian{Tm, ExtendableSparseMatrix{Tm, Ti}},
-                          B::AbstractVector{T} where {T}) where {Tm, Ti}
-    flush!(symm_ext.data)
-    symm_csc = Hermitian(symm_ext.data.cscmatrix, Symbol(symm_ext.uplo))
-    symm_csc \ B
-end
-function LinearAlgebra.:\(symm_ext::Hermitian{Tm, ExtendableSparseMatrix{Tm, Ti}},
-                          B::AbstractMatrix{T} where {T}) where {Tm, Ti}
-    flush!(symm_ext.data)
-    symm_csc = Hermitian(symm_ext.data.cscmatrix, Symbol(symm_ext.uplo))
-    symm_csc \ B
+                          b::AbstractVector) where {Tm, Ti}
+    symm_ext.data \ B # no ldlt yet ...
 end
 
+if USE_GPL_LIBS
+    for (Tv) in (:Float64, :ComplexF64)
+        @eval begin function LinearAlgebra.:\(ext::ExtendableSparseMatrix{$Tv, Ti},
+                                              B::AbstractVector) where {Ti}
+            flush!(ext)
+            ext.cscmatrix \ B
+        end end
+
+        @eval begin function LinearAlgebra.:\(symm_ext::Symmetric{$Tv,
+                                                                  ExtendableSparseMatrix{
+                                                                                         $Tv,
+                                                                                         Ti
+                                                                                         }},
+                                              B::AbstractVector) where {Ti}
+            flush!(symm_ext.data)
+            symm_csc = Symmetric(symm_ext.data.cscmatrix, Symbol(symm_ext.uplo))
+            symm_csc \ B
+        end end
+
+        @eval begin function LinearAlgebra.:\(symm_ext::Hermitian{$Tv,
+                                                                  ExtendableSparseMatrix{
+                                                                                         $Tv,
+                                                                                         Ti
+                                                                                         }},
+                                              B::AbstractVector) where {Ti}
+            flush!(symm_ext.data)
+            symm_csc = Hermitian(symm_ext.data.cscmatrix, Symbol(symm_ext.uplo))
+            symm_csc \ B
+        end end
+    end
+end # USE_GPL_LIBS
+
 """
 $(SIGNATURES)
 

src/ilut.jl

@@ -23,7 +23,9 @@ function ILUTPreconditioner(; valuetype::Type = Float64, indextype::Type = Int64
     ILUTPreconditioner{valuetype, indextype}(; kwargs...)
 end
 
-@eval begin @makefrommatrix ILUTPreconditioner end
+@eval begin
+    @makefrommatrix ILUTPreconditioner
+end
 
 function update!(precon::ILUTPreconditioner)
     A = precon.A

test/test_symmetric.jl

@@ -11,6 +11,7 @@ function test_symm(n, uplo)
     flush!(A)
     SA = Symmetric(A, uplo)
     Scsc = Symmetric(A.cscmatrix, uplo)
+
     if ExtendableSparse.USE_GPL_LIBS
         #requires SuiteSparse which is not available on non-GPL builds
         SA \ b ≈ Scsc \ b