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

@@ -2,18 +2,14 @@ using Documenter, SymbolicNumericIntegration
 
 include("pages.jl")
 
-makedocs(
-    sitename="SymbolicNumericIntegration.jl",
-    authors="Shahriar Iravanian",
-    modules=[SymbolicNumericIntegration],
-    clean=true,doctest=false,
-    format = Documenter.HTML(analytics = "UA-90474609-3",
-                             assets = ["assets/favicon.ico"],
-                             canonical="https://symbolicnumericintegration.sciml.ai/stable/"),
-    pages=pages
-)
+makedocs(sitename = "SymbolicNumericIntegration.jl",
+         authors = "Shahriar Iravanian",
+         modules = [SymbolicNumericIntegration],
+         clean = true, doctest = false,
+         format = Documenter.HTML(analytics = "UA-90474609-3",
+                                  assets = ["assets/favicon.ico"],
+                                  canonical = "https://symbolicnumericintegration.sciml.ai/stable/"),
+         pages = pages)
 
-deploydocs(
-   repo = "github.com/SciML/SymbolicNumericIntegration.jl.git";
-   push_preview = true
-)
+deploydocs(repo = "github.com/SciML/SymbolicNumericIntegration.jl.git";
+           push_preview = true)

docs/pages.jl

@@ -1,6 +1,6 @@
 # Put in a separate page so it can be used by SciMLDocs.jl
 
-pages=[
+pages = [
     "Home" => "index.md",
-    "symbolicnumericintegration.md"
-]
+    "symbolicnumericintegration.md",
+]

src/candidates.jl

@@ -1,7 +1,7 @@
 using DataStructures
 
 # this is the main heurisctic used to find the test fragments
-function generate_basis(eq, x; homotopy=true)
+function generate_basis(eq, x; homotopy = true)
     # if homotopy return generate_homotopy(eq, x) end
     eq = expand(eq)
     S = 0 #Set{Any}()
@@ -22,9 +22,9 @@ function generate_basis(eq, x; homotopy=true)
             C₂ = find_candidates(p, x)
         end
 
-        S += sum(c₁*c₂ for c₁ in C₁ for c₂ in C₂)
+        S += sum(c₁ * c₂ for c₁ in C₁ for c₂ in C₂)
     end
-    return unique([one(x); [equivalent(t,x) for t in terms(S)]])
+    return unique([one(x); [equivalent(t, x) for t in terms(S)]])
 end
 
 function expand_basis(basis, x)
@@ -36,8 +36,10 @@ function expand_basis(basis, x)
     return [one(x); [s for s in S]]
 end
 
-function closure(eq, x; max_terms=50)
-    if !isdependent(eq, x) return [one(x)] end
+function closure(eq, x; max_terms = 50)
+    if !isdependent(eq, x)
+        return [one(x)]
+    end
     D = Differential(x)
     S = Set{Any}()
     q = Queue{Any}()
@@ -47,7 +49,7 @@ function closure(eq, x; max_terms=50)
         y = dequeue!(q)
         enqueue_expr!(S, q, expand_derivatives(D(y)), x)
     end
-    unique([one(x); [s for s in S]; [s*x for s in S]])
+    unique([one(x); [s for s in S]; [s * x for s in S]])
 end
 
 function find_candidates(eq, x)
@@ -66,17 +68,19 @@ function find_candidates(eq, x)
     return unique([one(x); [s for s in S]])
 end
 
-function candidate_pow_minus(p, k; abstol=1e-8)
+function candidate_pow_minus(p, k; abstol = 1e-8)
     if isnan(poly_deg(p))
-        return [p^k, p^(k+1), log(p)]
+        return [p^k, p^(k + 1), log(p)]
     end
 
     x = var(p)
     d = poly_deg(p)
 
-    for j = 1:10  # will try 10 times to find the roots
+    for j in 1:10  # will try 10 times to find the roots
         r, s = find_roots(p, x)
