Factorization types (#12)

Change factorization  :symbols to factorization types.
This is more in-line with DiffEq, and allows to pass preconditioner
parameters with their constructors.

Author: j-fu

.gitignore

@@ -3,4 +3,5 @@ QUARRY
 docs/build
 *~
 Manifest.toml
+.repl_history.jl
 

Project.toml

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

docs/src/iter.md

@@ -2,15 +2,16 @@
 
 ## Factorizations
 
-In this package, preconditioners and LU factorizations are subcategories are both seen
-as complete or approximate _factorizations_. Correspondingly there is a common API for
+In this package, preconditioners and LU factorizations are both seen
+as complete or approximate _factorizations_. Correspondingly we provide a common  API for
 their creation.
 
-Factorizations from these package know the matrices which have been factorized.
 
 ```@autodocs
 Modules = [ExtendableSparse]
 Pages = ["factorizations.jl"]
+Order = [:function, :type]
+Private = false
 ```
 
 ## LU Factorizations

src/ExtendableSparse.jl

@@ -16,9 +16,11 @@ export SparseMatrixLNK,ExtendableSparseMatrix,flush!,nnz, updateindex!, rawupdat
 
 include("factorizations.jl")
 export JacobiPreconditioner, ILU0Preconditioner, ParallelJacobiPreconditioner
+export AbstractFactorization,LUFactorization, CholeskyFactorization
 export issolver
-export factorize,factorize!, update!
+export factorize!, update!
 export ILUTPreconditioner, AMGPreconditioner
+export PardisoLU, MKLPardisoLU
 
 include("simple_iteration.jl")
 export simple,simple!

src/amg.jl

@@ -1,23 +1,32 @@
-"""
-$(TYPEDEF)
-
-"""
-mutable struct AMGPreconditioner{Tv, Ti} <: AbstractExtendableSparsePreconditioner{Tv,Ti}
+mutable struct AMGPreconditioner{Tv, Ti} <: AbstractPreconditioner{Tv,Ti}
     A::ExtendableSparseMatrix{Tv,Ti}
     fact
+    max_levels::Int
+    max_coarse::Int
+    function AMGPreconditioner{Tv,Ti}(;max_levels=10, max_coarse=10) where {Tv,Ti}
+        precon=new()
+        precon.max_levels=max_levels
+        precon.max_coarse=max_coarse
+        precon
+    end
 end
 
 """
 ```
-AMGPreconditioner(extmatrix)
+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(A::ExtendableSparseMatrix{Tv,Ti}) where {Tv,Ti}
-    @inbounds flush!(A)
-    p=AlgebraicMultigrid.aspreconditioner(AlgebraicMultigrid.ruge_stuben(A.cscmatrix))
-    AMGPreconditioner{Tv,Ti}(A,p)
+AMGPreconditioner(;kwargs...)=AMGPreconditioner{Float64,Int64}(;kwargs...)
+
+@eval begin
+    @makefrommatrix AMGPreconditioner
 end
 
+
+
 function update!(precon::AMGPreconditioner{Tv,Ti}) where {Tv,Ti}
     @inbounds flush!(precon.A)
     precon.fact=AlgebraicMultigrid.aspreconditioner(AlgebraicMultigrid.ruge_stuben(precon.A.cscmatrix))

src/cholmod_cholesky.jl

@@ -1,40 +1,34 @@
-"""
-$(TYPEDEF)
-
-Default Julia LU Factorization based on umfpack.
-"""
-mutable struct ExtendableSparseCholmodCholesky{Tv, Ti} <: AbstractExtendableSparseLU{Tv,Ti}
-    A::ExtendableSparseMatrix{Tv,Ti}
-    A64
-    fact::SuiteSparse.CHOLMOD.Factor{Tv}
+mutable struct CholeskyFactorization{Tv, Ti} <: AbstractLUFactorization{Tv,Ti}
+    A::Union{ExtendableSparseMatrix{Tv,Ti},Nothing}
+    fact::Union{SuiteSparse.CHOLMOD.Factor{Tv},Nothing}
     phash::UInt64
+    A64
 end
 
 """
-```
-ExtendableSparseCholmodCholesky(A)
-```
+CholeskyFactorization()
+CholeskyFactorization(matrix)
+
+Default Cholesky factorization via cholmod.
 """
-function ExtendableSparseCholmodCholesky(A::ExtendableSparseMatrix{Tv,Ti}) where {Tv,Ti}
-    flush!(A)
-    A64=Symmetric(SparseMatrixCSC{Float64,Int64}(A.cscmatrix))
-    ExtendableSparseCholmodCholesky(A,A64,cholesky(A64),A.phash)
-end
+CholeskyFactorization()=CholeskyFactorization{Float64,Int64}(nothing,nothing,0,nothing)
 
-function update!(cholfact::ExtendableSparseCholmodCholesky)
-    flush!(cholfact.A)
-    if cholfact.A.phash!=cholfact.phash
-        cholfact.A64=Symmetric{SparseMatrixCSC{Float64,Int64}(A.cscmatrix)}
-        cholfact.fact=cholesky(cholfact.fact,cholfact.A64)
-        cholfact.phash=cholfact.A.phash
+
+function update!(cholfact::CholeskyFactorization)
+    A=cholfact.A
+    flush!(A)
+    if A.phash!=cholfact.phash
+        cholfact.A64=Symmetric(SparseMatrixCSC{Float64,Int64}(A.cscmatrix))
+        cholfact.fact=cholesky(cholfact.A64)
+        cholfact.phash=A.phash
     else
-        cholfact.A64.data.nzval.=cholfact.A.cscmatrix.nzval
+        cholfact.A64.data.nzval.=A.cscmatrix.nzval
         cholfact.fact=cholesky!(cholfact.fact,cholfact.A64)
     end
     cholfact
 end
 
 
-LinearAlgebra.ldiv!(fact::ExtendableSparseCholmodCholesky, v)=fact.fact\v
-LinearAlgebra.ldiv!(u,fact::ExtendableSparseCholmodCholesky, v)=u.=fact.fact\v
+LinearAlgebra.ldiv!(fact::CholeskyFactorization, v)=fact.fact\v
+LinearAlgebra.ldiv!(u,fact::CholeskyFactorization, v)=u.=fact.fact\v