Remove unicode and boilerplate code

Author: cpfiffer

src/mh-core.jl

@@ -3,7 +3,7 @@
 
 Fields:
 
-- `init_θ` is the vector form of the parameters needed for the likelihood function.
+- `init_params` is the vector form of the parameters needed for the likelihood function.
 - `proposal` is a function that dynamically constructs a conditional distribution.
 
 Example:
@@ -12,31 +12,12 @@ Example:
 MetropolisHastings([0.0, 0.0], x -> MvNormal(x, 1.0))
 ````
 """
-struct MetropolisHastings{P<:ProposalStyle, T, D} <: Metropolis
+mutable struct MetropolisHastings{P<:ProposalStyle, D, T} <: Metropolis
     proposal_type :: P
-    init_θ :: T
     proposal :: D
+    init_params :: T
 end
 
-# Default constructors.
-MetropolisHastings(init_θ::Real) = MetropolisHastings(init_θ, Normal(0,1))
-MetropolisHastings(init_θ::Vector{<:Real}) = MetropolisHastings(init_θ, MvNormal(length(init_θ),1))
-
-"""
-    propose(spl::MetropolisHastings, model::DensityModel, t::Transition)
-
-Generates a new parameter proposal conditional on the model, the sampler, and the previous
-sample.
-"""
-@inline propose(spl::MetropolisHastings, model::DensityModel, t::Transition) = propose(spl, model, t.θ)
-
-"""
-    q(spl::MetropolisHastings, t1::Transition, t2::Transition)
-
-Calculates the probability `q(θ | θcond)`, using the proposal distribution `spl.proposal`.
-"""
-@inline q(spl::MetropolisHastings, t1::Transition, t2::Transition) = q(spl, t1.θ, t2.θ)
-
 # Define the first step! function, which is called at the 
 # beginning of sampling. Return the initial parameter used
 # to define the sampler.
@@ -47,7 +28,7 @@ function step!(
     N::Integer;
     kwargs...
 )
-    return Transition(model, spl.init_θ)
+    return Transition(model, spl.init_params)
 end
 
 # Define the other step functions. Returns a Transition containing
@@ -58,19 +39,20 @@ function step!(
     model::DensityModel,
     spl::MetropolisHastings,
     ::Integer,
-    θ_prev::Transition;
+    params_prev::Transition;
     kwargs...
 )
     # Generate a new proposal.
-    θ = propose(spl, model, θ_prev)
+    params = propose(spl, model, params_prev)
 
     # Calculate the log acceptance probability.
-    α = ℓπ(model, θ) - ℓπ(model, θ_prev) + q(spl, θ_prev, θ) - q(spl, θ, θ_prev)
+    α = logdensity(model, params) - logdensity(model, params_prev) + 
+        q(spl, params_prev, params) - q(spl, params, params_prev)
 
-    # Decide whether to return the previous θ or the new one.
+    # Decide whether to return the previous params or the new one.
     if log(rand(rng)) < min(α, 0.0)
-        return θ
+        return params
     else
-        return θ_prev
+        return params_prev
     end
 end

src/rwmh.jl

@@ -8,7 +8,7 @@ Random walk Metropolis-Hastings.
 
 Fields:
 
-- `init_θ` is the vector form of the parameters needed for the likelihood function.
+- `init_params` is the vector form of the parameters needed for the likelihood function.
 - `proposal` is a function that dynamically constructs a conditional distribution.
 
 Example:
@@ -17,20 +17,33 @@ Example:
 RWMH([0.0, 0.0], x -> MvNormal(x, 1.0))
 ````
 """
-RWMH(init_theta::Real, proposal = Normal(init_theta, 1)) = MetropolisHastings(RandomWalk(), init_theta, proposal)
-RWMH(init_theta::Vector{<:Real}, proposal = MvNormal(init_theta, 1)) = MetropolisHastings(RandomWalk(), init_theta, proposal)
+RWMH(init_theta, proposal) = MetropolisHastings(RandomWalk(), proposal, init_theta)
+function RWMH(init_theta::Vector, proposal)
+    if proposal isa Vector
+        # Verify that there are proposal distributions for each parameter.
+        length(proposal) == length(init_theta) || 
+            throw("The number of proposal distributions must match the number of parameters.")
+    end
+
+    return MetropolisHastings(RandomWalk(), proposal, init_theta)
+end
 
 # Define a function that makes a basic proposal depending on a univariate
 # parameterization or a multivariate parameterization.
-propose(spl::MetropolisHastings{RandomWalk}, model::DensityModel, θ::Real) = Transition(model, θ + rand(spl.proposal))
-propose(spl::MetropolisHastings{RandomWalk}, model::DensityModel, θ::Vector{<:Real}) = Transition(model, θ + rand(spl.proposal))
+propose(spl::MetropolisHastings{RandomWalk, <:Distribution}, model::DensityModel, t::Transition) = Transition(model, t.params + rand(spl.proposal))
+function propose(spl::MetropolisHastings{RandomWalk, <:AbstractArray}, model::DensityModel, t::Transition)
+    props = map(x -> x[2] + rand(x[1]), zip(spl.proposal, t.params))
+    return Transition(model, props)
+end
 
 """
-    q(θ::Real, dist::Sampleable)
-    q(θ::Vector{<:Real}, dist::Sampleable)
+    q(params::Real, dist::Sampleable)
+    q(params::Vector{<:Real}, dist::Sampleable)
     q(t1::Transition, dist::Sampleable)
 
-Calculates the probability `q(θ | θcond)`, using the proposal distribution `spl.proposal`.
+Calculates the probability `q(params | paramscond)`, using the proposal distribution `spl.proposal`.
 """
