Cloud(n_params::Int, n_parts::Int)

Easier constructor for Cloud, which initializes the weights to be equal, and everything else in the particle object to be empty.

get_weights(c::Cloud)

Returns Vector{Float64}(n_parts) of weights of particles in cloud.

get_vals(c::Matrix{Float64})

Returns Matrix{Float64}(nparams, nparts) of parameter values in particle cloud.

split_cloud(filename::String, n_pieces::Int)

splits the cloud saved in filename to multiple files (n_pieces of them). For large clouds, the memory usage by one file may be too large. For example, the file may exceed GitHub's 100MB memory limit.

join_cloud(filename::String, n_pieces::Int; save_cloud::Bool = true)

joins a cloud saved in filename that had previously been split into multiple files (n_pieces of them) and saves the newly joined cloud when the kwarg save_cloud is true. For large clouds, the memory usage by one file may be too large. For example, the file may exceed GitHub's 100MB memory limit. For this reason, it is useful to split the cloud file into multiple files and then rejoin later.

add_parameters_to_cloud(old_cloud_file::String, para::ParameterVector,
                        old_para_inds::BitVector; regime_switching::Bool = false)

add_parameters_to_cloud(old_cloud::Cloud, para::ParameterVector, old_para_inds::BitVector;
                        regime_switching::Bool = false) where {T <: Real}

extends a Cloud from a previous estimation to include new parameters. This function helps construct a bridge distribution when you want to estimate a model that extends a previous model by adding additional parameters.

To be concrete, suppose we have two models $\mathcal{M}_1$ and $\mathcal{M}_2$ such that the parameters of the first model are a subset of the parameters of the second model. For example, suppose $\theta_1$ are the parameters for the first model, and $\theta_2 = [\theta_1, \tilde{\theta}]^T$, where $\tilde{\theta}$ are the new parameters for $\mathcal{M}_2$. Assume that

(1) the likelihood function for $\mathcal{M}_1` does not depend on$ ilde{\theta}$, (2) the priors for$ heta_1$and$ ilde{ heta}`` are independent.

Then the posterior for $\theta_2$ given $\mathcal{M}_1$ is just $math \begin{aligned} \pi(\theta_2 \vert Y, \mathcal{M}_1) = \pi(\theta_1 \vert Y, \mathcal{M}_1) p(\tilde{\theta}). \end{aligned}$ Therefore, we can construct the posterior $\pi(\theta_2 \vert Y, \mathcal{M}_1)$ by concatenating draws from the prior for $\tilde{\theta}$ to the previous estimation of $\mathcal{M}_1$. This function performs this concatenation and allows for regime-switching.

Inputs

• old_cloud or old_cloud_file: this input should specify the Cloud from a previous estimation of the old model. If a different package was used to estimate the model, then the user can construct a new Cloud object. The only fields which must be set correctly are the particles and ESS field. The others can be set to default values (see ?Cloud and the source code for the construction of the Cloud object).

• para: the parameter vector of the new model (i.e. $\theta_2$). The parameters in para that belonged to the old model should have the same settings as the ones used in previous estimation, e.g. the same prior.

• old_para_inds: indicates which parameters were used in the old estimation. If regime_switching = true, then this vector should specify which values correspond to old parameter values based on the matrix returned by SMC.get_values(para). For example, if old_para is the ParameterVector used by the old estimation, then SMC.get_values(old_para) == SMC.get_values(para)[old_para_inds]

Keyword Arguments

• regime_switching: this kwarg is needed to be able to draw from the prior correctly for the new parameters.

`function solve_adaptive_ϕ(cloud::Cloud, proposed_fixed_schedule::Vector{Float64},
                           i::Int64, j::Int64, ϕ_prop::Float64, ϕ_n1::Float64,
                           tempering_target::Float64, resampled_last_period::Bool)`

Solves for next Φ. Returns ϕn, resampledlastperiod, j, ϕprop.

`mvnormal_mixture_draw(θ_old::Vector{T}, d_prop::Distribution;
                       c::T = 1.0, α::T = 1.0) where T<:AbstractFloat`

Create a DegenerateMvNormal distribution object, d, from a parameter vector, p, and a standard deviation matrix (obtained from SVD), σ.

Generate a draw from the mixture distribution of:

1. A DegenerateMvNormal centered at θ_old with the standard deviation matrix σ, scaled by cc^2 and with mixture proportion α.
2. A DegenerateMvNormal centered at the same mean, but with a standard deviation matrix of the diagonal entries of σ scaled by cc^2 with mixture proportion (1 - α)/2.
3. A DegenerateMvNormal with the same standard deviation matrix σ but centered at the new proposed mean, θ_prop, scaled by cc^2, and with mixture proportion (1 - α)/2.

If no θ_prop is given, but an α is specified, then the mixture will consist of α of the standard distribution and (1 - α) of the diagonalized distribution.

Arguments

• θ_old::Vector{T}: The mean of the desired distribution
• σ::Matrix{T}: The standard deviation matrix of the desired distribution

Keyword Arguments

• cc::T: The standard deviation matrix scaling factor
• α::T: The mixing proportion
• θ_prop::Vector{T}: The proposed parameter vector to be used as part of the mixture distribution, set by default to be the weighted mean of the particles, prior to mutation.

Outputs

• θ_new::Vector{T}: The draw from the mixture distribution to be used as the MH proposed step

function `compute_ESS(loglh::Vector{T}, current_weights::Vector{T}, ϕ_n::T, ϕ_n1::T;
                     old_loglh::Vector{T} = zeros(length(loglh))) where {T<:AbstractFloat}`

Compute ESS given log likelihood, current weights, ϕn, ϕ{n-1}, and old log likelihood.

`generate_free_blocks(n_free_para::Int64, n_blocks::Int64)`

Return a Vector{Vector{Int64}} where each internal Vector{Int64} contains a subset of the range 1:nfreepara of randomly permuted indices. This is used to index out random blocks of free parameters from the covariance matrix for the mutation step.

`generate_all_blocks(blocks_free::Vector{Vector{Int64}}, free_para_inds::Vector{Int64})`

Return a Vector{Vector{Int64}} where each internal Vector{Int64} contains indices corresponding to those in blocks_free but mapping to 1:n_para (as opposed to 1:n_free_para). These blocks are used to reconstruct the particle vector by inserting the mutated free parameters into the size n_para, particle vector, which also contains fixed parameters.

function initial_draw!(loglikelihood::Function, parameters::ParameterVector{U},
                       data::Matrix{Float64}, c::Cloud; parallel::Bool = false,
                       regime_switching::Bool = false, toggle::Bool = true) where {U<:Number}

Draw from a general starting distribution (set by default to be from the prior) to initialize the SMC algorithm. Returns a tuple (loglh, logprior) and modifies the particle objects in the particle cloud in place.

Set regime_switching to true if there are regime-switching parameters. Otherwise, not all the values of the regimes will be used or saved.

Set toggle to false if, after calculating the loglikelihood, the values in the fields of every parameter in parameters are set to their regime 1 values. The regime-switching version of rand requires that the fields of all parameters take their regime 1 values, or else sampling may be wrong. The default is true as a safety, but if speed is a paramount concern, setting toggle = true will avoid unnecessary computations.