Merge pull request #28 from JuliaEarth/auto-juliaformatter-pr

[AUTO] JuliaFormatter.jl run

Author: juliohm

src/processes.jl

@@ -23,22 +23,16 @@ Generate `n` realizations of spatial point process `p`
 inside geometry `g`. Optionally specify sampling
 algorithm `algo` and random number generator `rng`.
 """
-Base.rand(rng::Random.AbstractRNG,
-          p::PointProcess, g::Geometry, n::Int;
-          algo=default_sampling_algorithm(p, g)) =
+Base.rand(rng::Random.AbstractRNG, p::PointProcess, g::Geometry, n::Int; algo=default_sampling_algorithm(p, g)) =
   [rand_single(rng, p, g, algo) for i in 1:n]
 
-Base.rand(rng::Random.AbstractRNG,
-          p::PointProcess, g::Geometry;
-          algo=default_sampling_algorithm(p, g)) =
+Base.rand(rng::Random.AbstractRNG, p::PointProcess, g::Geometry; algo=default_sampling_algorithm(p, g)) =
   rand_single(rng, p, g, algo)
 
-Base.rand(p::PointProcess, g::Geometry, n::Int;
-          algo=default_sampling_algorithm(p, g)) = 
+Base.rand(p::PointProcess, g::Geometry, n::Int; algo=default_sampling_algorithm(p, g)) =
   rand(Random.GLOBAL_RNG, p, g, n; algo=algo)
 
-Base.rand(p::PointProcess, g::Geometry;
-          algo=default_sampling_algorithm(p, g)) = 
+Base.rand(p::PointProcess, g::Geometry; algo=default_sampling_algorithm(p, g)) =
   rand(Random.GLOBAL_RNG, p, g; algo=algo)
 
 """

src/processes/binomial.jl

@@ -15,9 +15,7 @@ ishomogeneous(p::BinomialProcess) = true
 
 default_sampling_algorithm(::BinomialProcess, ::Geometry) = ProductSampling()
 
-function rand_single(rng::Random.AbstractRNG,
-                     p::BinomialProcess, b::Box{Dim,T},
-                     ::ProductSampling) where {Dim,T}
+function rand_single(rng::Random.AbstractRNG, p::BinomialProcess, b::Box{Dim,T}, ::ProductSampling) where {Dim,T}
   # region configuration
   lo, up = coordinates.(extrema(b))
 

src/processes/poisson.jl

@@ -11,17 +11,13 @@ struct PoissonProcess{L<:Union{Real,Function}} <: PointProcess
   λ::L
 end
 
-Base.union(p₁::PoissonProcess{<:Real}, p₂::PoissonProcess{<:Real}) =
-  PoissonProcess(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{<: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{<: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{<:Function}, p₂::PoissonProcess{<:Real}) = PoissonProcess(x -> p₁.λ(x) + p₂.λ)
 
 ishomogeneous(p::PoissonProcess{<:Real}) = true
 ishomogeneous(p::PoissonProcess{<:Function}) = false
@@ -33,12 +29,11 @@ default_sampling_algorithm(::PoissonProcess{<:Real}, ::Box) = ProductSampling()
 # HOMOGENEOUS CASE
 #------------------
 
-function rand_single(rng::Random.AbstractRNG,
-                     p::PoissonProcess{<:Real}, g::Geometry,
-                     ::DiscretizedSampling)
+function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Real}, g::Geometry, ::DiscretizedSampling)
   # simulate number of points
-  λ = p.λ; V = measure(g)
-  n = rand(rng, Poisson(λ*V))
+  λ = p.λ
+  V = measure(g)
+  n = rand(rng, Poisson(λ * V))
 
   # simulate homogeneous process
   pts = sample(g, HomogeneousSampling(n))
@@ -47,15 +42,14 @@ function rand_single(rng::Random.AbstractRNG,
   PointSet(collect(pts))
 end
 
-function rand_single(rng::Random.AbstractRNG,
-                     p::PoissonProcess{<:Real}, b::Box,
-                     ::ProductSampling)
+function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Real}, b::Box, ::ProductSampling)
   # region configuration
   lo, up = coordinates.(extrema(b))
 
   # simulate number of points
-  λ = p.λ; V = measure(b)
-  n = rand(rng, Poisson(λ*V))
+  λ = p.λ
+  V = measure(b)
+  n = rand(rng, Poisson(λ * V))
 
   # product of uniform distributions
   U = product_distribution([Uniform(lo[i], up[i]) for i in 1:embeddim(b)])
@@ -68,9 +62,7 @@ end
 # INHOMOGENEOUS CASE
 #--------------------
 
-function rand_single(rng::Random.AbstractRNG,
-                     p::PoissonProcess{<:Function}, b::Box,
-                     algo::DiscretizedSampling)
+function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Function}, b::Box, algo::DiscretizedSampling)
   # discretize region
   # TODO
 
