Apply runic and add format check to pre-commit

.pre-commit-config.yaml

@@ -19,3 +19,7 @@ repos:
   rev: v2.2.4
   hooks:
   - id: codespell
+- repo: https://github.com/fredrikekre/runic-pre-commit
+  rev: v1.0.0
+  hooks:
+  - id: runic

docs/make.jl

@@ -1,22 +1,24 @@
 using Documenter, ExtendableSparse, AlgebraicMultigrid, IncompleteLU, Sparspak, LinearAlgebra
 
 function mkdocs()
-    makedocs(; sitename = "ExtendableSparse.jl",
-             modules = [ExtendableSparse],
-             doctest = false,
-             warnonly = true,
-             clean = false,
-             authors = "J. Fuhrmann",
-             repo = "https://github.com/WIAS-PDELib/ExtendableSparse.jl",
-             pages = [
-                 "Home" => "index.md",
-                 "example.md",
-                 "extsparse.md",
-                 "linearsolve.md",
-                 "internal.md",
-                 "iter.md",
-                 "changes.md",
-             ])
+    return makedocs(;
+        sitename = "ExtendableSparse.jl",
+        modules = [ExtendableSparse],
+        doctest = false,
+        warnonly = true,
+        clean = false,
+        authors = "J. Fuhrmann",
+        repo = "https://github.com/WIAS-PDELib/ExtendableSparse.jl",
+        pages = [
+            "Home" => "index.md",
+            "example.md",
+            "extsparse.md",
+            "linearsolve.md",
+            "internal.md",
+            "iter.md",
+            "changes.md",
+        ]
+    )
 end
 
 mkdocs()

ext/ExtendableSparseAMGCLWrapExt.jl

@@ -12,11 +12,13 @@ mutable struct AMGCL_AMGPreconditioner <: AbstractPreconditioner
     factorization::AMGCLWrap.AMGPrecon
     kwargs
     function ExtendableSparse.AMGCL_AMGPreconditioner(; kwargs...)
-        Base.depwarn("AMGCL_AMGPreconditioner() is deprecated. Use LinearSolve with `precs=AMGCLWrap.AMGPreconBuilder()`  instead.",
-                     :AMGCL_AMGPreconditioner)
+        Base.depwarn(
+            "AMGCL_AMGPreconditioner() is deprecated. Use LinearSolve with `precs=AMGCLWrap.AMGPreconBuilder()`  instead.",
+            :AMGCL_AMGPreconditioner
+        )
         precon = new()
         precon.kwargs = kwargs
-        precon
+        return precon
     end
 end
 
@@ -27,23 +29,25 @@ end
 
 function update!(precon::AMGCL_AMGPreconditioner)
     @inbounds flush!(precon.A)
-    precon.factorization = AMGCLWrap.AMGPrecon(precon.A;precon.kwargs...)
+    return precon.factorization = AMGCLWrap.AMGPrecon(precon.A; precon.kwargs...)
 end
 
-allow_views(::AMGCL_AMGPreconditioner)=true
-allow_views(::Type{AMGCL_AMGPreconditioner})=true
+allow_views(::AMGCL_AMGPreconditioner) = true
+allow_views(::Type{AMGCL_AMGPreconditioner}) = true
 
 #############################################################################
 mutable struct AMGCL_RLXPreconditioner <: AbstractPreconditioner
     A::ExtendableSparseMatrix
     factorization::AMGCLWrap.RLXPrecon
     kwargs
     function ExtendableSparse.AMGCL_RLXPreconditioner(; kwargs...)
-        Base.depwarn("AMGCL_RLXPreconditioner() is deprecated. Use LinearSolve with  `precs=AMGCLWrap.RLXPreconBuilder()`  instead.",
-                     :AMGCL_RLXPreconditioner)
+        Base.depwarn(
+            "AMGCL_RLXPreconditioner() is deprecated. Use LinearSolve with  `precs=AMGCLWrap.RLXPreconBuilder()`  instead.",
+            :AMGCL_RLXPreconditioner
+        )
         precon = new()
         precon.kwargs = kwargs
-        precon
+        return precon
     end
 end
 
@@ -54,12 +58,11 @@ end
 
 function update!(precon::AMGCL_RLXPreconditioner)
     @inbounds flush!(precon.A)
-    precon.factorization = AMGCLWrap.RLXPrecon(precon.A;precon.kwargs...)
+    return precon.factorization = AMGCLWrap.RLXPrecon(precon.A; precon.kwargs...)
 end
 
