Rename rand_single -> randsingle

Author: juliohm

src/processes.jl

@@ -24,23 +24,23 @@ inside geometry or domain `g`. Optionally specify sampling
 algorithm `algo` and random number generator `rng`.
 """
 Base.rand(rng::Random.AbstractRNG, p::PointProcess, g, n::Int; algo=default_sampling_algorithm(p, g)) =
-  [rand_single(rng, p, g, algo) for i in 1:n]
+  [randsingle(rng, p, g, algo) for i in 1:n]
 
 Base.rand(rng::Random.AbstractRNG, p::PointProcess, g; algo=default_sampling_algorithm(p, g)) =
-  rand_single(rng, p, g, algo)
+  randsingle(rng, p, g, algo)
 
 Base.rand(p::PointProcess, g, n::Int; algo=default_sampling_algorithm(p, g)) =
   rand(Random.GLOBAL_RNG, p, g, n; algo=algo)
 
 Base.rand(p::PointProcess, g; algo=default_sampling_algorithm(p, g)) = rand(Random.GLOBAL_RNG, p, g; algo=algo)
 
 """
-    rand_single(rng, p, g, algo)
+    randsingle(rng, p, g, algo)
 
 Generate a single realization of spatial point process
 `p` inside geometry or domain `g` with sampling `algo`.
 """
-function rand_single end
+function randsingle end
 
 """
     default_sampling_algorithm(p, g)

src/processes/binomial.jl

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

src/processes/cluster.jl

@@ -31,7 +31,7 @@ ClusterProcess(p::PointProcess, o::PointProcess, gfun::Function) =
 
 default_sampling_algorithm(::ClusterProcess, ::Any) = nothing
 
-function rand_single(rng::Random.AbstractRNG, p::ClusterProcess, g, ::Nothing)
+function randsingle(rng::Random.AbstractRNG, p::ClusterProcess, g, ::Nothing)
   # retrieve parameters
   Dim = embeddim(g)
   T = coordtype(g)

src/processes/poisson.jl

@@ -35,7 +35,7 @@ end
 # HOMOGENEOUS CASE
 #------------------
 
-function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Real}, g, ::ConstantIntensity)
+function randsingle(rng::Random.AbstractRNG, p::PoissonProcess{<:Real}, g, ::ConstantIntensity)
   # simulate number of points
   λ = p.λ
   V = measure(g)
@@ -49,18 +49,18 @@ end
 # INHOMOGENEOUS CASE
 #--------------------
 
-function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Function}, g, algo::LewisShedler)
+function randsingle(rng::Random.AbstractRNG, p::PoissonProcess{<:Function}, g, algo::LewisShedler)
   # simulate a homogeneous process
-  pp = rand_single(rng, PoissonProcess(algo.λmax), g, ConstantIntensity())
+  pp = randsingle(rng, PoissonProcess(algo.λmax), g, ConstantIntensity())
 
   # thin point pattern
   isnothing(pp) ? nothing : PointSet(collect(thin(pp, RandomThinning(x -> p.λ(x) / algo.λmax))))
 end
 
-rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Function}, d::Domain, algo::ConstantIntensity) =
-  rand_single(rng, PoissonProcess(p.λ.(centroid.(d))), d, algo)
+randsingle(rng::Random.AbstractRNG, p::PoissonProcess{<:Function}, d::Domain, algo::ConstantIntensity) =
+  randsingle(rng, PoissonProcess(p.λ.(centroid.(d))), d, algo)
 
-function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:AbstractVector}, d::Domain, algo::ConstantIntensity)
+function randsingle(rng::Random.AbstractRNG, p::PoissonProcess{<:AbstractVector}, d::Domain, algo::ConstantIntensity)
   # simulate number of points
   λ = p.λ
   V = measure.(d)

src/processes/union.jl

@@ -16,7 +16,7 @@ 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)
+function randsingle(rng::Random.AbstractRNG, p::UnionProcess, g, ::Nothing)
   pp₁ = rand(rng, p.p₁, g)
   pp₂ = rand(rng, p.p₂, g)
   PointSet([collect(pp₁); collect(pp₂)])