Refactoring

Author: juliohm

src/PointPatterns.jl

@@ -23,7 +23,8 @@ export
   ishomogeneous,
 
   # algorithms
-  PointPatternAlgorithm,
+  PointPatternAlgo,
+  ConstantIntensity,
   LewisShedler,
 
   # thinning methods

src/processes.jl

@@ -55,31 +55,31 @@ function default_sampling_algorithm end
 # -------------------------
 
 """
-    PointPatternAlgorithm
+    PointPatternAlgo
 
-An algorithm for sampling point patterns.
+A method for sampling point patterns.
 """
-abstract type PointPatternAlgorithm end
+abstract type PointPatternAlgo end
 
 """
     LewisShedler(λmax)
 
 Generate sample using Lewis-Shedler algorithm (1979) with
 maximum real value `λmax` of the intensity function.
 """
-struct LewisShedler{T<:Real} <: PointPatternAlgorithm
+struct LewisShedler{T<:Real} <: PointPatternAlgo
   λmax::T
 end
 
 """
-    DiscretizedSampling()
+    ConstantIntensity()
 
 Generate sample assuming the intensity is constant over a `Geometry`
 or piecewise constant over a `Domain`.
 """
-struct DiscretizedSampling <: PointPatternAlgorithm end
+struct ConstantIntensity <: PointPatternAlgo end
 
-struct UnionSampling <: PointPatternAlgorithm end
+struct UnionSampling <: PointPatternAlgo end
 
 #-----------------
 # IMPLEMENTATIONS

src/processes/binomial.jl

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

src/processes/poisson.jl

@@ -32,7 +32,7 @@ ishomogeneous(p::PoissonProcess{<:Function}) = false
 
 ishomogeneous(p::PoissonProcess{<:AbstractVector}) = false
 
-default_sampling_algorithm(::PoissonProcess, ::Any) = DiscretizedSampling()
+default_sampling_algorithm(::PoissonProcess, ::Any) = ConstantIntensity()
 
 default_sampling_algorithm(p::PoissonProcess{<:Function}, g) = LewisShedler(default_lambda_max(p, g))
 
@@ -46,7 +46,7 @@ end
 # HOMOGENEOUS CASE
 #------------------
 
-function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Real}, g, ::DiscretizedSampling)
+function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Real}, g, ::ConstantIntensity)
   # simulate number of points
   λ = p.λ
   V = measure(g)
@@ -69,16 +69,16 @@ end
 
 function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Function}, g, algo::LewisShedler)
   # simulate a homogeneous process
-  pp = rand_single(rng, PoissonProcess(algo.λmax), g, DiscretizedSampling())
+  pp = rand_single(rng, PoissonProcess(algo.λmax), g, ConstantIntensity())
 
   # thin point pattern
   thin(pp, RandomThinning(x -> p.λ(x) / algo.λmax))
 end
 
-rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Function}, d::Domain, algo::DiscretizedSampling) =
+rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Function}, d::Domain, algo::ConstantIntensity) =
   rand_single(rng, PoissonProcess(p.λ.(centroid.(d))), d, algo)
 
-function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:AbstractVector}, d::Domain, algo::DiscretizedSampling)
+function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:AbstractVector}, d::Domain, algo::ConstantIntensity)
   # simulate number of points
   λ = p.λ
   V = measure.(d)

test/processes.jl

@@ -53,7 +53,7 @@
       @test all(∈(g), pp)
 
       g = discretize(g)
-      pp = rand(p, g, algo=PointPatterns.DiscretizedSampling())
+      pp = rand(p, g, algo=ConstantIntensity())
       @test all(∈(g), g)
     end