Remove ProposalStyle and forward function proposals

Author: devmotion

src/AdvancedMH.jl

@@ -8,18 +8,14 @@ using Requires
 using Random
 
 # Exports
-export MetropolisHastings, DensityModel, RWMH, StaticMH, Proposal, Static, RandomWalk
+export MetropolisHastings, DensityModel, RWMH, StaticMH, StaticProposal, RandomWalkProposal
 
 # Reexports
 using AbstractMCMC: sample, psample
 export sample, psample
 
 # Abstract type for MH-style samplers.
 abstract type Metropolis <: AbstractMCMC.AbstractSampler end
-abstract type ProposalStyle end
-
-struct RandomWalk <: ProposalStyle end
-struct Static <: ProposalStyle end
 
 # Define a model type. Stores the log density function and the data to 
 # evaluate the log density on.

src/mh-core.jl

@@ -12,16 +12,16 @@ x = (a = 1.0, b=3.8)
 The proposal would be
 
 ```julia
-proposal = (a=Proposal(Static(), Normal(0,1)), b=Proposal(Static(), Normal(0,1)))
+proposal = (a=StaticProposal(Normal(0,1)), b=StaticProposal(Normal(0,1)))
 ````
 
-Other allowed proposal styles are
+Other allowed proposals are
 
 ```
