add OpenClose, OpenOpen, CloseClose

Author: rfourquet

src/RandomExtensions.jl

@@ -1,6 +1,6 @@
 module RandomExtensions
 
-export make, Uniform, Normal, Exponential, CloseOpen, Rand, Bernoulli
+export make, Uniform, Normal, Exponential, CloseOpen, OpenClose, OpenOpen, CloseClose, Rand, Bernoulli
 
 # re-exports from Random, which don't overlap with new functionality and not from misc.jl
 export rand!, AbstractRNG, MersenneTwister, RandomDevice

src/distributions.jl

@@ -155,16 +155,39 @@ Exponential(θ::T) where {T<:AbstractFloat} = Exponentialθ(θ)
 ## floats
 
 abstract type FloatInterval{T<:AbstractFloat} <: Uniform{T} end
-abstract type CloseOpen{T<:AbstractFloat} <: FloatInterval{T} end
 
-struct CloseOpen01{T<:AbstractFloat} <: CloseOpen{T} end # interval [0,1)
+abstract type CloseOpen{ T<:AbstractFloat} <: FloatInterval{T} end
+abstract type OpenClose{ T<:AbstractFloat} <: FloatInterval{T} end
+abstract type CloseClose{T<:AbstractFloat} <: FloatInterval{T} end
+abstract type OpenOpen{  T<:AbstractFloat} <: FloatInterval{T} end
+
 struct CloseOpen12{T<:AbstractFloat} <: CloseOpen{T} end # interval [1,2)
 
+struct CloseOpen01{ T<:AbstractFloat} <: CloseOpen{T}  end # interval [0,1)
+struct OpenClose01{ T<:AbstractFloat} <: OpenClose{T}  end # interval (0,1]
+struct CloseClose01{T<:AbstractFloat} <: CloseClose{T} end # interval [0,1]
+struct OpenOpen01{  T<:AbstractFloat} <: OpenOpen{T}   end # interval (0,1)
+
 struct CloseOpenAB{T<:AbstractFloat} <: CloseOpen{T} # interval [a,b)
     a::T
     b::T
 end
 
+struct OpenCloseAB{T<:AbstractFloat} <: OpenClose{T} # interval (a,b]
+    a::T
+    b::T
+end
+
+struct CloseCloseAB{T<:AbstractFloat} <: CloseClose{T} # interval [a,b]
+    a::T
+    b::T
+end
+
+struct OpenOpenAB{T<:AbstractFloat} <: OpenOpen{T} # interval (a,b)
+    a::T
+    b::T
+end
+
 const FloatInterval_64 = FloatInterval{Float64}
 const CloseOpen01_64   = CloseOpen01{Float64}
 const CloseOpen12_64   = CloseOpen12{Float64}
@@ -175,10 +198,29 @@ CloseOpen12(::Type{T}=Float64) where {T<:AbstractFloat} = CloseOpen12{T}()
 CloseOpen(::Type{T}=Float64) where {T<:AbstractFloat} = CloseOpen01{T}()
 CloseOpen(a::T, b::T) where {T<:AbstractFloat} = CloseOpenAB{T}(a, b)
 
+OpenClose(::Type{T}=Float64) where {T<:AbstractFloat} = OpenClose01{T}()
+OpenClose(a::T, b::T) where {T<:AbstractFloat} = OpenCloseAB{T}(a, b)
+
+CloseClose(::Type{T}=Float64) where {T<:AbstractFloat} = CloseClose01{T}()
+CloseClose(a::T, b::T) where {T<:AbstractFloat} = CloseCloseAB{T}(a, b)
+
+OpenOpen(::Type{T}=Float64) where {T<:AbstractFloat} = OpenOpen01{T}()
+OpenOpen(a::T, b::T) where {T<:AbstractFloat} = OpenOpenAB{T}(a, b)
+
 # convenience functions
+
 CloseOpen(a, b) = CloseOpen(AbstractFloat(a), AbstractFloat(b))
 CloseOpen(a::AbstractFloat, b::AbstractFloat) = CloseOpen(promote(a, b)...)
 
