Merge pull request #18

Integral equations

Author: maltezfaria

.JuliaFormatter.toml

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

.github/workflows/FormatCheck.yml

@@ -0,0 +1,42 @@
+# modified from https://github.com/SciML/DiffEqDocs.jl/tree/master/.github/workflows
+name: format-check
+
+on:
+  push:
+    branches:
+      - 'main'
+    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'

.gitignore

@@ -6,4 +6,4 @@
 .gitignore
 .vscode/*
 Manifest.toml
-scratch/*
+sandbox/*

Project.toml

@@ -4,10 +4,14 @@ version = "0.2.5"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
+DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+NearestNeighbors = "b8a86587-4115-5ab1-83bc-aa920d37bbce"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 

benchmarks/clustertree_bench.jl

@@ -4,6 +4,6 @@ using BenchmarkTools
 
 n = 1_000_000
 
-pts      = rand(WPB.Point3D,n)
-splitter = WPB.GeometricSplitter(nmax=100)
-@btime WPB.ClusterTree($pts,$splitter;threads=false)
+pts = rand(WPB.Point3D, n)
+splitter = WPB.GeometricSplitter(; nmax=100)
+@btime WPB.ClusterTree($pts, $splitter; threads=false)

docs/make.jl

@@ -1,31 +1,27 @@
 using WavePropBase
 using Documenter
 
-DocMeta.setdocmeta!(WavePropBase, :DocTestSetup, :(using WavePropBase; using WriteVTK); recursive=true)
+DocMeta.setdocmeta!(WavePropBase,
+                    :DocTestSetup,
+                    :(using WavePropBase; using WriteVTK);
+                    recursive=true)
 
 makedocs(;
-    modules=[WavePropBase],
-    repo="https://github.com/WaveProp/WavePropBase.jl/blob/{commit}{path}#{line}",
-    sitename="WavePropBase.jl",
-    format=Documenter.HTML(;
-        prettyurls=get(ENV, "CI", "false") == "true",
-        canonical="https://WaveProp.github.io/WavePropBase.jl",
-        assets=String[],
-    ),
-    pages=[
-        "WavePropBase" => "index.md",
-        "Utils" => "utils.md",
-        "Geometry" => "geometry.md",
-        "Interpolation" => "interpolation.md",
-        "Integration" => "integration.md",
-        "Meshes" => "mesh.md",
-        "Trees" => "trees.md",
-        "IO" => "io.md",
-        "References" => "references.md"
-    ],
-)
+         modules=[WavePropBase],
+         repo="https://github.com/WaveProp/WavePropBase.jl/blob/{commit}{path}#{line}",
+         sitename="WavePropBase.jl",
+         format=Documenter.HTML(;
+                                prettyurls=get(ENV, "CI", "false") == "true",
+                                canonical="https://WaveProp.github.io/WavePropBase.jl",
+                                assets=String[]),
+         pages=["WavePropBase" => "index.md",
+                "Utils" => "utils.md",
+                "Geometry" => "geometry.md",
+                "Interpolation" => "interpolation.md",
+                "Integration" => "integration.md",
+                "Meshes" => "mesh.md",
+                "Trees" => "trees.md",
+                "IO" => "io.md",
+                "References" => "references.md"])
 
-deploydocs(;
-    repo="github.com/WaveProp/WavePropBase.jl",
-    devbranch="main",
-)
+deploydocs(; repo="github.com/WaveProp/WavePropBase.jl", devbranch="main")

src/Geometry/domain.jl

@@ -16,21 +16,21 @@ Return a vector of all elementary entities making up a domain.
 """
 entities(Ω::Domain) = Ω.entities
 
-Domain(ω::AbstractEntity) = Domain([ω,])
+Domain(ω::AbstractEntity) = Domain([ω])
 Domain() = Domain(AbstractEntity[])
 
-function Base.show(io::IO,d::Domain)
+function Base.show(io::IO, d::Domain)
     ents = entities(d)
     n = length(entities(d))
-    n == 1 ? print(io,"Domain with $n entity:\n") : print(io,"Domain with $n entities:")
+    n == 1 ? print(io, "Domain with $n entity:\n") : print(io, "Domain with $n entities:")
     for ent in ents
-        print(io,"\n\t $(ent)")
+        print(io, "\n\t $(ent)")
     end
     return io
 end
 
 function geometric_dimension(Ω::Domain)
-    l,u = extrema(geometric_dimension(ent) for ent in entities(Ω))
+    l, u = extrema(geometric_dimension(ent) for ent in entities(Ω))
     @assert l == u "geometric dimension of entities in a domain not equal"
     return u
 end
@@ -51,9 +51,9 @@ Return all the boundaries of the domain, i.e. the domain's skeleton.
 function skeleton(Ω::Domain)
     ents = AbstractEntity[]
     for ent in entities(Ω)
-        append!(ents,boundary(ent))
+        append!(ents, boundary(ent))
     end
-    Domain(unique!(ents))
+    return Domain(unique!(ents))
 end
 
 """
@@ -62,7 +62,7 @@ end
 Two `Domain`s are equal if all their entities are equal (regardless of order).
 """
 function Base.:(==)(Ω1::Domain, Ω2::Domain)
-    return issetequal(entities(Ω1),entities(Ω2))
+    return issetequal(entities(Ω1), entities(Ω2))
 end
 
 """
@@ -77,7 +77,7 @@ function Base.in(ω::ElementaryEntity, Ω::Domain)
     # TODO: should we really recurse on the boundary of the entities composing
     # the domain for determining if an entity is in a domain.
     for ent in ents
-        in(ω,Domain(boundary(ent))) && (return true)
+        in(ω, Domain(boundary(ent))) && (return true)
     end
     return false
 end
@@ -97,22 +97,23 @@ function Base.iterate(Ω::Domain, state=1)
         return nothing
     end
     # Return (result, state)
-    return (Ω[state], state+1)
+    return (Ω[state], state + 1)
 end
 
 Base.isempty(Ω::Domain) = length(entities(Ω)) == 0
 
 function Base.setdiff(Ω1::Domain, Ω2::Domain)
-    Domain(setdiff(entities(Ω1), entities(Ω2)))
+    return Domain(setdiff(entities(Ω1), entities(Ω2)))
 end
 
-function Base.union(Ω1::Domain,Ωs::Domain...)
-    ents = vcat(entities(Ω1),entities.(Ωs)...)
-    Domain(unique!(ents))
+function Base.union(Ω1::Domain, Ωs::Domain...)
+    ents = vcat(entities(Ω1), entities.(Ωs)...)
+    return Domain(unique!(ents))
 end
 Base.union(Ω::Domain) = Domain(unique(entities(Ω)))
 
-Base.append!(Ω1,Ω2) = (append!(entities(Ω1),entities(Ω2)); Ω1)
+Base.append!(Ω1, Ω2) = (append!(entities(Ω1), entities(Ω2));
+                        Ω1)
 
 """
     assertequaldim(Ω1::Domain,Ω2::Domain)
@@ -145,8 +146,8 @@ function Base.intersect(Ω1::Domain, Ω2::Domain)
     end
 end
 
-function Base.push!(Ω::Domain,ent::AbstractEntity)
-    push!(entities(Ω),ent)
+function Base.push!(Ω::Domain, ent::AbstractEntity)
+    return push!(entities(Ω), ent)
 end
 
 function Base.issubset(Ω1::Domain, Ω2::Domain)
@@ -163,11 +164,10 @@ Return a domain comprising the external boundary of Ω.
 """
 boundary(Ω::Domain) = external_boundary(Ω::Domain)
 
-
 """Return the internal boundaries inside a domain."""
 function internal_boundary(Ω::Domain)
     Ω1 = Domain(Ω[1])
-    γ  = Domain()
+    γ = Domain()
     for ω2 in Ω[2:end]
         Ω2 = Domain(ω2)
         γ1 = Domain(vcat(boundary.(entities(Ω1))...))
@@ -180,7 +180,7 @@ end
 
 """Return the external boundaries inside a domain."""
 function external_boundary(Ω::Domain)
-    return setdiff(skeleton(Ω),internal_boundary(Ω))
+    return setdiff(skeleton(Ω), internal_boundary(Ω))
 end
 
 """
@@ -192,20 +192,22 @@ function Base.keys(Ω::Domain, d::Integer)
     elseif d == geometric_dimension(Ω)
         return Vector{Tuple{Int64,Int64}}(vcat(key.(entities(Ω))))
     elseif d < geometric_dimension(Ω)
-        return unique(keys(skeleton(Ω),d))
+        return unique(keys(skeleton(Ω), d))
     else
         error("Asking for tags with dimension > dimension of domain")
     end
 end
 function Base.keys(Ω::Domain)
-    isempty(Ω) ? Tuple{Int64, Int64}[] : keys(Ω, geometric_dimension(Ω))
+    return isempty(Ω) ? Tuple{Int64,Int64}[] : keys(Ω, geometric_dimension(Ω))
 end
 
 """
 Return all tags of the elementary entities in the domain `Ω` corresponding to the dimensions contained in `dims`.
 """
-function Base.keys(Ω::Domain, dims::Vector{T}) where T <: Integer
-    tgs = Vector{Tuple{Int64, Int64}}(undef, 0)
-    for d in dims push!(tgs, keys(Ω, d)...) end
+function Base.keys(Ω::Domain, dims::Vector{T}) where {T<:Integer}
+    tgs = Vector{Tuple{Int64,Int64}}(undef, 0)
+    for d in dims
+        push!(tgs, keys(Ω, d)...)
+    end
     return tgs
 end