Bugfixes and tests

Author: cscherrer

src/combinators/product.jl

@@ -72,6 +72,10 @@ function logdensity(d::ProductMeasure{F,T}, x::Tuple) where {F,T<:Tuple}
     mapreduce(logdensity, +, d.f.(d.pars), x)
 end
 
+function Base.rand(rng::AbstractRNG, ::Type{T}, d::ProductMeasure{F,I}) where {T,F,I<:Tuple}
+    rand.(d.pars)
+end
+
 ###############################################################################
 # I <: AbstractArray
 
@@ -100,6 +104,11 @@ function Base.show(io::IO, d::ProductMeasure{F,I}) where {F, I<:CartesianIndices
     print(io, ")")
 end
 
+
+# function Base.rand(rng::AbstractRNG, ::Type{T}, d::ProductMeasure{F,I}) where {T,F,I<:CartesianIndices}
+
+# end
+
 ###############################################################################
 # I <: Base.Generator
 
@@ -113,6 +122,15 @@ function logdensity(d::ProductMeasure{F,I}, x) where {F, I<:Base.Generator}
 end
 
 
+function Base.rand(rng::AbstractRNG, ::Type{T}, d::ProductMeasure{F,I}) where {T,F,I<:Base.Generator}
+    mar = marginals(d)
+    elT = typeof(rand(rng, T, first(mar)))
+
+    sz = size(mar)
+    r = ResettableRNG(rng, rand(rng, UInt))
+    Base.Generator(s -> rand(r, d.pars.f(s)), d.pars.iter)
+end
+
 function Base.rand(rng::AbstractRNG, ::Type{T}, d::ProductMeasure{F,I}) where {T,F,I<:Base.Generator}
     mar = marginals(d)
     elT = typeof(rand(rng, T, first(mar)))
@@ -123,7 +141,8 @@ function Base.rand(rng::AbstractRNG, ::Type{T}, d::ProductMeasure{F,I}) where {T
 end
 
 @propagate_inbounds function Random.rand!(rng::AbstractRNG, d::ProductMeasure, x::AbstractArray)
-    T = float(eltype(x))
+    # TODO: Generalize this
+    T = Float64
     for(j,m) in zip(eachindex(x), marginals(d))
         @inbounds x[j] = rand(rng, T, m)
     end
@@ -135,41 +154,6 @@ end
 
 
 
-# @propagate_inbounds function MeasureBase.logdensity(d::ProductMeasure{A}, x) where{T, A<:AbstractArray{T,1}}
-#     data = marginals(d)
-#     @boundscheck size(data) == size(x) || throw(BoundsError)
-#     @tullio s = logdensity(data[i], x[i])
-#     s
-# end
-
-# @propagate_inbounds function MeasureBase.logdensity(d::ProductMeasure{A}, x) where{T, A<:AbstractArray{T,2}}
-#     data = marginals(d)
-#     @boundscheck size(data) == size(x) || throw(BoundsError)
-#     @tullio s = @inbounds logdensity(data[i,j], x[i,j])
-#     s
-# end
-
-# @propagate_inbounds function MeasureBase.logdensity(d::ProductMeasure{A}, x) where{T, A<:AbstractArray{T,3}}
-#     data = marginals(d)
-#     @boundscheck size(data) == size(x) || throw(BoundsError)
-#     @tullio s = @inbounds logdensity(data[i,j,k], x[i,j,k])
-#     s
-# end
-
-# @propagate_inbounds function MeasureBase.logdensity(d::ProductMeasure{A}, x) where{T, A<:AbstractArray{T,4}}
-#     data = marginals(d)
-#     @boundscheck size(data) == size(x) || throw(BoundsError)
-#     @tullio s = @inbounds logdensity(data[i,j,k,l], x[i,j,k,l])
-#     s
-# end
-
-# @propagate_inbounds function MeasureBase.logdensity(d::ProductMeasure{A}, x) where{T, A<:AbstractArray{T,5}}
-#     data = marginals(d)
-#     @boundscheck size(data) == size(x) || throw(BoundsError)
-#     @tullio s = @inbounds logdensity(data[i,j,k,l,m], x[i,j,k,l,m])
-#     s
-# end
-
 export rand!
 using Random: rand!, GLOBAL_RNG, AbstractRNG
 

test/runtests.jl

@@ -50,11 +50,11 @@ test_measures = [
     Dirac(π)
     Lebesgue(ℝ)
     Dirac(0.0) + Lebesgue(ℝ)
+    SpikeMixture(Lebesgue(ℝ), 2)
     # Normal() ⊙ Cauchy()
 ]
 
 testbroken_measures = [
-    SpikeMixture(Lebesgue(ℝ), 2)
     # InverseGamma(2) # Not defined yet
     # MvNormal(I(3)) # Entirely broken for now
     CountingMeasure(Float64)
@@ -124,19 +124,20 @@ end
     end
 end
 
-# @testset "For" begin
-#     FORDISTS = [
-#         For(1:10) do j Normal(μ=j) end
-#         For(4,3) do μ,σ Normal(μ,σ) end
-#         For(1:4, 1:4) do μ,σ Normal(μ,σ) end
-#         For(eachrow(rand(4,2))) do x Normal(x[1], x[2]) end
-#         For(rand(4), rand(4)) do μ,σ Normal(μ,σ) end
-#     ]
-
-#     for d in FORDISTS
-#         @test logdensity(d, rand(d)) isa Float64
-#     end
-# end
+@testset "For" begin
+    FORDISTS = [
+        For(1:10) do j Dirac(j) end
+        For(4,3) do i,j Dirac(i) ⊗ Dirac(j) end
+        For(1:4, 1:4) do i,j Dirac(i) ⊗ Dirac(j) end
+        For(eachrow(rand(4,2))) do x Dirac(x[1]) ⊗ Dirac(x[2]) end
+        For(rand(4), rand(4)) do i,j Dirac(i) ⊗ Dirac(j) end
+    ]
+
+    for d in FORDISTS
+        @info "testing $d"
+        @test logdensity(d, rand(d)) isa Float64
+    end
+end
 
 # import MeasureBase.:⋅
 # function ⋅(μ::Normal, kernel)