Merge pull request #149 from SciML/format2

Format SciML Style

Author: ChrisRackauckas

.JuliaFormatter.toml

@@ -0,0 +1 @@
+style = "sciml"

.github/workflows/FormatCheck.yml

@@ -0,0 +1,42 @@
+name: format-check
+
+on:
+  push:
+    branches:
+      - 'master'
+      - 'release-'
+    tags: '*'
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        julia-version: [1]
+        julia-arch: [x86]
+        os: [ubuntu-latest]
+    steps:
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: ${{ matrix.julia-version }}
+
+      - uses: actions/checkout@v1
+      - name: Install JuliaFormatter and format
+        # This will use the latest version by default but you can set the version like so:
+        #
+        # julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter", version="0.13.0"))'
+        run: |
+          julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter"))'
+          julia  -e 'using JuliaFormatter; format(".", verbose=true)'
+      - name: Format check
+        run: |
+          julia -e '
+          out = Cmd(`git diff --name-only`) |> read |> String
+          if out == ""
+              exit(0)
+          else
+              @error "Some files have not been formatted !!!"
+              write(stdout, out)
+              exit(1)
+          end'

docs/make.jl

@@ -1,22 +1,19 @@
 using LinearSolve
 using Documenter
 
-DocMeta.setdocmeta!(LinearSolve, :DocTestSetup, :(using LinearSolve); recursive=true)
+DocMeta.setdocmeta!(LinearSolve, :DocTestSetup, :(using LinearSolve); recursive = true)
 
 include("pages.jl")
 
-makedocs(
-    sitename="LinearSolve.jl",
-    authors="Chris Rackauckas",
-    modules=[LinearSolve,LinearSolve.SciMLBase],
-    clean=true,doctest=false,
-    format = Documenter.HTML(analytics = "UA-90474609-3",
-                             assets = ["assets/favicon.ico"],
-                             canonical="https://linearsolve.sciml.ai/stable/"),
-    pages=pages
-)
+makedocs(sitename = "LinearSolve.jl",
+         authors = "Chris Rackauckas",
+         modules = [LinearSolve, LinearSolve.SciMLBase],
+         clean = true, doctest = false,
+         format = Documenter.HTML(analytics = "UA-90474609-3",
+                                  assets = ["assets/favicon.ico"],
+                                  canonical = "https://linearsolve.sciml.ai/stable/"),
+         pages = pages)
 
 deploydocs(;
-    repo="github.com/SciML/LinearSolve.jl",
-    devbranch="main",
-)
+           repo = "github.com/SciML/LinearSolve.jl",
+           devbranch = "main")

docs/pages.jl

@@ -1,23 +1,15 @@
 # Put in a separate page so it can be used by SciMLDocs.jl
 
-pages=[
+pages = [
     "Home" => "index.md",
-    "Tutorials" => Any[
-        "tutorials/linear.md"
-        "tutorials/caching_interface.md"
-    ],
-    "Basics" => Any[
-        "basics/LinearProblem.md",
-        "basics/common_solver_opts.md",
-        "basics/CachingAPI.md",
-        "basics/Preconditioners.md",
-        "basics/FAQ.md"
-    ],
-    "Solvers" => Any[
-        "solvers/solvers.md"
-    ],
-    "Advanced" => Any[
-        "advanced/developing.md"
-        "advanced/custom.md"
-    ]
-]
+    "Tutorials" => Any["tutorials/linear.md"
+                       "tutorials/caching_interface.md"],
+    "Basics" => Any["basics/LinearProblem.md",
+                    "basics/common_solver_opts.md",
+                    "basics/CachingAPI.md",
+                    "basics/Preconditioners.md",
+                    "basics/FAQ.md"],
+    "Solvers" => Any["solvers/solvers.md"],
+    "Advanced" => Any["advanced/developing.md"
+                      "advanced/custom.md"],
+]

lib/LinearSolveCUDA/src/LinearSolveCUDA.jl

@@ -4,7 +4,8 @@ using CUDA, LinearAlgebra, LinearSolve, SciMLBase
 
 struct CudaOffloadFactorization <: LinearSolve.AbstractFactorization end
 
-function SciMLBase.solve(cache::LinearSolve.LinearCache, alg::CudaOffloadFactorization; kwargs...)
+function SciMLBase.solve(cache::LinearSolve.LinearCache, alg::CudaOffloadFactorization;
+                         kwargs...)
     if cache.isfresh
         fact = LinearSolve.do_factorization(alg, CUDA.CuArray(cache.A), cache.b, cache.u)
         cache = LinearSolve.set_cacheval(cache, fact)