-        if length(r) + length(s) >= d break end
+        if length(r) + length(s) >= d
+            break
+        end
     end
     s = s[1:2:end]
     r = nice_parameter.(r)
@@ -87,8 +91,8 @@ function candidate_pow_minus(p, k; abstol=1e-8)
     for i in eachindex(s)
         β = s[i]
         if abs(imag(β)) > abstol
-            push!(q, atan((x - real(β))/imag(β)))
-            push!(q, (1+x)*log(x^2 - 2*real(β)*x + abs2(β)))
+            push!(q, atan((x - real(β)) / imag(β)))
+            push!(q, (1 + x) * log(x^2 - 2 * real(β) * x + abs2(β)))
         else
             push!(q, log(x - real(β)))
         end
@@ -99,14 +103,14 @@ function candidate_pow_minus(p, k; abstol=1e-8)
     if k ≈ -1
         return [[p^k]; q]
     else
-        return [[p^k, p^(k+1)]; q]
+        return [[p^k, p^(k + 1)]; q]
     end
 end
 
 function candidate_sqrt(p, k)
     x = var(p)
 
-    h = Any[p^k, p^(k+1)]
+    h = Any[p^k, p^(k + 1)]
 
     if poly_deg(p) == 2
         r, s = find_roots(p, x)
@@ -115,18 +119,18 @@ function candidate_sqrt(p, k)
             if sum(r) ≈ 0
                 r₁ = abs(r[1])
                 if l > 0
-                    push!(h, acosh(x/r₁))
+                    push!(h, acosh(x / r₁))
                 else
-                    push!(h, asin(x/r₁))
+                    push!(h, asin(x / r₁))
                 end
             end
         elseif real(s[1]) ≈ 0
-            push!(h, asinh(x/imag.(s[1])))
+            push!(h, asinh(x / imag.(s[1])))
         end
     end
 
     Δ = expand_derivatives(Differential(x)(p))
-    push!(h, log(0.5*Δ + sqrt(p)))
+    push!(h, log(0.5 * Δ + sqrt(p)))
     return h
 end
 

src/homotopy.jl

@@ -13,19 +13,25 @@ function next_variable!(f, eq)
     return μ
 end
 
-transformer(eq::SymbolicUtils.Add, f) = sum(transformer(t,f) for t in arguments(eq); init=0)
-transformer(eq::SymbolicUtils.Mul, f) = prod(transformer(t,f) for t in arguments(eq); init=1)
-transformer(eq::SymbolicUtils.Div, f) = transformer(arguments(eq)[1],f) * transformer(inv(arguments(eq)[2]),f)
+function transformer(eq::SymbolicUtils.Add, f)
+    sum(transformer(t, f) for t in arguments(eq); init = 0)
+end
+function transformer(eq::SymbolicUtils.Mul, f)
+    prod(transformer(t, f) for t in arguments(eq); init = 1)
+end
+function transformer(eq::SymbolicUtils.Div, f)
+    transformer(arguments(eq)[1], f) * transformer(inv(arguments(eq)[2]), f)
+end
 
 function transformer(eq::SymbolicUtils.Pow, f)
     y, k = arguments(eq)
 
     if is_pos_int(k)
         μ = next_variable!(f, y)
-        return μ ^ k
+        return μ^k
     elseif is_neg_int(k)
         μ = next_variable!(f, inv(y))
-        return μ ^ -k
+        return μ^-k
     else
         return next_variable!(f, y^k)
     end
@@ -60,7 +66,7 @@ function generate_homotopy(eq, x)
     q, sub = transform(eq, x)
     S = 0
 
-    for i = 1:length(sub)
+    for i in 1:length(sub)
         μ = u[i]
         h₁, ∂h₁ = apply_partial_int_rules(sub[μ])
         h₂ = expand_derivatives(Differential(μ)(q))
@@ -71,7 +77,7 @@ function generate_homotopy(eq, x)
         S += expand((1 + h₁) * (1 + h₂))
     end
 