-allow_views(::AMGCL_RLXPreconditioner)=true
-allow_views(::Type{AMGCL_RLXPreconditioner})=true
-
+allow_views(::AMGCL_RLXPreconditioner) = true
+allow_views(::Type{AMGCL_RLXPreconditioner}) = true
 
 
 end

ext/ExtendableSparseAlgebraicMultigridExt.jl

@@ -8,8 +8,8 @@ using LinearAlgebra: I
 import ExtendableSparse: SmoothedAggregationPreconBuilder
 import ExtendableSparse: RugeStubenPreconBuilder
 
-(b::SmoothedAggregationPreconBuilder)(A::AbstractSparseMatrixCSC,p)= (aspreconditioner(smoothed_aggregation(SparseMatrixCSC(A), Val{b.blocksize}; b.kwargs...)),I)
-(b::RugeStubenPreconBuilder)(A::AbstractSparseMatrixCSC,p)= (aspreconditioner(ruge_stuben(SparseMatrixCSC(A), Val{b.blocksize}; b.kwargs...)),I)
+(b::SmoothedAggregationPreconBuilder)(A::AbstractSparseMatrixCSC, p) = (aspreconditioner(smoothed_aggregation(SparseMatrixCSC(A), Val{b.blocksize}; b.kwargs...)), I)
+(b::RugeStubenPreconBuilder)(A::AbstractSparseMatrixCSC, p) = (aspreconditioner(ruge_stuben(SparseMatrixCSC(A), Val{b.blocksize}; b.kwargs...)), I)
 
 
 ####
@@ -19,23 +19,23 @@ import ExtendableSparse: RugeStubenPreconBuilder
 import ExtendableSparse: @makefrommatrix, AbstractPreconditioner, update!
 
 ######################################################################################
-rswarned=false
+rswarned = false
 
 mutable struct RS_AMGPreconditioner <: AbstractPreconditioner
     A::ExtendableSparseMatrix
     factorization::AlgebraicMultigrid.Preconditioner
     kwargs
     blocksize
-    function ExtendableSparse.RS_AMGPreconditioner(blocksize=1; kwargs...)
+    function ExtendableSparse.RS_AMGPreconditioner(blocksize = 1; kwargs...)
         global rswarned
         if !rswarned
             @warn "RS_AMGPreconditioner is deprecated. Use LinearSolve with `precs=RugeStubenPreconBuilder()` instead"
-            rswarned=true
+            rswarned = true
         end
         precon = new()
         precon.kwargs = kwargs
-        precon.blocksize=blocksize
-        precon
+        precon.blocksize = blocksize
+        return precon
     end
 end
 
@@ -46,30 +46,30 @@ end
 
 function update!(precon::RS_AMGPreconditioner)
     @inbounds flush!(precon.A)
-    precon.factorization =  AlgebraicMultigrid.aspreconditioner(AlgebraicMultigrid.ruge_stuben(precon.A.cscmatrix,Val{precon.blocksize}; precon.kwargs...))
+    return precon.factorization = AlgebraicMultigrid.aspreconditioner(AlgebraicMultigrid.ruge_stuben(precon.A.cscmatrix, Val{precon.blocksize}; precon.kwargs...))
 end
 
-allow_views(::RS_AMGPreconditioner)=true
-allow_views(::Type{RS_AMGPreconditioner})=true
+allow_views(::RS_AMGPreconditioner) = true
+allow_views(::Type{RS_AMGPreconditioner}) = true
 
 
 ######################################################################################
-sawarned=false
+sawarned = false
 mutable struct SA_AMGPreconditioner <: AbstractPreconditioner
     A::ExtendableSparseMatrix
     factorization::AlgebraicMultigrid.Preconditioner
     kwargs
     blocksize
-    function ExtendableSparse.SA_AMGPreconditioner(blocksize=1; kwargs...)
+    function ExtendableSparse.SA_AMGPreconditioner(blocksize = 1; kwargs...)
         global sawarned
         if !sawarned
             @warn "SA_AMGPreconditioner is deprecated. Use LinearSolve with `precs=SmoothedAggregationPreconBuilder()` instead"
-            sawarned=true
+            sawarned = true
         end
         precon = new()
         precon.kwargs = kwargs
-        precon.blocksize=blocksize
-        precon
+        precon.blocksize = blocksize
+        return precon
     end
 end
 
