Refactor code

Author: juliohm

src/processes.jl

@@ -86,34 +86,4 @@ struct ConstantIntensity <: PointPatternAlgo end
 include("processes/binomial.jl")
 include("processes/poisson.jl")
 include("processes/cluster.jl")
-
-# ----------------
-# UNION PROCESSES
-# ----------------
-
-"""
-    UnionProcess(p₁, p₂)
-
-Union (or superposition) of spatial point processes `p₁` and `p₂`.
-"""
-struct UnionProcess{P₁<:PointProcess,P₂<:PointProcess} <: PointProcess
-  p₁::P₁
-  p₂::P₂
-end
-
-"""
-    p₁ ∪ p₂
-
-Return the union of point processes `p₁` and `p₂`.
-"""
-Base.union(p₁::PointProcess, p₂::PointProcess) = UnionProcess(p₁, p₂)
-
-ishomogeneous(p::UnionProcess) = ishomogeneous(p.p₁) && ishomogeneous(p.p₂)
-
-default_sampling_algorithm(::UnionProcess, ::Any) = nothing
-
-function rand_single(rng::Random.AbstractRNG, p::UnionProcess, g, ::Nothing)
-  pp₁ = rand(rng, p.p₁, g)
-  pp₂ = rand(rng, p.p₂, g)
-  PointSet([coordinates.(pp₁); coordinates.(pp₂)])
-end
+include("processes/union.jl")

src/processes/binomial.jl

@@ -15,7 +15,5 @@ ishomogeneous(p::BinomialProcess) = true
 
 default_sampling_algorithm(::BinomialProcess, ::Any) = ConstantIntensity()
 
-function rand_single(rng::Random.AbstractRNG, p::BinomialProcess, g, ::ConstantIntensity)
-  points = sample(rng, g, HomogeneousSampling(p.n))
-  PointSet(points)
-end
+rand_single(rng::Random.AbstractRNG, p::BinomialProcess, g, ::ConstantIntensity) =
+  PointSet(sample(rng, g, HomogeneousSampling(p.n)))

src/processes/cluster.jl

@@ -3,17 +3,17 @@
 # ------------------------------------------------------------------
 
 """
-    ClusterProcess(p, ofun)
+    ClusterProcess(proc, ofun)
 
-A cluster process with parent process `p` and offsprings generated
+A cluster process with parent process `proc` and offsprings generated
 with `ofun`. It is a function that takes a parent point and returns
 a point pattern from another point process.
 
-    ClusterProcess(p, o, gfun)
+    ClusterProcess(proc, offs, gfun)
 
-Alternatively, specify the parent process `p`, the offspring process `o`
-and the geometry function `gfun`. It is a function that takes a parent
-point and returns a geometry or domain for the offspring process.
+Alternatively, specify the parent process `proc`, the offspring process
+`offs` and the geometry function `gfun`. It is a function that takes a
+parent point and returns a geometry or domain for the offspring process.
 
 ## Examples
 
@@ -22,22 +22,22 @@ point and returns a geometry or domain for the offspring process.
 ```
 """
 struct ClusterProcess{P<:PointProcess,F<:Function} <: PointProcess
-  p::P
+  proc::P
   ofun::F
 end
 
 ClusterProcess(p::PointProcess, o::PointProcess, gfun::Function) =
   ClusterProcess(p, parent -> rand(o, gfun(parent)))
 
-default_sampling_algorithm(p::ClusterProcess, g) = nothing
+default_sampling_algorithm(::ClusterProcess, ::Any) = nothing
 
 function rand_single(rng::Random.AbstractRNG, p::ClusterProcess, g, ::Nothing)
   # retrieve parameters
   Dim = embeddim(g)
   T = coordtype(g)
 
   # generate parents
-  parents = rand_single(rng, p.p, g)
+  parents = rand(rng, p.proc, g)
 
   # generate offsprings
   offsprings = p.ofun.(parents)

src/processes/poisson.jl

@@ -15,17 +15,6 @@ struct PoissonProcess{L<:Union{Real,Function,AbstractVector}} <: PointProcess
   λ::L
 end
 
-Base.union(p₁::PoissonProcess{<:Real}, p₂::PoissonProcess{<:Real}) = PoissonProcess(p₁.λ + p₂.λ)
-
-Base.union(p₁::PoissonProcess{<:Function}, p₂::PoissonProcess{<:Function}) = PoissonProcess(x -> p₁.λ(x) + p₂.λ(x))
-
-Base.union(p₁::PoissonProcess{<:Real}, p₂::PoissonProcess{<:Function}) = PoissonProcess(x -> p₁.λ + p₂.λ(x))
-
-Base.union(p₁::PoissonProcess{<:Function}, p₂::PoissonProcess{<:Real}) = PoissonProcess(x -> p₁.λ(x) + p₂.λ)
-
-Base.union(p₁::PoissonProcess{<:AbstractVector}, p₂::PoissonProcess{<:AbstractVector}) =
-  PoissonProcess(x -> p₁.λ + p₂.λ)
-
 ishomogeneous(p::PoissonProcess{<:Real}) = true
 
 ishomogeneous(p::PoissonProcess{<:Function}) = false

src/processes/union.jl

@@ -0,0 +1,45 @@
+# ------------------------------------------------------------------
+# Licensed under the MIT License. See LICENSE in the project root.
+# ------------------------------------------------------------------
+
+"""
+    UnionProcess(p₁, p₂)
+
+Union (or superposition) of spatial point processes `p₁` and `p₂`.
+"""
+struct UnionProcess{P₁<:PointProcess,P₂<:PointProcess} <: PointProcess
+  p₁::P₁
+  p₂::P₂
+end
+
+ishomogeneous(p::UnionProcess) = ishomogeneous(p.p₁) && ishomogeneous(p.p₂)
+
+default_sampling_algorithm(::UnionProcess, ::Any) = nothing
+
+function rand_single(rng::Random.AbstractRNG, p::UnionProcess, g, ::Nothing)
+  pp₁ = rand(rng, p.p₁, g)
+  pp₂ = rand(rng, p.p₂, g)
+  PointSet([collect(pp₁); collect(pp₂)])
+end
+
+# ----------
+# OPERATION
+# ----------
+
+"""
+    p₁ ∪ p₂
+
+Return the union of point processes `p₁` and `p₂`.
+"""
+Base.union(p₁::PointProcess, p₂::PointProcess) = UnionProcess(p₁, p₂)
+
+Base.union(p₁::PoissonProcess{<:Real}, p₂::PoissonProcess{<:Real}) = PoissonProcess(p₁.λ + p₂.λ)
+
+Base.union(p₁::PoissonProcess{<:Function}, p₂::PoissonProcess{<:Function}) = PoissonProcess(x -> p₁.λ(x) + p₂.λ(x))
+
+Base.union(p₁::PoissonProcess{<:Real}, p₂::PoissonProcess{<:Function}) = PoissonProcess(x -> p₁.λ + p₂.λ(x))
+
+Base.union(p₁::PoissonProcess{<:Function}, p₂::PoissonProcess{<:Real}) = PoissonProcess(x -> p₁.λ(x) + p₂.λ)
+
+Base.union(p₁::PoissonProcess{<:AbstractVector}, p₂::PoissonProcess{<:AbstractVector}) =
+  PoissonProcess(x -> p₁.λ + p₂.λ)