-p1 = Proposal(Static(), Normal(0,1))
-p2 = Proposal(Static(), [Normal(0,1), InverseGamma(2,3)])
-p3 = Proposal(Static(), (a=Normal(0,1), b=InverseGamma(2,3)))
-p4 = Proposal(Static(), (x=1.0) -> Normal(x, 1))
+p1 = StaticProposal(Normal(0,1))
+p2 = StaticProposal([Normal(0,1), InverseGamma(2,3)])
+p3 = StaticProposal(a=Normal(0,1), b=InverseGamma(2,3))
+p4 = StaticProposal((x=1.0) -> Normal(x, 1))
 ```
 
 The sampler is constructed using
@@ -45,8 +45,8 @@ mutable struct MetropolisHastings{D} <: Metropolis
     proposal :: D
 end
 
-StaticMH(d) = MetropolisHastings(Proposal(Static(), d))
-RWMH(d) = MetropolisHastings(Proposal(RandomWalk(), d))
+StaticMH(d) = MetropolisHastings(StaticProposal(d))
+RWMH(d) = MetropolisHastings(RandomWalkProposal(d))
 
 # Propose from a vector of proposals
 function propose(

src/proposal.jl

@@ -1,131 +1,99 @@
-struct Proposal{T<:ProposalStyle, P}
-    type :: T
-    proposal :: P
+abstract type Proposal{P} end
+
+struct StaticProposal{P} <: Proposal{P}
+    proposal::P
 end
 
-# Random draws
-Base.rand(p::Proposal{<:ProposalStyle, <:Distribution}) = rand(p.proposal)
-function Base.rand(p::Proposal{<:ProposalStyle, <:AbstractArray})
-    return map(rand, p.proposal)
+struct RandomWalkProposal{P} <: Proposal{P}
+    proposal::P
 end
 
+# Random draws
+Base.rand(p::Proposal{<:Distribution}) = rand(p.proposal)
+Base.rand(p::Proposal{<:AbstractArray}) = map(rand, p.proposal)
+
 # Densities
-function Distributions.logpdf(p::Proposal{<:ProposalStyle, <:UnivariateDistribution}, v) 
-    return sum(logpdf(p.proposal, v))
-end
-function Distributions.logpdf(p::Proposal{<:ProposalStyle, <:MultivariateDistribution}, v) 
-    return sum(logpdf(p.proposal, v))
-end
-function Distributions.logpdf(p::Proposal{<:ProposalStyle, <:MatrixDistribution}, v) 
-    return sum(logpdf(p.proposal, v))
-end
-function Distributions.logpdf(p::Proposal{<:ProposalStyle, <:AbstractArray}, v)
-    return sum(map(x -> logpdf(x[1], x[2]), zip(p.proposal, v)))
-end
-function Distributions.logpdf(p::Proposal{<:ProposalStyle, <:Function}, v)
-    return logpdf(p.proposal(v), v)
+Distributions.logpdf(p::Proposal{<:Distribution}, v) = logpdf(p.proposal, v)
+function Distributions.logpdf(p::Proposal{<:AbstractArray}, v)
+    # `mapreduce` with multiple iterators requires Julia 1.2 or later
+    return mapreduce(((pi, vi),) -> logpdf(pi, vi), +, zip(p.proposal, v))
 end
 
 ###############
 # Random Walk #
 ###############
 
-function propose(
-    proposal::Proposal{RandomWalk, <:Distribution}, 
-    model::DensityModel, 
-    t
-)
-    return t + rand(proposal)
+function propose(p::RandomWalkProposal, m::DensityModel)
+    return propose(StaticProposal(p.proposal), m)
 end
 
 function propose(
-    proposal::Proposal{RandomWalk, <:AbstractArray}, 
+    proposal::RandomWalkProposal{<:Union{Distribution,AbstractArray}}, 
     model::DensityModel, 
     t
 )
     return t + rand(proposal)
 end
 
 function q(
-    proposal::Proposal{RandomWalk, <:Distribution}, 
+    proposal::RandomWalkProposal{<:Union{Distribution,AbstractArray}}, 
     t,
     t_cond
 )
-    return sum(logpdf(proposal, t - t_cond))
-end
-
-function q(
-    proposal::Proposal{RandomWalk, <:AbstractArray}, 
-    t,
-    t_cond
-)
-    return sum(logpdf(proposal, t - t_cond))
+    return logpdf(proposal, t - t_cond)
 end
 
 ##########
 # Static #
 ##########
 
-propose(p::Proposal{RandomWalk}, m::DensityModel) = propose(Proposal(Static(), p.proposal), m)
 function propose(
-    proposal::Proposal{Static, <:Distribution}, 
-    model::DensityModel, 
+    proposal::StaticProposal{<:Union{Distribution,AbstractArray}},
+    model::DensityModel,
     t=nothing
 )
     return rand(proposal)
 end
 
-function propose(
-    p::Proposal{Static, <:AbstractArray}, 
-    model::DensityModel, 
-    t=nothing
-)
-    props = map(x -> rand(x), p.proposal)
-    return props
-end
-
 function q(
-    proposal::Proposal{Static, <:Distribution}, 
+    proposal::StaticProposal{<:Union{Distribution,AbstractArray}},
     t,
     t_cond
 )
-    return sum(logpdf(proposal, t))
-end
-
-function q(
-    proposal::Proposal{Static, <:AbstractArray}, 
-    t,
-    t_cond
-)
-    return sum(logpdf(proposal, t))
+    return logpdf(proposal, t)
 end
 
 ############
 # Function #
 ############
 
+# function definition with abstract types requires Julia 1.3 or later
+for T in (StaticProposal, RandomWalkProposal)
+    @eval begin
+        (p::$T{<:Function})() = $T(p.proposal())
+        (p::$T{<:Function})(t) = $T(p.proposal(t))
+    end
+end
+
 function propose(
-    proposal::Proposal{<:ProposalStyle, <:Function}, 
+    proposal::Proposal{<:Function},
     model::DensityModel
 )
-    p = proposal.proposal 
-    return rand(proposal.proposal())
+    return propose(proposal(), model)
 end
 
 function propose(
-    proposal::Proposal{<:ProposalStyle, <:Function}, 
+    proposal::Proposal{<:Function}, 
     model::DensityModel,
     t
 )
-    p = proposal.proposal
-    return rand(proposal.proposal(t))
+    return propose(proposal(t), model)
 end
 
 function q(
-    proposal::Proposal{<:ProposalStyle, <:Function}, 
+    proposal::Proposal{<:Function},
     t,
     t_cond
 )
-    p = proposal.proposal
-    return sum(logpdf.(p(t_cond), t))
+    return q(proposal(t_cond), t, t_cond)
 end

test/runtests.jl

@@ -68,10 +68,10 @@ using Test
         m3 = DensityModel(x -> logpdf(Normal(x.a, x.b), 1.0))
         m4 = DensityModel(x -> logpdf(Normal(x,1), 1.0))
 
-        p1 = Proposal(Static(), Normal(0,1))
-        p2 = Proposal(Static(), [Normal(0,1), InverseGamma(2,3)])
-        p3 = (a=Proposal(Static(), Normal(0,1)), b=Proposal(Static(), InverseGamma(2,3)))
-        p4 = Proposal(Static(), (x=1.0) -> Normal(x, 1))
+        p1 = StaticProposal(Normal(0,1))
+        p2 = StaticProposal([Normal(0,1), InverseGamma(2,3)])
+        p3 = (a=StaticProposal(Normal(0,1)), b=StaticProposal(InverseGamma(2,3)))
+        p4 = StaticProposal((x=1.0) -> Normal(x, 1))
 
         c1 = sample(m1, MetropolisHastings(p1), 100; chain_type=Vector{NamedTuple})
         c2 = sample(m2, MetropolisHastings(p2), 100; chain_type=Vector{NamedTuple})