autoformat with Runic

finish migration to `Runic`

Author: maltezfaria

.JuliaFormatter.toml

@@ -0,0 +1,6 @@
+# This file contains a list of commits that should be ignored by git blame.
+# To use this file, run: git config blame.ignoreRevsFile .git-blame-ignore-revs
+# See: https://git-scm.com/docs/git-blame#Documentation/git-blame.txt---ignore-revs-fileltfilegt
+
+# Format all code with Runic.jl (replacing JuliaFormatter)
+e50743f8a5d515880f4c9a4d1f7532304957eb63

.git-blame-ignore-revs

@@ -22,13 +22,13 @@ jobs:
           version: ${{ matrix.julia-version }}
 
       - uses: actions/checkout@v1
-      - name: Install JuliaFormatter and format
+      - name: Install Runic 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"))'
+        # julia  -e 'using Pkg; Pkg.add(PackageSpec(name="Runic", version="0.1.0"))'
         run: |
-          julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter"))'
-          julia  -e 'using JuliaFormatter; format(".", verbose=true)'
+          julia  -e 'using Pkg; Pkg.add(PackageSpec(name="Runic"))'
+          julia  -e 'using Runic; format(".", verbose=true)'
       - name: Format check
         run: |
           julia -e '

.github/workflows/FormatCheck.yml