-@inline q(spl::MetropolisHastings{RandomWalk}, θ::Real, θcond::Real) = logpdf(spl.proposal, θ - θcond)
-@inline q(spl::MetropolisHastings{RandomWalk}, θ::Vector{<:Real}, θcond::Vector{<:Real}) = logpdf(spl.proposal, θ - θcond)
+q(spl::MetropolisHastings{RandomWalk, <:Distribution}, t::Transition, t_cond::Transition) = logpdf(spl.proposal, t.params - t_cond.params)
+function q(spl::MetropolisHastings{RandomWalk, <:AbstractArray}, t::Transition, t_cond::Transition)
+    return sum(map(x -> logpdf(x[1], x[2] - x[3]), zip(spl.proposal, t.params, t_cond.params)))
+end

src/staticmh.jl

@@ -8,7 +8,7 @@ Static Metropolis-Hastings. Proposes only from the prior distribution.
 
 Fields:
 
-- `init_θ` is the vector form of the parameters needed for the likelihood function.
+- `init_params` is the vector form of the parameters needed for the likelihood function.
 - `proposal` is a distribution.
 
 Example:
@@ -17,21 +17,59 @@ Example:
 RWMH([0.0, 0.0], MvNormal(x, 1.0))
 ````
 """
-StaticMH(init_theta::Real, proposal = Normal(init_theta, 1)) = MetropolisHastings(Static(), init_theta, proposal)
-StaticMH(init_theta::Vector{<:Real}, proposal = MvNormal(init_theta, 1)) = MetropolisHastings(Static(), init_theta, proposal)
+StaticMH(init_theta, proposal) = MetropolisHastings(Static(), proposal, init_theta)
+function StaticMH(init_theta::Vector, proposal)
+    if proposal isa Vector
+        # Verify that there are proposal distributions for each parameter.
+        length(proposal) == length(init_theta) || 
+            throw("The number of proposal distributions must match the number of parameters.")
+    end
+
+    return MetropolisHastings(Static(), proposal, init_theta)
+end
 
 # Define a function that makes a basic proposal depending on a univariate
 # parameterization or a multivariate parameterization.
-propose(spl::MetropolisHastings{Static}, model::DensityModel, θ::Real) = Transition(model, rand(spl.proposal))
-propose(spl::MetropolisHastings{Static}, model::DensityModel, θ::Vector{<:Real}) = Transition(model, rand(spl.proposal))
+propose(spl::MetropolisHastings{Static, <:Distribution}, model::DensityModel, params::Transition) = Transition(model, rand(spl.proposal))
+function propose(spl::MetropolisHastings{Static, <:AbstractArray}, model::DensityModel, params::Transition)
+    props = map(rand, spl.proposal)
+    return Transition(model, props)
+end
+function propose(spl::MetropolisHastings{Static, <:NamedTuple}, model::DensityModel, params::Transition)
+    return Transition(model, _propose(spl.proposal))
+end
+@generated function _propose(proposals::NamedTuple{names}) where {names}
+    expr = Expr(:tuple)
+    map(names) do f
+        push!(expr.args, Expr(:(=), f, :(rand(proposals.$f)) ))
+    end
+    return expr
+end
 
 """
-    q(θ::Real, dist::Sampleable)
-    q(θ::Vector{<:Real}, dist::Sampleable)
+    q(params::Real, dist::Sampleable)
+    q(params::Vector{<:Real}, dist::Sampleable)
     q(t1::Transition, dist::Sampleable)
 
-Calculates the probability `q(θ | θcond)`, using the proposal distribution `spl.proposal`.
+Calculates the probability `q(params | paramscond)`, using the proposal distribution `spl.proposal`.
 """
-q(spl::MetropolisHastings{Static}, θ::Real, θcond::Real) = logpdf(spl.proposal, θ)
-q(spl::MetropolisHastings{Static}, θ::Vector{<:Real}, θcond::Vector{<:Real}) = logpdf(spl.proposal, θ)
+function q(spl::MetropolisHastings{Static, <:Distribution}, t::Transition, t_cond::Transition)
+    return logpdf(spl.proposal, t.params)
+end
+
+function q(spl::MetropolisHastings{Static, <:AbstractArray}, t::Transition, t_cond::Transition)
+    return sum(map(x -> logpdf(x[1], x[2]), zip(spl.proposal, t.params)))
+end
+
+function q(spl::MetropolisHastings{Static, <:NamedTuple}, t::Transition, t_cond::Transition)
+    total = 0.0
+    for p in keys(t.params)
+        if length(t.params[p]) == 1
+            total += logpdf(spl.proposal[p], t.params[p][1])
+        else
+            total += logpdf(spl.proposal[p], t.params[p])
+        end
+    end
+    return total
+end