@@ -81,9 +73,7 @@ function rand_single(rng::Random.AbstractRNG,
   # TODO
 end
 
-function rand_single(rng::Random.AbstractRNG,
-                     p::PoissonProcess{<:Function}, b::Box,
-                     algo::ThinnedSampling)
+function rand_single(rng::Random.AbstractRNG, p::PoissonProcess{<:Function}, b::Box, algo::ThinnedSampling)
   # Lewis-Shedler algorithm
   # TODO
-end
+end

src/processes/union.jl

@@ -23,9 +23,7 @@ ishomogeneous(p::UnionProcess) = ishomogeneous(p.p₁) && ishomogeneous(p.p₂)
 
 default_sampling_algorithm(::UnionProcess, ::Geometry) = UnionSampling()
 
-function rand_single(rng::Random.AbstractRNG,
-                     p::UnionProcess, g::Geometry,
-                     ::UnionSampling)
+function rand_single(rng::Random.AbstractRNG, p::UnionProcess, g::Geometry, ::UnionSampling)
   pp₁ = rand(rng, p.p₁, g)
   pp₂ = rand(rng, p.p₂, g)
 

src/thinning/random.jl

@@ -15,25 +15,21 @@ end
 # THINNING POINT PROCESS
 # -----------------------
 
-thin(p::PoissonProcess{<:Real}, t::RandomThinning{<:Real}) =
-  PoissonProcess(t.p * p.λ)
+thin(p::PoissonProcess{<:Real}, t::RandomThinning{<:Real}) = PoissonProcess(t.p * p.λ)
 
-thin(p::PoissonProcess{<:Function}, t::RandomThinning{<:Function}) =
-  PoissonProcess(x -> t.p(x) * p.λ(x))
+thin(p::PoissonProcess{<:Function}, t::RandomThinning{<:Function}) = PoissonProcess(x -> t.p(x) * p.λ(x))
 
-thin(p::PoissonProcess{<:Real}, t::RandomThinning{<:Function}) =
-  PoissonProcess(x -> t.p(x) * p.λ)
+thin(p::PoissonProcess{<:Real}, t::RandomThinning{<:Function}) = PoissonProcess(x -> t.p(x) * p.λ)
 
-thin(p::PoissonProcess{<:Function}, t::RandomThinning{<:Real}) =
-  PoissonProcess(x -> t.p * p.λ(x))
+thin(p::PoissonProcess{<:Function}, t::RandomThinning{<:Real}) = PoissonProcess(x -> t.p * p.λ(x))
 
 # -----------------------
 # THINNING POINT PATTERN
 # -----------------------
 
 function thin(pp::PointSet, t::RandomThinning{<:Real})
   draws = rand(Bernoulli(t.p), nelements(pp))
-  inds  = findall(isequal(1), draws)
+  inds = findall(isequal(1), draws)
   PointSet(coordinates(pp, inds))
 end
 

test/processes.jl

@@ -1,7 +1,7 @@
 @testset "Processes" begin
   @testset "Basic" begin
-    for p in [BinomialProcess(100), PoissonProcess(100.)]
-      b  = Box((0.,1.), (1.,2.))
+    for p in [BinomialProcess(100), PoissonProcess(100.0)]
+      b = Box((0.0, 1.0), (1.0, 2.0))
       pp = rand(p, b)
       xs = coordinates.(pp)
       @test all(0 .≤ first.(xs) .≤ 1)
@@ -14,30 +14,30 @@
   end
 
   @testset "Poisson" begin
-    p = PoissonProcess(100.)
-    t = Triangle((0.,0.), (1.,0.), (1.,1.))
+    p = PoissonProcess(100.0)
+    t = Triangle((0.0, 0.0), (1.0, 0.0), (1.0, 1.0))
     pp = rand(p, t)
     xs = coordinates.(pp)
     @test all(0 .≤ first.(xs) .≤ 1)
     @test all(0 .≤ last.(xs))
 
-    q = Quadrangle((0.,0.), (1.,0.), (1.,1.), (0.,1.))
+    q = Quadrangle((0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0))
     pp = rand(p, q)
     xs = coordinates.(pp)
     @test all(0 .≤ first.(xs) .≤ 1)
     @test all(0 .≤ last.(xs) .≤ 1)
   end
 
   @testset "Union" begin
-    b  = Box((0.,0.), (100.,100.))
+    b = Box((0.0, 0.0), (100.0, 100.0))
     p₁ = BinomialProcess(50)
     p₂ = BinomialProcess(50)
-    p  = p₁ ∪ p₂ # 100 points
+    p = p₁ ∪ p₂ # 100 points
 
     s = rand(p, b, 2)
     @test length(s) == 2
     @test s[1] isa PointSet
     @test s[2] isa PointSet
-    @test nelements.(s) == [100,100]
+    @test nelements.(s) == [100, 100]
   end
 end

test/runtests.jl

@@ -4,9 +4,7 @@ using GeoStatsBase
 using Test, Random
 
 # list of tests
-testfiles = [
-  "processes.jl"
-]
+testfiles = ["processes.jl"]
 
 @testset "PointPatterns.jl" begin
   for testfile in testfiles