@@ -80,11 +80,11 @@ end
 
 function update!(precon::SA_AMGPreconditioner)
     @inbounds flush!(precon.A)
-    precon.factorization =  AlgebraicMultigrid.aspreconditioner(AlgebraicMultigrid.smoothed_aggregation(precon.A.cscmatrix, Val{precon.blocksize}; precon.kwargs...))
+    return precon.factorization = AlgebraicMultigrid.aspreconditioner(AlgebraicMultigrid.smoothed_aggregation(precon.A.cscmatrix, Val{precon.blocksize}; precon.kwargs...))
 end
 
-allow_views(::SA_AMGPreconditioner)=true
-allow_views(::Type{SA_AMGPreconditioner})=true
+allow_views(::SA_AMGPreconditioner) = true
+allow_views(::Type{SA_AMGPreconditioner}) = true
 
 ######################################################################################
 # deprecated

ext/ExtendableSparseIncompleteLUExt.jl

@@ -1,19 +1,19 @@
 module ExtendableSparseIncompleteLUExt
 using ExtendableSparse
-using IncompleteLU 
+using IncompleteLU
 using LinearAlgebra: I
 using SparseArrays: AbstractSparseMatrixCSC, SparseMatrixCSC, getcolptr, rowvals, nonzeros
 
 import ExtendableSparse: ILUTPreconBuilder
 
-(b::ILUTPreconBuilder)(A::AbstractSparseMatrixCSC,p)=(IncompleteLU.ilu(SparseMatrixCSC(A); τ = b.droptol),I)
+(b::ILUTPreconBuilder)(A::AbstractSparseMatrixCSC, p) = (IncompleteLU.ilu(SparseMatrixCSC(A); τ = b.droptol), I)
 
 
 import ExtendableSparse: @makefrommatrix, AbstractPreconditioner, update!
 
 
 # Deprecated from here
-warned=false
+warned = false
 mutable struct ILUTPreconditioner <: AbstractPreconditioner
     A::ExtendableSparseMatrix
     factorization::IncompleteLU.ILUFactorization
@@ -22,11 +22,11 @@ mutable struct ILUTPreconditioner <: AbstractPreconditioner
         global warned
         if !warned
             @warn "ILUTPreconditioner is deprecated. Use LinearSolve with `precs=ILUTPreconBuilder()` instead"
-            warned=true
+            warned = true
         end
         p = new()
         p.droptol = droptol
-        p
+        return p
     end
 end
 
@@ -38,7 +38,7 @@ end
 function update!(precon::ILUTPreconditioner)
     A = precon.A
     @inbounds flush!(A)
-    precon.factorization = IncompleteLU.ilu(A.cscmatrix; τ = precon.droptol)
+    return precon.factorization = IncompleteLU.ilu(A.cscmatrix; τ = precon.droptol)
 end
 
 end

ext/ExtendableSparseLinearSolveExt.jl

@@ -9,17 +9,17 @@ struct LinearSolvePrecon{T}
     cache::T
 end
 
-function LinearSolvePrecon(A,method::LinearSolve.AbstractFactorization)
+function LinearSolvePrecon(A, method::LinearSolve.AbstractFactorization)
     pr = LinearProblem(A, zeros(eltype(A), size(A, 1)))
-    LinearSolvePrecon(init(pr, method))
+    return LinearSolvePrecon(init(pr, method))
 end
 
 function LinearAlgebra.ldiv!(u, P::LinearSolvePrecon, b)
     P.cache.b = b
     sol = solve!(P.cache)
-    copyto!(u, sol.u)
+    return copyto!(u, sol.u)
 end
 
-(b::LinearSolvePreconBuilder)(A::AbstractSparseMatrixCSC,p) = (LinearSolvePrecon(A,b.method), LinearAlgebra.I)
+(b::LinearSolvePreconBuilder)(A::AbstractSparseMatrixCSC, p) = (LinearSolvePrecon(A, b.method), LinearAlgebra.I)
 
 end

ext/ExtendableSparsePardisoExt.jl

@@ -12,38 +12,37 @@ if Pardiso.PARDISO_LOADED[]
         A::Union{ExtendableSparseMatrix, Nothing}
         ps::Pardiso.PardisoSolver
         phash::UInt64
-        iparm::Union{Vector{Int},Nothing}
-        dparm::Union{Vector{Float64},Nothing}
-        mtype::Union{Int,Nothing}
+        iparm::Union{Vector{Int}, Nothing}
+        dparm::Union{Vector{Float64}, Nothing}
+        mtype::Union{Int, Nothing}
     end