@@ -16,7 +17,7 @@ function SciMLBase.solve(cache::LinearSolve.LinearCache, alg::CudaOffloadFactori
 end
 
 function LinearSolve.do_factorization(alg::CudaOffloadFactorization, A, b, u)
-    A isa Union{AbstractMatrix,SciMLBase.AbstractDiffEqOperator} ||
+    A isa Union{AbstractMatrix, SciMLBase.AbstractDiffEqOperator} ||
         error("LU is not defined for $(typeof(A))")
 
     if A isa SciMLBase.AbstractDiffEqOperator
@@ -28,4 +29,4 @@ end
 
 export CudaOffloadFactorization
 
-end
+end

lib/LinearSolveCUDA/test/runtests.jl

@@ -2,40 +2,50 @@ using LinearSolve, LinearSolveCUDA, LinearAlgebra, SparseArrays
 using Test
 
 n = 8
-A = Matrix(I,n,n)
+A = Matrix(I, n, n)
 b = ones(n)
-A1 = A/1; b1 = rand(n); x1 = zero(b)
-A2 = A/2; b2 = rand(n); x2 = zero(b)
+A1 = A / 1;
+b1 = rand(n);
+x1 = zero(b);
+A2 = A / 2;
+b2 = rand(n);
+x2 = zero(b);
 
-prob1 = LinearProblem(A1, b1; u0=x1)
-prob2 = LinearProblem(A2, b2; u0=x2)
+prob1 = LinearProblem(A1, b1; u0 = x1)
+prob2 = LinearProblem(A2, b2; u0 = x2)
 
-cache_kwargs = (;verbose=true, abstol=1e-8, reltol=1e-8, maxiter=30,)
+cache_kwargs = (; verbose = true, abstol = 1e-8, reltol = 1e-8, maxiter = 30)
 
 function test_interface(alg, prob1, prob2)
-    A1 = prob1.A; b1 = prob1.b; x1 = prob1.u0
-    A2 = prob2.A; b2 = prob2.b; x2 = prob2.u0
+    A1 = prob1.A
+    b1 = prob1.b
+    x1 = prob1.u0
+    A2 = prob2.A
+    b2 = prob2.b
+    x2 = prob2.u0
 
     y = solve(prob1, alg; cache_kwargs...)
-    @test A1 *  y  ≈ b1
+    @test A1 * y ≈ b1
 
-    cache = SciMLBase.init(prob1,alg; cache_kwargs...) # initialize cache
+    cache = SciMLBase.init(prob1, alg; cache_kwargs...) # initialize cache
     y = solve(cache)
-    @test A1 *  y  ≈ b1
+    @test A1 * y ≈ b1
 
-    cache = LinearSolve.set_A(cache,copy(A2))
+    cache = LinearSolve.set_A(cache, copy(A2))
     y = solve(cache)
-    @test A2 *  y  ≈ b1
+    @test A2 * y ≈ b1
 
-    cache = LinearSolve.set_b(cache,b2)
+    cache = LinearSolve.set_b(cache, b2)
     y = solve(cache)
-    @test A2 *  y  ≈ b2
+    @test A2 * y ≈ b2
 
     return
 end
 
 test_interface(CudaOffloadFactorization(), prob1, prob2)
 
-A1 = prob1.A; b1 = prob1.b; x1 = prob1.u0
+A1 = prob1.A;
+b1 = prob1.b;
+x1 = prob1.u0;
 y = solve(prob1)
-@test A1 *  y  ≈ b1
+@test A1 * y ≈ b1

lib/LinearSolvePardiso/src/LinearSolvePardiso.jl

@@ -4,35 +4,35 @@ using Pardiso, LinearSolve, SciMLBase
 using UnPack
 
 Base.@kwdef struct PardisoJL <: LinearSolve.SciMLLinearSolveAlgorithm
-    nprocs::Union{Int,Nothing} = nothing
-    solver_type::Union{Int,Pardiso.Solver,Nothing} = nothing
-    matrix_type::Union{Int,Pardiso.MatrixType,Nothing} = nothing
-    iparm::Union{Vector{Tuple{Int,Int}},Nothing} = nothing
-    dparm::Union{Vector{Tuple{Int,Int}},Nothing} = nothing
+    nprocs::Union{Int, Nothing} = nothing
+    solver_type::Union{Int, Pardiso.Solver, Nothing} = nothing
+    matrix_type::Union{Int, Pardiso.MatrixType, Nothing} = nothing
+    iparm::Union{Vector{Tuple{Int, Int}}, Nothing} = nothing
+    dparm::Union{Vector{Tuple{Int, Int}}, Nothing} = nothing
 end
 
-MKLPardisoFactorize(; kwargs...) = PardisoJL(; solver_type=0, kwargs...)
-MKLPardisoIterate(; kwargs...) = PardisoJL(; solver_type=1, kwargs...)
+MKLPardisoFactorize(; kwargs...) = PardisoJL(; solver_type = 0, kwargs...)
+MKLPardisoIterate(; kwargs...) = PardisoJL(; solver_type = 1, kwargs...)
 LinearSolve.needs_concrete_A(alg::PardisoJL) = true
 
 # TODO schur complement functionality
 
-function LinearSolve.init_cacheval(alg::PardisoJL, A, b, u, Pl, Pr, maxiters, abstol, reltol, verbose)
+function LinearSolve.init_cacheval(alg::PardisoJL, A, b, u, Pl, Pr, maxiters, abstol,
+                                   reltol, verbose)
     @unpack nprocs, solver_type, matrix_type, iparm, dparm = alg
     A = convert(AbstractMatrix, A)
 
-    solver =
-        if Pardiso.PARDISO_LOADED[]
-            solver = Pardiso.PardisoSolver()
-            solver_type !== nothing && Pardiso.set_solver!(solver, solver_type)
+    solver = if Pardiso.PARDISO_LOADED[]
+        solver = Pardiso.PardisoSolver()
+        solver_type !== nothing && Pardiso.set_solver!(solver, solver_type)
 
-            solver
-        else
-            solver = Pardiso.MKLPardisoSolver()
-            nprocs !== nothing && Pardiso.set_nprocs!(solver, nprocs)
+        solver
+    else
+        solver = Pardiso.MKLPardisoSolver()
+        nprocs !== nothing && Pardiso.set_nprocs!(solver, nprocs)
 
-            solver
-        end
+        solver
+    end
 
     Pardiso.pardisoinit(solver) # default initialization
 
@@ -113,4 +113,4 @@ end
 
 export PardisoJL, MKLPardisoFactorize, MKLPardisoIterate
 
-end
+end

lib/LinearSolvePardiso/test/runtests.jl

@@ -1,9 +1,9 @@
 using LinearSolve, LinearSolvePardiso, SparseArrays, Random
 
 A1 = sparse([1.0 0 -2 3
-    0 5 1 2
-    -2 1 4 -7
-    3 2 -7 5])
+             0 5 1 2
+             -2 1 4 -7
+             3 2 -7 5])
 b1 = rand(4)
 prob1 = LinearProblem(A1, b1)
 
