Extensions (#27)

Introducd 1.9 extensions

Also: 

* Let timing test always pass, issue a warning instead if it fails.
Fixes problem with cases of  CPU noise on CI.

Author: j-fu

Project.toml

@@ -1,7 +1,7 @@
 name = "ExtendableSparse"
 uuid = "95c220a8-a1cf-11e9-0c77-dbfce5f500b3"
 authors = ["Juergen Fuhrmann <[email protected]>"]
-version = "1.1.0"
+version = "1.2.0"
 
 [deps]
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
@@ -11,16 +11,34 @@ Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Sparspak = "e56a9233-b9d6-4f03-8d0f-1825330902ac"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 SuiteSparse = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
+[weakdeps]
+AlgebraicMultigrid = "2169fc97-5a83-5252-b627-83903c6c433c"
+IncompleteLU = "40713840-3770-5561-ab4c-a76e7d0d7895"
+Pardiso = "46dd5b70-b6fb-5a00-ae2d-e8fea33afaf2"
+
+
+
+[extensions]
+ExtendableSparseAlgebraicMultigridExt = "AlgebraicMultigrid"
+ExtendableSparsePardisoExt = "Pardiso"
+ExtendableSparseIncompleteLUExt = "IncompleteLU"
+
 [compat]
 DocStringExtensions = "0.8, 0.9"
 ILUZero = "0.2"
-Requires = "1.1.3"
+Requires ="1.1.3"
 Sparspak = "0.3.6"
 julia = "1.6"
+AlgebraicMultigrid = "0.4,0.5"
+IncompleteLU = "^0.2.1"
+Pardiso = "0.5.1"
+StaticArrays = "1.5.24"
 
 [extras]
-Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
-Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+AlgebraicMultigrid = "2169fc97-5a83-5252-b627-83903c6c433c"
+IncompleteLU = "40713840-3770-5561-ab4c-a76e7d0d7895"
+Pardiso = "46dd5b70-b6fb-5a00-ae2d-e8fea33afaf2"

docs/Project.toml

@@ -13,7 +13,4 @@ Pardiso = "46dd5b70-b6fb-5a00-ae2d-e8fea33afaf2"
 Sparspak = "e56a9233-b9d6-4f03-8d0f-1825330902ac"
 
 [compat]
-AlgebraicMultigrid = "0.4,0.5"
-IncompleteLU = "^0.2.1"
 IterativeSolvers = "0.9"
-Pardiso = "^0.5.1"

docs/src/iter.md

@@ -66,12 +66,19 @@ nm1, nm2
 ```
 
 ### API
-
+Available by default:
 ```@autodocs
 Modules = [ExtendableSparse]
-Pages = ["umfpack_lu.jl", "pardiso_lu.jl", "sparspak.jl"]
+Pages = ["umfpack_lu.jl",  "sparspak.jl"]
+```
+
+Pardiso extension:
+```@docs
+PardisoLU
+MKLPardisoLU
 ```
 
+
 ## Preconditioners
 
 The API is similar to that for LU factorizations.
@@ -123,14 +130,22 @@ nm1, nm2
 ### API
 
 #### Recommended 
+Available by default:
 ```@autodocs
 Modules = [ExtendableSparse]
 Pages = ["iluzero.jl","ilut.jl","amg.jl","blockpreconditioner.jl"]
 ```
 
+Extensions:
+```@docs
+ILUTPreconditioner
+AMGPreconditioner
+```
+
 
 #### Experimental
 ```@autodocs
 Modules = [ExtendableSparse]
 Pages = ["jacobi.jl","parallel_jacobi.jl","ilu0.jl",]
 ```
+

src/factorizations/amg.jl renamed to ext/ExtendableSparseAlgebraicMultigridExt.jl

@@ -1,28 +1,27 @@
+module ExtendableSparseAlgebraicMultigridExt
+
+using ExtendableSparse
+
+isdefined(Base, :get_extension) ? using AlgebraicMultigrid : using ..AlgebraicMultigrid
+
+import ExtendableSparse: @makefrommatrix, AbstractPreconditioner, update!
+
 mutable struct AMGPreconditioner <: AbstractPreconditioner
     A::ExtendableSparseMatrix
     factorization::AlgebraicMultigrid.Preconditioner
     max_levels::Int
     max_coarse::Int
-    function AMGPreconditioner(; max_levels = 10, max_coarse = 10)
+    function ExtendableSparse.AMGPreconditioner(; max_levels = 10, max_coarse = 10)
         precon = new()
         precon.max_levels = max_levels
         precon.max_coarse = max_coarse
         precon
     end
 end
 
-"""
-```
-AMGPreconditioner(;max_levels=10, max_coarse=10)
-AMGPreconditioner(matrix;max_levels=10, max_coarse=10)
-```
-
-Create the  [`AMGPreconditioner`](@ref) wrapping the Ruge-Stüben AMG preconditioner from [AlgebraicMultigrid.jl](https://github.com/JuliaLinearAlgebra/AlgebraicMultigrid.jl)
-"""
-function AMGPreconditioner end
 
 @eval begin
-    @makefrommatrix AMGPreconditioner
+    @makefrommatrix  ExtendableSparse.AMGPreconditioner
 end
 
 function update!(precon::AMGPreconditioner)
@@ -32,3 +31,5 @@ end
 
 allow_views(::AMGPreconditioner)=true
 allow_views(::Type{AMGPreconditioner})=true
+
+end

src/factorizations/ilut.jl renamed to ext/ExtendableSparseIncompleteLUExt.jl

@@ -1,32 +1,31 @@
+module ExtendableSparseIncompleteLUExt
+
+using ExtendableSparse
+
+isdefined(Base, :get_extension) ? using IncompleteLU : using ..IncompleteLU
+
+import ExtendableSparse: @makefrommatrix, AbstractPreconditioner, update!
+
 mutable struct ILUTPreconditioner <: AbstractPreconditioner
     A::ExtendableSparseMatrix
     factorization::IncompleteLU.ILUFactorization
     droptol::Float64
-    function ILUTPreconditioner(; droptol = 1.0e-3)
+    function ExtendableSparse.ILUTPreconditioner(; droptol = 1.0e-3)
         p = new()
         p.droptol = droptol
         p
     end
 end
 
-"""
-```
-ILUTPreconditioner(;droptol=1.0e-3)
-ILUTPreconditioner(matrix; droptol=1.0e-3)
-```
-
-Create the [`ILUTPreconditioner`](@ref) wrapping the one 
-from [IncompleteLU.jl](https://github.com/haampie/IncompleteLU.jl)
-For using this, you need to issue `using IncompleteLU`.
-"""
-function ILUTPreconditioner end
 
 @eval begin
-    @makefrommatrix ILUTPreconditioner
+    @makefrommatrix ExtendableSparse.ILUTPreconditioner
 end
 
 function update!(precon::ILUTPreconditioner)
     A = precon.A
     @inbounds flush!(A)
     precon.factorization = IncompleteLU.ilu(A.cscmatrix; τ = precon.droptol)
 end
+end
+

src/factorizations/pardiso_lu.jl renamed to ext/ExtendableSparsePardisoExt.jl

@@ -1,3 +1,11 @@
+module ExtendableSparsePardisoExt
+using ExtendableSparse
+using LinearAlgebra
+
+isdefined(Base, :get_extension) ? using Pardiso : using ..Pardiso
+
+import ExtendableSparse: @makefrommatrix, update!, AbstractLUFactorization
+
 abstract type AbstractPardisoLU <: AbstractLUFactorization end
 
 mutable struct PardisoLU <: AbstractPardisoLU
@@ -9,34 +17,10 @@ mutable struct PardisoLU <: AbstractPardisoLU
     mtype::Union{Int,Nothing}
 end
 
-function PardisoLU(; iparm = nothing, dparm = nothing,mtype = nothing)
+function ExtendableSparse.PardisoLU(; iparm = nothing, dparm = nothing,mtype = nothing)
     fact = PardisoLU(nothing, Pardiso.PardisoSolver(), 0,iparm,dparm,mtype)
 end
 
-"""
-```
-PardisoLU(;iparm::Vector, 
-           dparm::Vector, 
-           mtype::Int)
-
-PardisoLU(matrix; iparm,dparm,mtype)
-```
-
-LU factorization based on pardiso. For using this, you need to issue `using Pardiso`
-and have the pardiso library from  [pardiso-project.org](https://pardiso-project.org) 
-[installed](https://github.com/JuliaSparse/Pardiso.jl#pardiso-60).
-
-The optional keyword arguments `mtype`, `iparm`  and `dparm` are 
-[Pardiso internal parameters](https://github.com/JuliaSparse/Pardiso.jl#readme).
-
-Forsetting them, one can also access the `PardisoSolver` e.g. like
-```
-using Pardiso
-plu=PardisoLU()
-Pardiso.set_iparm!(plu.ps,5,13.0)
-```
-"""
-function PardisoLU end
 
 #############################################################################################
 mutable struct MKLPardisoLU <: AbstractPardisoLU
@@ -48,31 +32,10 @@ mutable struct MKLPardisoLU <: AbstractPardisoLU
     mtype::Union{Int,Nothing}
 end
 
-function MKLPardisoLU(; iparm = nothing, mtype = nothing)
+function ExtendableSparse.MKLPardisoLU(; iparm = nothing, mtype = nothing)
     fact = MKLPardisoLU(nothing, Pardiso.MKLPardisoSolver(), 0,iparm,nothing,mtype)
 end
 
-"""
-```
-MKLPardisoLU(;iparm::Vector, mtype::Int)
-
-MKLPardisoLU(matrix; iparm, mtype)
-```
-
-LU factorization based on pardiso. For using this, you need to issue `using Pardiso`.
-This version  uses the early 2000's fork in Intel's MKL library.
-
-The optional keyword arguments `mtype` and `iparm`  are  
-[Pardiso internal parameters](https://github.com/JuliaSparse/Pardiso.jl#readme).
-
-For setting them you can also access the `PardisoSolver` e.g. like
-```
-using Pardiso
-plu=MKLPardisoLU()
-Pardiso.set_iparm!(plu.ps,5,13.0)
-```
-"""
-function MKLPardisoLU end
 
 
 ##########################################################################################
@@ -140,6 +103,9 @@ function LinearAlgebra.ldiv!(fact::AbstractPardisoLU, v::AbstractVector)
 end
 
 @eval begin
-    @makefrommatrix PardisoLU
-    @makefrommatrix MKLPardisoLU
+    @makefrommatrix ExtendableSparse.PardisoLU
+    @makefrommatrix ExtendableSparse.MKLPardisoLU
 end
+
+end
+