-    
-    function ExtendableSparse.PardisoLU(; iparm = nothing, dparm = nothing,mtype = nothing)
-        fact = PardisoLU(nothing, Pardiso.PardisoSolver(), 0,iparm,dparm,mtype)
+
+    function ExtendableSparse.PardisoLU(; iparm = nothing, dparm = nothing, mtype = nothing)
+        return fact = PardisoLU(nothing, Pardiso.PardisoSolver(), 0, iparm, dparm, mtype)
     end
 
 end
-    
+
 #############################################################################################
 mutable struct MKLPardisoLU <: AbstractPardisoLU
     A::Union{ExtendableSparseMatrix, Nothing}
     ps::Pardiso.MKLPardisoSolver
     phash::UInt64
-    iparm::Union{Vector{Int},Nothing}
+    iparm::Union{Vector{Int}, Nothing}
     dparm::Nothing
-    mtype::Union{Int,Nothing}
+    mtype::Union{Int, Nothing}
 end
 
 function ExtendableSparse.MKLPardisoLU(; iparm = nothing, mtype = nothing)
-    fact = MKLPardisoLU(nothing, Pardiso.MKLPardisoSolver(), 0,iparm,nothing,mtype)
+    return fact = MKLPardisoLU(nothing, Pardiso.MKLPardisoSolver(), 0, iparm, nothing, mtype)
 end
 
 
-
 ##########################################################################################
-function default_initialize!(Tv,fact::AbstractPardisoLU)
-    iparm=fact.iparm
-    dparm=fact.dparm
-    mtype=fact.mtype
+function default_initialize!(Tv, fact::AbstractPardisoLU)
+    iparm = fact.iparm
+    dparm = fact.dparm
+    mtype = fact.mtype
     # if !isnothing(mtype)
     #     my_mtype=mtype fix this!
     # else
@@ -57,26 +56,26 @@ function default_initialize!(Tv,fact::AbstractPardisoLU)
     Pardiso.set_matrixtype!(fact.ps, my_mtype)
 
     if !isnothing(iparm)
-        for i = 1:min(length(iparm), length(fact.ps.iparm))
+        for i in 1:min(length(iparm), length(fact.ps.iparm))
             Pardiso.set_iparm!(fact.ps, i, iparm[i])
         end
     end
 
     if !isnothing(dparm)
-        for i = 1:min(length(dparm), length(fact.ps.dparm))
+        for i in 1:min(length(dparm), length(fact.ps.dparm))
             Pardiso.set_dparm!(fact.ps, i, dparm[i])
         end
     end
-    fact
+    return fact
 end
 
 function update!(lufact::AbstractPardisoLU)
     ps = lufact.ps
     flush!(lufact.A)
     Acsc = lufact.A.cscmatrix
-    Tv=eltype(Acsc)
+    Tv = eltype(Acsc)
     if lufact.phash != lufact.A.phash
-        default_initialize!(Tv,lufact)
+        default_initialize!(Tv, lufact)
         Pardiso.set_phase!(ps, Pardiso.RELEASE_ALL)
         Pardiso.pardiso(ps, Tv[], Acsc, Tv[])
         Pardiso.set_phase!(ps, Pardiso.ANALYSIS_NUM_FACT)
@@ -86,21 +85,23 @@ function update!(lufact::AbstractPardisoLU)
     end
     Pardiso.fix_iparm!(ps, :N)
     Pardiso.pardiso(ps, Tv[], Acsc, Tv[])
-    lufact
+    return lufact
 end
 
-function LinearAlgebra.ldiv!(u::AbstractVector,
-                             lufact::AbstractPardisoLU,
-                             v::AbstractVector)
+function LinearAlgebra.ldiv!(
+        u::AbstractVector,
+        lufact::AbstractPardisoLU,
+        v::AbstractVector
+    )
     ps = lufact.ps
     Acsc = lufact.A.cscmatrix
     Pardiso.set_phase!(ps, Pardiso.SOLVE_ITERATIVE_REFINE)
     Pardiso.pardiso(ps, u, Acsc, v)
-    u
+    return u
 end
 
 function LinearAlgebra.ldiv!(fact::AbstractPardisoLU, v::AbstractVector)
-    ldiv!(v, fact, copy(v))
+    return ldiv!(v, fact, copy(v))
 end
 
 @eval begin