@@ -13,16 +13,13 @@ e = ones(n)
 e2 = ones(n - 1)
 A2 = spdiagm(-1 => im * e2, 0 => lambda * e, 1 => -im * e2)
 b2 = rand(n) + im * zeros(n)
-cache_kwargs = (; verbose=true, abstol=1e-8, reltol=1e-8, maxiter=30)
+cache_kwargs = (; verbose = true, abstol = 1e-8, reltol = 1e-8, maxiter = 30)
 
 prob2 = LinearProblem(A2, b2)
 
-for alg in (
-    PardisoJL(),
-    MKLPardisoFactorize(),
-    MKLPardisoIterate(),
-)
-
+for alg in (PardisoJL(),
+            MKLPardisoFactorize(),
+            MKLPardisoIterate())
     u = solve(prob1, alg; cache_kwargs...).u
     @test A1 * u ≈ b1
 
@@ -55,4 +52,4 @@ sol33 = solve(linsolve)
 
 @test sol11.u ≈ sol31.u
 @test sol12.u ≈ sol32.u
-@test sol13.u ≈ sol33.u
+@test sol13.u ≈ sol33.u

src/LinearSolve.jl

@@ -5,7 +5,7 @@ using RecursiveFactorization
 using Base: cache_dependencies, Bool
 import Base: eltype, adjoint, inv
 using LinearAlgebra
-using IterativeSolvers:Identity
+using IterativeSolvers: Identity
 using SparseArrays
 using SciMLBase: AbstractDiffEqOperator, AbstractLinearAlgorithm
 using Setfield