@@ -4,6 +4,7 @@
 [![Dev](https://img.shields.io/badge/docs-dev-blue.svg)](https://IntegralEquations.github.io/ElementaryPDESolutions.jl/dev/)
 [![Build Status](https://github.com/IntegralEquations/ElementaryPDESolutions.jl/actions/workflows/CI.yml/badge.svg?branch=main)](https://github.com/IntegralEquations/ElementaryPDESolutions.jl/actions/workflows/CI.yml?query=branch%3Amain)
 [![Coverage](https://codecov.io/gh/IntegralEquations/ElementaryPDESolutions.jl/branch/main/graph/badge.svg)](https://codecov.io/gh/IntegralEquations/ElementaryPDESolutions.jl)
+[![code style: runic](https://img.shields.io/badge/code_style-%E1%9A%B1%E1%9A%A2%E1%9A%BE%E1%9B%81%E1%9A%B2-black)](https://github.com/fredrikekre/Runic.jl)
 [![Aqua
 QA](https://raw.githubusercontent.com/JuliaTesting/Aqua.jl/master/badge.svg)](https://github.com/JuliaTesting/Aqua.jl)
 

README.md

@@ -1,23 +1,30 @@
 using ElementaryPDESolutions
 using Documenter
 
-DocMeta.setdocmeta!(ElementaryPDESolutions, :DocTestSetup,
-                    :(using ElementaryPDESolutions, StaticArrays);
-                    recursive=true)
+DocMeta.setdocmeta!(
+    ElementaryPDESolutions, :DocTestSetup,
+    :(using ElementaryPDESolutions, StaticArrays);
+    recursive = true
+)
 
 makedocs(;
-         modules=[ElementaryPDESolutions],
-         authors="Thomas G. Anderson, Luiz M. Faria",
-         repo="https://github.com/IntegralEquations/ElementaryPDESolutions.jl/blob/{commit}{path}#{line}",
-         sitename="ElementaryPDESolutions.jl",
-         format=Documenter.HTML(;
-                                prettyurls=get(ENV, "CI", "false") == "true",
-                                canonical="https://IntegralEquations.github.io/ElementaryPDESolutions.jl",
-                                edit_link="main",
-                                assets=String[]),
-         pages=["Home" => "index.md",
-                "Docstrings" => "docstrings.md"])
+    modules = [ElementaryPDESolutions],
+    authors = "Thomas G. Anderson, Luiz M. Faria",
+    repo = "https://github.com/IntegralEquations/ElementaryPDESolutions.jl/blob/{commit}{path}#{line}",
+    sitename = "ElementaryPDESolutions.jl",
+    format = Documenter.HTML(;
+        prettyurls = get(ENV, "CI", "false") == "true",
+        canonical = "https://IntegralEquations.github.io/ElementaryPDESolutions.jl",
+        edit_link = "main",
+        assets = String[]
+    ),
+    pages = [
+        "Home" => "index.md",
+        "Docstrings" => "docstrings.md",
+    ]
+)
 
 deploydocs(;
-           repo="github.com/IntegralEquations/ElementaryPDESolutions.jl",
-           devbranch="main")
+    repo = "github.com/IntegralEquations/ElementaryPDESolutions.jl",
+    devbranch = "main"
+)

docs/make.jl

@@ -5,64 +5,82 @@ import DynamicPolynomials: @polyvar
 using FixedPolynomials: FixedPolynomials
 
 function __init__()
-    @info "Loading ElementaryPDESolutions.jl FixedPolynomials extension"
+    return @info "Loading ElementaryPDESolutions.jl FixedPolynomials extension"
 end
 
-struct VecPolyFastEvaluator{N,S,T}
+struct VecPolyFastEvaluator{N, S, T}
     N::Int64
     PolSystem::FixedPolynomials.System{S}
-    cfg::FixedPolynomials.JacobianConfig{T,S}
+    cfg::FixedPolynomials.JacobianConfig{T, S}
 end
 
-struct ScaPolyFastEvaluator{N,T}
+struct ScaPolyFastEvaluator{N, T}
     N::Int64
     Pol::FixedPolynomials.Polynomial{T}
-    r::FixedPolynomials.GradientDiffResult{T,Vector{T}}
+    r::FixedPolynomials.GradientDiffResult{T, Vector{T}}
     cfg::FixedPolynomials.GradientConfig{T}
 end
 
-function VecPolyFastEvaluator(N, PolSystem::FixedPolynomials.System{S},
-                              cfg::FixedPolynomials.JacobianConfig{T,S}) where {S,T}
-    return VecPolyFastEvaluator{N,S,T}(N, PolSystem, cfg)
+function VecPolyFastEvaluator(
+        N, PolSystem::FixedPolynomials.System{S},
+        cfg::FixedPolynomials.JacobianConfig{T, S}
+    ) where {S, T}
+    return VecPolyFastEvaluator{N, S, T}(N, PolSystem, cfg)
 end
 
-function ScaPolyFastEvaluator(N, Pol, r::FixedPolynomials.GradientDiffResult{T},
-                              cfg::FixedPolynomials.GradientConfig{T}) where {T}
-    return ScaPolyFastEvaluator{N,T}(N, Pol, r, cfg)
+function ScaPolyFastEvaluator(
+        N, Pol, r::FixedPolynomials.GradientDiffResult{T},
+        cfg::FixedPolynomials.GradientConfig{T}
+    ) where {T}
+    return ScaPolyFastEvaluator{N, T}(N, Pol, r, cfg)
 end
 
-Base.length(VPFE::VecPolyFastEvaluator{N,S,T}) where {N,S,T} = length(VPFE.PolSystem)
+Base.length(VPFE::VecPolyFastEvaluator{N, S, T}) where {N, S, T} = length(VPFE.PolSystem)
 
 """
     fast_evaluate_with_jacobian!(vals::AbstractArray{S}, grad::AbstractArray{S}, x::AbstractVector{S}, VPFE::VecPolyFastEvaluator{N,S,T})
 
 Evaluate an M-length vector of `N`-variate polynomials `VPFE` at point `x`, with values placed in the vector `vals` and its gradient placed in the array `grad` of size MxN.
 """
-function ElementaryPDESolutions.fast_evaluate_with_jacobian!(vals::AbstractArray{S},
-                                                             grad::AbstractArray{S},
-                                                             x::AbstractVector{S},
-                                                             VPFE::VecPolyFastEvaluator{N,S,
-                                                                                        T}) where {N,
-                                                                                                   S,
-                                                                                                   T}
+function ElementaryPDESolutions.fast_evaluate_with_jacobian!(
+        vals::AbstractArray{S},
+        grad::AbstractArray{S},
+        x::AbstractVector{S},
+        VPFE::VecPolyFastEvaluator{
+            N, S,
+            T,
+        }
+    ) where {
+        N,
+        S,
+        T,
+    }
     @assert length(vals) == length(VPFE.PolSystem)
     @assert size(grad) == (length(VPFE.PolSystem), N)
-    return FixedPolynomials.evaluate_and_jacobian!(vals, grad, VPFE.PolSystem, x,
-                                                   VPFE.cfg)
+    return FixedPolynomials.evaluate_and_jacobian!(
+        vals, grad, VPFE.PolSystem, x,
+        VPFE.cfg
+    )
 end
 
 """
     fast_evaluate_with_jacobian!(vals::AbstractArray{S}, grad::AbstractArray{S}, x::AbstractVector{S}, SPFE::ScaPolyFastEvaluator{N,S,T})
 
 Evaluate an `N`-variate polynomial `SPFE` at point `x`, with values placed in the vector `vals` and its gradient placed in the array `grad`.
 """
-function ElementaryPDESolutions.fast_evaluate_with_gradient!(vals::AbstractArray{S},
-                                                             grad::AbstractArray{S},
-                                                             x::AbstractVector{S},
-                                                             SPFE::ScaPolyFastEvaluator{N,
-                                                                                        T}) where {N,
-                                                                                                   S,
-                                                                                                   T}
+function ElementaryPDESolutions.fast_evaluate_with_gradient!(
+        vals::AbstractArray{S},
+        grad::AbstractArray{S},
+        x::AbstractVector{S},
+        SPFE::ScaPolyFastEvaluator{
+            N,
+            T,
+        }
+    ) where {
+        N,
+        S,
+        T,
+    }
     @assert SPFE.N == length(x)
     @assert length(grad) == N
     FixedPolynomials.gradient!(SPFE.r, SPFE.Pol, x, SPFE.cfg)
@@ -75,10 +93,14 @@ end
 
 Evaluate a vector of polynomials `VPFE` at point `x`, with values placed in the vector `vals`.
 """
-function ElementaryPDESolutions.fast_evaluate!(vals::AbstractArray{S}, x::AbstractVector{S},
-                                               VPFE::VecPolyFastEvaluator{N,S,T}) where {N,
-                                                                                         S,
-                                                                                         T}
+function ElementaryPDESolutions.fast_evaluate!(
+        vals::AbstractArray{S}, x::AbstractVector{S},
+        VPFE::VecPolyFastEvaluator{N, S, T}
+    ) where {
+        N,
+        S,
+        T,
+    }
     @assert VPFE.N == length(x)
     @assert length(vals) == length(VPFE.PolSystem)
     return FixedPolynomials.evaluate!(vals, VPFE.PolSystem, x, VPFE.cfg)
@@ -89,9 +111,13 @@ end
 
 Evaluate polynomial `SPFE` at point `x`, with value placed in `val`.
 """
-function ElementaryPDESolutions.fast_evaluate!(val::AbstractArray{S}, x::AbstractVector{S},
-                                               SPFE::ScaPolyFastEvaluator{N,T}) where {N,S,
-                                                                                       T}
+function ElementaryPDESolutions.fast_evaluate!(
+        val::AbstractArray{S}, x::AbstractVector{S},
+        SPFE::ScaPolyFastEvaluator{N, T}
+    ) where {
+        N, S,
+        T,
+    }
     @assert SPFE.N == length(x)
     return val = FixedPolynomials.evaluate(SPFE.Pol, x, SPFE.cfg)
 end
@@ -103,9 +129,15 @@ Perform precomputations for fast evaluation of a `Vector` of `N`-variate
 `Polynomial` of input type `S`, with coefficients of type T.  Return a
 `VecPolyFastEvaluator` object for online use.
 """
-function ElementaryPDESolutions.assemble_fastevaluator(Pols::Vector{ElementaryPDESolutions.Polynomial{N,
-                                                                                                      T}},
-                                                       ::Type{S}) where {N,S,T}
+function ElementaryPDESolutions.assemble_fastevaluator(
+        Pols::Vector{
+            ElementaryPDESolutions.Polynomial{
+                N,
+                T,
+            },
+        },
+        ::Type{S}
+    ) where {N, S, T}
     if N == 1
         @polyvar x
     elseif N == 2
@@ -132,8 +164,10 @@ function ElementaryPDESolutions.assemble_fastevaluator(Pols::Vector{ElementaryPD
         elseif N == 2
             PolArray[polind] = FixedPolynomials.Polynomial(exp_data, coeff_data, [:x, :y])
         else
-            PolArray[polind] = FixedPolynomials.Polynomial(exp_data, coeff_data,
-                                                           [:x, :y, :z])
+            PolArray[polind] = FixedPolynomials.Polynomial(
+                exp_data, coeff_data,
+                [:x, :y, :z]
+            )
         end
     end
     PolSystem = FixedPolynomials.System(PolArray)
@@ -147,9 +181,13 @@ end
 Perform precomputations for fast evaluation of a `Polynomial` on points of type `S`.
 Return a `ScaPolyFastEvaluator` object for online use.
 """
-function ElementaryPDESolutions.assemble_fastevaluator(Pol::ElementaryPDESolutions.Polynomial{N,
-                                                                                              T},
-                                                       ::Type{S}) where {N,S,T}
+function ElementaryPDESolutions.assemble_fastevaluator(
+        Pol::ElementaryPDESolutions.Polynomial{
+            N,
+            T,
+        },
+        ::Type{S}
+    ) where {N, S, T}
     if N == 1
         @polyvar x
     elseif N == 2