-    unique([one(x); [equivalent(t,x) for t in terms(S)]])
+    unique([one(x); [equivalent(t, x) for t in terms(S)]])
 end
 
 ##############################################################################
@@ -81,63 +87,57 @@ function ∂(x)
     return isequal(d, 0) ? 1 : d
 end
 
-partial_int_rules = [
-    @rule 𝛷(^(sin(~x), ~k::is_neg)) => 𝛷(^(csc(~x), -~k))
-    @rule 𝛷(^(cos(~x), ~k::is_neg)) => 𝛷(^(sec(~x), -~k))
-    @rule 𝛷(^(tan(~x), ~k::is_neg)) => 𝛷(^(cot(~x), -~k))
-    @rule 𝛷(^(csc(~x), ~k::is_neg)) => 𝛷(^(sin(~x), -~k))
-    @rule 𝛷(^(sec(~x), ~k::is_neg)) => 𝛷(^(cos(~x), -~k))
-    @rule 𝛷(^(cot(~x), ~k::is_neg)) => 𝛷(^(tan(~x), -~k))
-
-    @rule 𝛷(^(sinh(~x), ~k::is_neg)) => 𝛷(^(csch(~x), -~k))
-    @rule 𝛷(^(cosh(~x), ~k::is_neg)) => 𝛷(^(sech(~x), -~k))
-    @rule 𝛷(^(tanh(~x), ~k::is_neg)) => 𝛷(^(coth(~x), -~k))
-    @rule 𝛷(^(csch(~x), ~k::is_neg)) => 𝛷(^(sinh(~x), -~k))
-    @rule 𝛷(^(sech(~x), ~k::is_neg)) => 𝛷(^(cosh(~x), -~k))
-    @rule 𝛷(^(coth(~x), ~k::is_neg)) => 𝛷(^(tanh(~x), -~k))
-
-    @rule 𝛷(sin(~x)) => (cos(~x), ∂(~x))
-    @rule 𝛷(cos(~x)) => (sin(~x), ∂(~x))
-    @rule 𝛷(tan(~x)) => (log(cos(~x)), ∂(~x))
-    @rule 𝛷(csc(~x)) => (log(sin(~x)^-1 - cos(~x)*sin(~x)^-1), ∂(~x))
-    @rule 𝛷(sec(~x)) => (log(cos(~x)^-1 + sin(~x)*cos(~x)^-1), ∂(~x))
-    @rule 𝛷(cot(~x)) => (log(sin(~x)), ∂(~x))
-
-    @rule 𝛷(sinh(~x)) => (cosh(~x), ∂(~x))
-    @rule 𝛷(cosh(~x)) => (sinh(~x), ∂(~x))
-    @rule 𝛷(tanh(~x)) => (log(cosh(~x)), ∂(~x))
-    @rule 𝛷(csch(~x)) => (log(sinh(~x)^-1 + cosh(~x)*sinh(~x)^-1), ∂(~x))
-    @rule 𝛷(sech(~x)) => (log(cosh(~x)^-1 + sinh(~x)*cosh(~x)^-1), ∂(~x))
-    @rule 𝛷(coth(~x)) => (log(sinh(~x)), ∂(~x))
-
-    @rule 𝛷(asin(~x)) => (~x*asin(~x) + sqrt(1 - ~x*~x), ∂(~x))
-    @rule 𝛷(acos(~x)) => (~x*acos(~x) + sqrt(1 - ~x*~x), ∂(~x))
-    @rule 𝛷(atan(~x)) => (~x*atan(~x) + log(~x*~x + 1), ∂(~x))
-    @rule 𝛷(acsc(~x)) => (~x*acsc(~x) + acosh(~x), ∂(~x))     # needs an abs inside acosh
-    @rule 𝛷(asec(~x)) => (~x*asec(~x) + acosh(~x), ∂(~x))     # needs an abs inside acosh
-    @rule 𝛷(acot(~x)) => (~x*acot(~x) + log(~x*~x + 1), ∂(~x))
-
-    @rule 𝛷(asinh(~x)) => (~x*asinh(~x) + sqrt(~x*~x + 1), ∂(~x))
-    @rule 𝛷(acosh(~x)) => (~x*acosh(~x) + sqrt(~x*~x - 1), ∂(~x))
-    @rule 𝛷(atanh(~x)) => (~x*atanh(~x) + log(~x + 1), ∂(~x))
-    @rule 𝛷(acsch(~x)) => (acsch(~x), ∂(~x))
-    @rule 𝛷(asech(~x)) => (asech(~x), ∂(~x))
-    @rule 𝛷(acoth(~x)) => (~x*acot(~x) + log(~x + 1), ∂(~x))
-
-    @rule 𝛷(log(~x)) => (~x + ~x * log(~x), ∂(~x))
-
-    @rule 𝛷(^(~x, ~k::is_abs_half)) => (sum(candidate_sqrt(~x,~k); init=one(~x)), 1)
-    @rule 𝛷(^(~x::is_poly, ~k::is_neg)) => (sum(candidate_pow_minus(~x, ~k); init=one(~x)), 1)
-    @rule 𝛷(sqrt(~x)) => (sum(candidate_sqrt(~x,0.5); init=one(~x)), 1)
-    @rule 𝛷(^(sqrt(~x),-1)) => 𝛷(^(~x,-0.5))
-
-    @rule 𝛷(^(~x, -1)) => (log(~x), ∂(~x))
-    @rule 𝛷(1 / ~x) => 𝛷(^(~x, -1))
-    @rule 𝛷(^(~x, ~k)) => (^(~x, ~k+1), ∂(~x))
-
-    @rule 𝛷(exp(~x)) => (exp(~x), ∂(~x))
-    @rule 𝛷(1) => (𝑥, 1)
-    @rule 𝛷(~x) => ((~x + ^(~x,2)), ∂(~x))
-]
-
-apply_partial_int_rules(eq) = expand(Fixpoint(Prewalk(Chain(partial_int_rules))))(𝛷(value(eq)))
+partial_int_rules = [@rule 𝛷(^(sin(~x), ~k::is_neg)) => 𝛷(^(csc(~x), -~k))
+                     @rule 𝛷(^(cos(~x), ~k::is_neg)) => 𝛷(^(sec(~x), -~k))
+                     @rule 𝛷(^(tan(~x), ~k::is_neg)) => 𝛷(^(cot(~x), -~k))
+                     @rule 𝛷(^(csc(~x), ~k::is_neg)) => 𝛷(^(sin(~x), -~k))
+                     @rule 𝛷(^(sec(~x), ~k::is_neg)) => 𝛷(^(cos(~x), -~k))
+                     @rule 𝛷(^(cot(~x), ~k::is_neg)) => 𝛷(^(tan(~x), -~k))
+                     @rule 𝛷(^(sinh(~x), ~k::is_neg)) => 𝛷(^(csch(~x), -~k))
+                     @rule 𝛷(^(cosh(~x), ~k::is_neg)) => 𝛷(^(sech(~x), -~k))
+                     @rule 𝛷(^(tanh(~x), ~k::is_neg)) => 𝛷(^(coth(~x), -~k))
+                     @rule 𝛷(^(csch(~x), ~k::is_neg)) => 𝛷(^(sinh(~x), -~k))
+                     @rule 𝛷(^(sech(~x), ~k::is_neg)) => 𝛷(^(cosh(~x), -~k))
+                     @rule 𝛷(^(coth(~x), ~k::is_neg)) => 𝛷(^(tanh(~x), -~k))
+                     @rule 𝛷(sin(~x)) => (cos(~x), ∂(~x))
+                     @rule 𝛷(cos(~x)) => (sin(~x), ∂(~x))
+                     @rule 𝛷(tan(~x)) => (log(cos(~x)), ∂(~x))
+                     @rule 𝛷(csc(~x)) => (log(sin(~x)^-1 - cos(~x) * sin(~x)^-1), ∂(~x))
+                     @rule 𝛷(sec(~x)) => (log(cos(~x)^-1 + sin(~x) * cos(~x)^-1), ∂(~x))
+                     @rule 𝛷(cot(~x)) => (log(sin(~x)), ∂(~x))
+                     @rule 𝛷(sinh(~x)) => (cosh(~x), ∂(~x))
+                     @rule 𝛷(cosh(~x)) => (sinh(~x), ∂(~x))
+                     @rule 𝛷(tanh(~x)) => (log(cosh(~x)), ∂(~x))
+                     @rule 𝛷(csch(~x)) => (log(sinh(~x)^-1 + cosh(~x) * sinh(~x)^-1), ∂(~x))
+                     @rule 𝛷(sech(~x)) => (log(cosh(~x)^-1 + sinh(~x) * cosh(~x)^-1), ∂(~x))
+                     @rule 𝛷(coth(~x)) => (log(sinh(~x)), ∂(~x))
+                     @rule 𝛷(asin(~x)) => (~x * asin(~x) + sqrt(1 - ~x * ~x), ∂(~x))
+                     @rule 𝛷(acos(~x)) => (~x * acos(~x) + sqrt(1 - ~x * ~x), ∂(~x))
+                     @rule 𝛷(atan(~x)) => (~x * atan(~x) + log(~x * ~x + 1), ∂(~x))
+                     @rule 𝛷(acsc(~x)) => (~x * acsc(~x) + acosh(~x), ∂(~x))     # needs an abs inside acosh
+                     @rule 𝛷(asec(~x)) => (~x * asec(~x) + acosh(~x), ∂(~x))     # needs an abs inside acosh
+                     @rule 𝛷(acot(~x)) => (~x * acot(~x) + log(~x * ~x + 1), ∂(~x))
+                     @rule 𝛷(asinh(~x)) => (~x * asinh(~x) + sqrt(~x * ~x + 1), ∂(~x))
+                     @rule 𝛷(acosh(~x)) => (~x * acosh(~x) + sqrt(~x * ~x - 1), ∂(~x))
+                     @rule 𝛷(atanh(~x)) => (~x * atanh(~x) + log(~x + 1), ∂(~x))
+                     @rule 𝛷(acsch(~x)) => (acsch(~x), ∂(~x))
+                     @rule 𝛷(asech(~x)) => (asech(~x), ∂(~x))
+                     @rule 𝛷(acoth(~x)) => (~x * acot(~x) + log(~x + 1), ∂(~x))
+                     @rule 𝛷(log(~x)) => (~x + ~x * log(~x), ∂(~x))
+                     @rule 𝛷(^(~x, ~k::is_abs_half)) => (sum(candidate_sqrt(~x, ~k);
+                                                             init = one(~x)), 1);
+                     @rule 𝛷(^(~x::is_poly, ~k::is_neg)) => (sum(candidate_pow_minus(~x,
+                                                                                     ~k);
+                                                                 init = one(~x)), 1)
+                     @rule 𝛷(sqrt(~x)) => (sum(candidate_sqrt(~x, 0.5); init = one(~x)), 1);
+                     @rule 𝛷(^(sqrt(~x), -1)) => 𝛷(^(~x, -0.5))
+                     @rule 𝛷(^(~x, -1)) => (log(~x), ∂(~x))
+                     @rule 𝛷(1 / ~x) => 𝛷(^(~x, -1))
+                     @rule 𝛷(^(~x, ~k)) => (^(~x, ~k + 1), ∂(~x))
+                     @rule 𝛷(exp(~x)) => (exp(~x), ∂(~x))
+                     @rule 𝛷(1) => (𝑥, 1)
+                     @rule 𝛷(~x) => ((~x + ^(~x, 2)), ∂(~x))]
+
+function apply_partial_int_rules(eq)
+    expand(Fixpoint(Prewalk(Chain(partial_int_rules))))(𝛷(value(eq)))
+end