+OpenClose(a, b) = OpenClose(AbstractFloat(a), AbstractFloat(b))
+OpenClose(a::AbstractFloat, b::AbstractFloat) = OpenClose(promote(a, b)...)
+
+CloseClose(a, b) = CloseClose(AbstractFloat(a), AbstractFloat(b))
+CloseClose(a::AbstractFloat, b::AbstractFloat) = CloseClose(promote(a, b)...)
+
+OpenOpen(a, b) = OpenOpen(AbstractFloat(a), AbstractFloat(b))
+OpenOpen(a::AbstractFloat, b::AbstractFloat) = OpenOpen(promote(a, b)...)
+
 ## Bernoulli
 
 struct Bernoulli{T<:Number} <: Distribution{T}

src/sampling.jl

@@ -27,20 +27,47 @@ for CO in (:CloseOpen01, :CloseOpen12)
 end
 
 ### fall-back on Random definitions
+
 rand(r::AbstractRNG, ::SamplerTrivial{CloseOpen01{T}}) where {T} =
     rand(r, SamplerTrivial(Random.CloseOpen01{T}()))
 
 rand(r::AbstractRNG, ::SamplerTrivial{CloseOpen12{T}}) where {T} =
     rand(r, SamplerTrivial(Random.CloseOpen12{T}()))
 
+### new intervals 01
+
+# TODO: optimize for BigFloat
+
+for CO = (:OpenClose01, :OpenOpen01, :CloseClose01)
+    @eval Sampler(RNG::Type{<:AbstractRNG}, I::$CO{T}, n::Repetition) where {T} =
+              SamplerSimple(I, CloseOpen01(T))
+end
+
+rand(r::AbstractRNG, sp::SamplerSimple{OpenClose01{T}}) where {T} =
+    one(T) - rand(r, sp.data)
+
+rand(r::AbstractRNG, sp::SamplerSimple{OpenOpen01{T}}) where {T} =
+    while true
+        x = rand(r, sp.data)
+        x != zero(T) && return x
+    end
+
+rand(r::AbstractRNG, sp::SamplerSimple{CloseClose01{T}}) where {T} =
+    rand(r, sp.data) / prevfloat(one(T))
+
 ### CloseOpenAB
 
-Sampler(RNG::Type{<:AbstractRNG}, d::CloseOpenAB{T}, n::Repetition) where {T} =
-    SamplerTag{CloseOpenAB{T}}((a=d.a, d=d.b - d.a, sp=Sampler(RNG, CloseOpen01{T}(), n)))
+for (CO, CO01) = (CloseOpenAB => CloseOpen01,
+                  OpenCloseAB => OpenClose01,
+                  CloseCloseAB => CloseClose01,
+                  OpenOpenAB => OpenOpen01)
 
-rand(rng::AbstractRNG, sp::SamplerTag{CloseOpenAB{T}}) where {T} =
-    sp.data.a + sp.data.d  * rand(rng, sp.data.sp)
+    @eval Sampler(RNG::Type{<:AbstractRNG}, d::$CO{T}, n::Repetition) where {T} =
+        SamplerTag{$CO{T}}((a=d.a, d=d.b - d.a, sp=Sampler(RNG, $CO01{T}(), n)))
 
+    @eval rand(rng::AbstractRNG, sp::SamplerTag{$CO{T}}) where {T} =
+        sp.data.a + sp.data.d  * rand(rng, sp.data.sp)
+end
 
 ## Normal & Exponential
 

test/runtests.jl

@@ -247,6 +247,14 @@ end
         sp = Random.Sampler(MersenneTwister, RandomExtensions.CloseOpen01(F))
         @test rand(m, sp) isa F
         @test 0 <= rand(m, sp) < 1
+        for (CO, (l, r)) = (CloseOpen  => (<=, <),
+                            CloseClose => (<=, <=),
+                            OpenOpen   => (<,  <),
+                            OpenClose  => (<,  <=))
+            f = rand(CO(F))
+            @test f isa F
+            @test l(0, f) && r(f, 1)
+        end
         F ∈ (Float64, BigFloat) || continue # only types implemented in Random
         sp = Random.Sampler(MersenneTwister, RandomExtensions.CloseOpen12(F))
         @test rand(m, sp) isa F