Fix a few issues with functions on superposition (#46)

* Show that the logdensity is not defined when not using 2-tuples

* Fix on basemeasure

* Remove Any

* WIP for constructors

* Add gitignore for vscode

* Add tests fors the constructor

* Update src/combinators/smart-constructors.jl

* Update src/combinators/superpose.jl

* Update test/combinators/superpose.jl

Co-authored-by: Chad Scherrer <chad.scherrer@gmail.com>

Author: theogf

.gitignore

@@ -4,3 +4,4 @@
 **/Manifest.toml
 /docs/build/
 coverage/
+.vscode/settings.json

src/combinators/smart-constructors.jl

@@ -34,16 +34,17 @@ end
 
 productmeasure(mar::Fill) = powermeasure(mar.value, mar.axes)
 
-function productmeasure(mar::ReadonlyMappedArray{T, N, A, Returns{M}}) where {T,N,A,M}
+function productmeasure(mar::ReadonlyMappedArray{T,N,A,Returns{M}}) where {T,N,A,M}
     return powermeasure(mar.f.value, axes(mar.data))
 end
 
 productmeasure(mar::Base.Generator) = ProductMeasure(mar)
 productmeasure(mar::AbstractArray) = ProductMeasure(mar)
 
-
 # TODO: Make this static when its length is static
-@inline function productmeasure(mar::AbstractArray{WeightedMeasure{StaticFloat64{W}, M}}) where {W,M}
+@inline function productmeasure(
+    mar::AbstractArray{WeightedMeasure{StaticFloat64{W},M}},
+) where {W,M}
     return weightedmeasure(W * length(mar), productmeasure(map(basemeasure, mar)))
 end
 
@@ -54,6 +55,7 @@ productmeasure(f, param_maps, pars) = ProductMeasure(kernel(f, param_maps), pars
 
 productmeasure(k::ParameterizedTransitionKernel, pars) = productmeasure(k.f, k.param_maps, pars)
 
+
 function productmeasure(f::Returns{W}, ::typeof(identity), pars) where {W<:WeightedMeasure}
     ℓ = _logweight(f.value)
     base = basemeasure(f.value)
@@ -75,19 +77,31 @@ superpose(a::AbstractArray) = SuperpositionMeasure(a)
 superpose(t::Tuple) = SuperpositionMeasure(t)
 superpose(nt::NamedTuple) = SuperpositionMeasure(nt)
 
-function superpose(μ::T, ν::T) where {T}
-    if μ==ν
+function superpose(μ::T, ν::T) where {T<:AbstractMeasure}
+    if μ == ν
         return weightedmeasure(static(logtwo), μ)
     else
         return superpose((μ, ν))
     end
 end
 
-function superpose(μ, ν)
-    components = (μ, ν)
-    superpose(components)
+function superpose(μ::AbstractMeasure, μs...)
+    if all(==(μ), μs)
+        return weightedmeasure(log(length(μs) + 1), μ)
+    else
+        return superpose((μ, μs...))
+    end
+end
+
+add_measures(μs::AbstractVector, νs) = push!(μs, νs...)
+add_measures(μs::Tuple, νs) = (μs..., νs...)
+
+function superpose(μ::SuperpositionMeasure, μs...)
+    SuperpositionMeasure(add_measures(μ.components, μs))
 end
 
+superpose(μ::SuperpositionMeasure) = μ
+
 ###############################################################################
 # WeightedMeasure
 
@@ -125,5 +139,5 @@ function kernel(::Type{M}; param_maps...) where {M}
     kernel(M, nt)
 end
 
-
 kernel(k::ParameterizedTransitionKernel) = k
+

src/combinators/superpose.jl

@@ -1,7 +1,11 @@
+
+using LogarithmicNumbers
+using LogExpFunctions
+
 export SuperpositionMeasure
 
 @doc raw"""
-    struct SuperpositionMeasure{X,NT} <: AbstractMeasure
+    struct SuperpositionMeasure{NT} <: AbstractMeasure
         components :: NT
     end
 Superposition of measures is analogous to mixture distributions, but (because
@@ -57,16 +61,14 @@ function Base.:+(μ::AbstractMeasure, ν::AbstractMeasure)
     superpose(μ, ν)
 end
 
-using LogarithmicNumbers
-
 oneplus(x::ULogarithmic) = exp(ULogarithmic, log1pexp(x.log))
 
 @inline function density_def(s::SuperpositionMeasure{Tuple{A,B}}, x) where {A,B}
     (μ, ν) = s.components
 
     insupport(μ, x) || return exp(ULogarithmic, logdensity_def(ν, x))
     insupport(ν, x) || return exp(ULogarithmic, logdensity_def(μ, x))
-  
+
     α = basemeasure(μ)
     β = basemeasure(ν)
     dμ_dα = exp(ULogarithmic, logdensity_def(μ, x))
@@ -76,13 +78,24 @@ oneplus(x::ULogarithmic) = exp(ULogarithmic, log1pexp(x.log))
     return dμ_dα / oneplus(dβ_dα) + dν_dβ / oneplus(dα_dβ)
 end
 
-using LogExpFunctions
+function density_def(s::SuperpositionMeasure, x)
+    T = typeof(s)
+    msg = """
+    Not implemented: There is no method
+    density_def(::$T, x)
+    """
+    error(msg)
+end
 
-@inline function logdensity_def(μ::T, ν::T, x::Any) where T<:(SuperpositionMeasure{Tuple{A, B}} where {A, B})
+@inline function logdensity_def(
+    μ::T,
+    ν::T,
+    x,
+) where {T<:(SuperpositionMeasure{Tuple{A,B}} where {A,B})}
     if μ === ν
         return zero(return_type(logdensity_def, (μ, x)))
     else
-        return logdensity_def(μ,x) - logdensity_def(ν, x)
+        return logdensity_def(μ, x) - logdensity_def(ν, x)
     end
 end
 
@@ -94,7 +107,11 @@ end
     return logaddexp(logdensity_rel(μ, β, x), logdensity_rel(ν, β, x))
 end
 
-@inline function logdensity_def(s::SuperpositionMeasure{Tuple{A,B}}, β::SuperpositionMeasure, x) where {A,B}
+@inline function logdensity_def(
+    s::SuperpositionMeasure{Tuple{A,B}},
+    β::SuperpositionMeasure,
+    x,
+) where {A,B}
     (μ, ν) = s.components
     insupport(μ, x) == true || return logdensity_rel(ν, β, x)
     insupport(ν, x) == true || return logdensity_rel(μ, β, x)
@@ -107,7 +124,10 @@ end
 
 @inline logdensity_def(s::SuperpositionMeasure, x) = log(density_def(s, x))
 
-basemeasure(μ::SuperpositionMeasure) = superpose(map(basemeasure, μ.components)...)
+function basemeasure(μ::SuperpositionMeasure{Tuple{A,B}}) where {A,B}
+    superpose(map(basemeasure, μ.components)...)
+end
+basemeasure(μ::SuperpositionMeasure) = superpose(map(basemeasure, μ.components))
 
 # TODO: Fix `rand` method (this one is wrong)
 # function Base.rand(μ::SuperpositionMeasure{X,N}) where {X,N}
@@ -118,4 +138,4 @@ basemeasure(μ::SuperpositionMeasure) = superpose(map(basemeasure, μ.components
     any(d.components) do c
         dynamic(insupport(c, x))
     end
-end
+end

test/combinators/superpose.jl

@@ -0,0 +1,24 @@
+using Test
+
+using MeasureBase
+using MeasureBase: superpose
+
+@testset "superpose.jl" begin
+    μ = Dirac(0)
+    ν = Dirac(1)
+    μs = μ + ν
+    @test μs isa SuperpositionMeasure{<:Tuple{Dirac,Dirac}}
+    @test μs == SuperpositionMeasure((μ, ν)) == superpose(μ, ν)
+    @test density_def(μs, 0) == 1.0
+    @test basemeasure(μs) == CountingMeasure() + CountingMeasure()
+
+    μs = SuperpositionMeasure([μ, ν])
+    @test μs isa SuperpositionMeasure{<:AbstractVector{<:AbstractMeasure}}
+    @test_throws ErrorException density_def(μs, 0)
+    @test basemeasure(μs).components == SuperpositionMeasure([CountingMeasure(), CountingMeasure()]).components
+
+    μ2 = μ + μ
+    @test μ2 isa WeightedMeasure
+    @test μ2 == superpose(μ, μ)
+    @test basemeasure(μ2) == μ
+end