bugfixes

Author: cscherrer

Project.toml

@@ -7,6 +7,7 @@ version = "0.1.0"
 ConcreteStructs = "2569d6c7-a4a2-43d3-a901-331e8e4be471"
 ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
+KeywordCalls = "4d827475-d3e4-43d6-abe3-9688362ede9f"
 MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078"
 MappedArrays = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"

src/combinators/for.jl

@@ -21,15 +21,15 @@ depending on `CartesianIndices(base)`.
 
 ```
 julia> For(3) do λ Exponential(λ) end |> marginals
-3-element mappedarray(MeasureTheory.var"#17#18"{var"#15#16"}(var"#15#16"()), ::CartesianIndices{1, Tuple{Base.OneTo{Int64}}}) with eltype Exponential{(:λ,), Tuple{Int64}}:
+3-element mappedarray(MeasureBase.var"#17#18"{var"#15#16"}(var"#15#16"()), ::CartesianIndices{1, Tuple{Base.OneTo{Int64}}}) with eltype Exponential{(:λ,), Tuple{Int64}}:
  Exponential(λ = 1,)
  Exponential(λ = 2,)
  Exponential(λ = 3,)
 ```
 
 ```
 julia> For(4,3) do μ,σ Normal(μ,σ) end |> marginals
-4×3 mappedarray(MeasureTheory.var"#17#18"{var"#11#12"}(var"#11#12"()), ::CartesianIndices{2, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}) with eltype Normal{(:μ, :σ), Tuple{Int64, Int64}}:
+4×3 mappedarray(MeasureBase.var"#17#18"{var"#11#12"}(var"#11#12"()), ::CartesianIndices{2, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}) with eltype Normal{(:μ, :σ), Tuple{Int64, Int64}}:
  Normal(μ = 1, σ = 1)  Normal(μ = 1, σ = 2)  Normal(μ = 1, σ = 3)
  Normal(μ = 2, σ = 1)  Normal(μ = 2, σ = 2)  Normal(μ = 2, σ = 3)
  Normal(μ = 3, σ = 1)  Normal(μ = 3, σ = 2)  Normal(μ = 3, σ = 3)

src/combinators/likelihood.jl

@@ -84,7 +84,7 @@ Finally, let's return to the expression for Bayes's Law,
 ``P(θ|x) ∝ P(θ) P(x|θ)``
 
 The product on the right side is computed pointwise. To work with this in
-MeasureTheory, we have a "pointwise product" `⊙`, which takes a measure and a
+MeasureBase, we have a "pointwise product" `⊙`, which takes a measure and a
 likelihood, and returns a new measure, that is, the unnormalized posterior that has density ``P(θ) P(x|θ)`` with respect to the base measure of the prior.
 
 For example, say we have

src/combinators/product.jl

@@ -135,35 +135,35 @@ end
 
 
 
-# @propagate_inbounds function MeasureTheory.logdensity(d::ProductMeasure{A}, x) where{T, A<:AbstractArray{T,1}}
+# @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 MeasureTheory.logdensity(d::ProductMeasure{A}, x) where{T, A<:AbstractArray{T,2}}
+# @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 MeasureTheory.logdensity(d::ProductMeasure{A}, x) where{T, A<:AbstractArray{T,3}}
+# @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 MeasureTheory.logdensity(d::ProductMeasure{A}, x) where{T, A<:AbstractArray{T,4}}
+# @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 MeasureTheory.logdensity(d::ProductMeasure{A}, x) where{T, A<:AbstractArray{T,5}}
+# @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])

src/combinators/weighted.jl

@@ -1,4 +1,4 @@
-export WeightedMeasure
+export WeightedMeasure, AbstractWeightedMeasure
 
 """
     struct WeightedMeasure{R,M} <: AbstractMeasure

src/domains.jl

@@ -1,3 +1,5 @@
+export IntegerRange
+
 abstract type AbstractDomain end
 
 """

src/macros.jl

@@ -1,7 +1,9 @@
 
 using MLStyle
 using Random: AbstractRNG
-export @parameterized
+using KeywordCalls
+using ConstructionBase
+export @parameterized, @μσ_methods, @σ_methods, @half
 
 # A fold over ASTs. Example usage in `replace`
 function foldast(leaf, branch; kwargs...)
@@ -49,12 +51,12 @@ function _parameterized(__module__, expr)
 
         # @gensym basename
         q = quote
-            struct $μ{N,T} <: MeasureTheory.ParameterizedMeasure{N}
+            struct $μ{N,T} <: MeasureBase.ParameterizedMeasure{N}
                 par :: NamedTuple{N,T}
             end
 
             const $μbase = $base
-            MeasureTheory.basemeasure(::$μ) = $μbase
+            MeasureBase.basemeasure(::$μ) = $μbase
         end   
 
         if !isempty(p)
@@ -70,7 +72,7 @@ function _parameterized(__module__, expr)
         μ = esc(μ)
 
         q = quote
-            struct $μ{N,T} <: MeasureTheory.ParameterizedMeasure{N}
+            struct $μ{N,T} <: MeasureBase.ParameterizedMeasure{N}
                 par :: NamedTuple{N,T}
             end
         end   
@@ -88,7 +90,7 @@ function _parameterized(__module__, expr)
         μ = esc(μ)
 
         q = quote
-            struct $μ{N,T} <: MeasureTheory.ParameterizedMeasure{N}
+            struct $μ{N,T} <: MeasureBase.ParameterizedMeasure{N}
                 par :: NamedTuple{N,T}
             end
         end   
@@ -141,15 +143,16 @@ end
 function _μσ_methods(__module__, ex)
     @match ex begin
         :($dist($(args...))) => begin
+            
             argnames = QuoteNode.(args)
 
             d_args = (:(d.$arg) for arg in args)
 
             method_μσ = KeywordCalls._kwstruct(__module__, :($dist($(args...), μ, σ)))
             method_μ  = KeywordCalls._kwstruct(__module__, :($dist($(args...), μ)))
             method_σ  = KeywordCalls._kwstruct(__module__, :($dist($(args...), σ)))
-
             C = constructorof(getproperty(__module__, dist))
+            dist = esc(dist)
             q = quote
 
                  $method_μσ
@@ -160,7 +163,7 @@ function _μσ_methods(__module__, ex)
                     d.σ * rand(rng, T, $dist($(d_args...))) + d.μ
                 end
 
-                function MeasureTheory.logdensity(d::$dist{($(argnames...), :μ, :σ)}, x)
+                function MeasureBase.logdensity(d::$dist{($(argnames...), :μ, :σ)}, x)
                     z = (x - d.μ) / d.σ   
                     return logdensity($dist($(d_args...)), z) - log(d.σ)
                 end
@@ -169,7 +172,7 @@ function _μσ_methods(__module__, ex)
                     d.σ * rand(rng, T, $dist($(d_args...)))
                 end
 
-                function MeasureTheory.logdensity(d::$dist{($(argnames...), :σ)}, x)
+                function MeasureBase.logdensity(d::$dist{($(argnames...), :σ)}, x)
                     z = x / d.σ   
                     return logdensity($dist($(d_args...)), z) - log(d.σ) 
                 end
@@ -178,15 +181,10 @@ function _μσ_methods(__module__, ex)
                     rand(rng, T, $dist($(d_args...))) + d.μ
                 end
 
-                function MeasureTheory.logdensity(d::$dist{($(argnames...), :μ)}, x)
+                function MeasureBase.logdensity(d::$dist{($(argnames...), :μ)}, x)
                     z = x - d.μ
                     return logdensity($dist($(d_args...)), z)
                 end
-
-                
-                MeasureTheory.asparams(::Type{<: $C}, ::Val{:μ}) = asℝ
-                MeasureTheory.asparams(::Type{<: $C}, ::Val{:σ}) = asℝ₊
-                MeasureTheory.asparams(::Type{<: $C}, ::Val{:logσ}) = asℝ
             end 
 
             return q
@@ -208,14 +206,15 @@ function _σ_methods(__module__, ex)
 
             method_σ  = KeywordCalls._kwstruct(__module__, :($dist($(args...), σ)))
 
+            dist = esc(dist)
             q = quote
                 $method_σ
 
                 function Base.rand(rng::AbstractRNG, T::Type, d::$dist{($(argnames...), :σ)})
                     d.σ * rand(rng, T, $dist($(d_args...)))
                 end
 
-                function MeasureTheory.logdensity(d::$dist{($(argnames...), :σ)}, x)
+                function MeasureBase.logdensity(d::$dist{($(argnames...), :σ)}, x)
                     z = x / d.σ   
                     return logdensity($dist($(d_args...)), z) - log(d.σ) 
                 end
@@ -241,34 +240,29 @@ creates `HalfNormal()`, and
 creates `HalfStudentT(ν)`.
 """
 macro half(ex)
-    esc(_half(__module__, ex))
+    _half(__module__, ex)
 end
 
 function _half(__module__, ex)
     @match ex begin
         :($dist($(args...))) => begin
-            halfdist = Symbol(:Half, dist)
-
-            TV = TransformVariables
-
+            halfdist = esc(Symbol(:Half, dist))
+            
             quote
-
-                export $halfdist
-                
                 struct $halfdist{N,T} <: ParameterizedMeasure{N}
                     par :: NamedTuple{N,T}
                 end
 
                 unhalf(μ::$halfdist) = $dist(getfield(μ, :par))
 
-                function MeasureTheory.basemeasure(μ::$halfdist) 
+                function MeasureBase.basemeasure(μ::$halfdist) 
                     b = basemeasure(unhalf(μ))
                     @assert basemeasure(b) == Lebesgue(ℝ)
                     lw = b.logweight
                     return WeightedMeasure(logtwo + lw, Lebesgue(ℝ₊))
                 end
 
-                function MeasureTheory.logdensity(μ::$halfdist, x)
+                function MeasureBase.logdensity(μ::$halfdist, x)
                     return logdensity(unhalf(μ), x)
                 end
 

src/resettablerng.jl

@@ -1,5 +1,5 @@
 using Random
-
+export ResettableRNG
 struct ResettableRNG{R,S} <: Random.AbstractRNG
     rng::R
     seed::S