DREAM
Markov Chain Monte Carlo acceleration by Differential Evolution
DREAM
is a FORTRAN90 program which
implements the DREAM algorithm for accelerating
Markov Chain Monte Carlo (MCMC) convergence using differential evolution,
by Guannan Zhang.
DREAM requires user input in the form of five FORTRAN90
subroutines:

problem_size(), defines the sizes of problem parameters;

problem_value(), defines the value of problem parameters;

prior_density(), evaluates the prior distribution;

prior_sample(), samples the prior distribution;

sample_likelihood(), evaluates the log likelihood function.
Examples of such user input are listed below.
DREAM requires access to a compiled version of the
pdflib library, which can evaluate a variety of Probability
Density Functions (PDF's) and produce samples from them.
The user may wish to invoke this library when constructing
some of the user functions.
DREAM requires access to a compiled version of the
rnglib library, in order to generate random numbers.
An older implementation of the DREAM algorithm is available
as DREAM1; it requires a user main program and two input files.
The DREAM program was originally developed by Guannan Zhang, of
Oak Ridge National Laboratory (ORNL); it has been incorporated into
the DAKOTA package of Sandia National Laboratory, and forms
part of the ORNL package known as TASMANIAN.
Web Link:
A version of the DREAM library is available in
http://tasmanian.ornl.gov,
the TASMANIAN library, available from Oak Ridge National Laboratory.
Licensing:
The computer code and data files described and made available on this
web page are distributed under
the GNU LGPL license.
Languages:
DREAM is available in
a C version and
a C++ version and
a FORTRAN90 version and
a MATLAB version.
Related Data and Programs:
DREAM0
a FORTRAN90 library which
is the original implementation of the DREAM algorithm for accelerating
Markov Chain Monte Carlo (MCMC) convergence using differential evolution,
by Guannan Zhang.
DREAM1,
a FORTRAN90 library which
is an older implementation of the DREAM algorithm for accelerating
Markov Chain Monte Carlo (MCMC)
convergence using differential evolution,
using a user function main program and two input files
to define the problem, by Guannan Zhang.
PDFLIB,
a FORTRAN90 library which
evaluates Probability Density Functions (PDF's)
and produces random samples from them,
including beta, binomial, chi, exponential, gamma, inverse chi,
inverse gamma, multinomial, normal, scaled inverse chi, and uniform.
RANLIB,
a FORTRAN90 library which
produces random samples from Probability Density Functions (PDF's),
including Beta, Chisquare Exponential, F, Gamma, Multivariate normal,
Noncentral chisquare, Noncentral F, Univariate normal,
random permutations, Real uniform, Binomial, Negative Binomial,
Multinomial, Poisson and Integer uniform,
by Barry Brown and James Lovato.
RNGLIB,
a FORTRAN90 library which
implements a random number generator (RNG) with splitting facilities,
allowing multiple independent streams to be computed,
by L'Ecuyer and Cote.
Author:
Original FORTRAN90 version by Guannan Zhang;
This FORTRAN90 version by John Burkardt.
Reference:

Pierre LEcuyer, Serge Cote,
Implementing a Random Number Package with Splitting Facilities,
ACM Transactions on Mathematical Software,
Volume 17, Number 1, March 1991, pages 98111.

Jasper Vrugt, CJF ter Braak, CGH Diks, Bruce Robinson, James Hyman,
Dave Higdon,
Accelerating Markov Chain Monte Carlo Simulation by Differential
Evolution with SelfAdaptive Randomized Subspace Sampling,
International Journal of Nonlinear Sciences and Numerical
Simulation,
Volume 10, Number 3, March 2009, pages 271288.
Source Code:
Examples and Tests:
PROBLEM0 is a small sample problem, in 10 dimensions, with a
density that is the maximum of two gaussians centered at (5,5,...,5)
and (5,5,...,5).

problem0.f90,
is a user written file, containing 5 functions, which
define the data for problem 0.

problem0_output.txt,
the output file.

problem0_chain01.txt,
a chain data file.

problem0_chain02.txt,
a chain data file.

problem0_chain03.txt,
a chain data file.

problem0_chain04.txt,
a chain data file.

problem0_chain05.txt,
a chain data file.

problem0_chain06.txt,
a chain data file.

problem0_chain07.txt,
a chain data file.

problem0_chain08.txt,
a chain data file.

problem0_chain09.txt,
a chain data file.

problem0_chain10.txt,
a chain data file.

problem0_gr.txt,
the GelmanRubin statistic file.

problem0_restart.txt,
the restart file.
PROBLEM1 is based on the first example in the Vrugt reference.
The Vrugt version involves 100 variables, with a multidimensional
normal distribution with specified mean vector and covariance matrix.
So far, I have simply set up the user routines, with just 5 variables,
and created a small standalone main program to test it.

problem1.f90,
is a user written file, containing the 5 functions required
to define the problem data, as well as other functions to
set the covariance for problem 1.

problem1_main.f90,
a standalone main program that calls the user functions
to make some simple tests.

problem1_main_output.txt,
the output file from the standalone main program.
PROBLEM2 is based on the second example in the Vrugt reference.
The Vrugt version involves 10 variables, with a "twisted" Gaussian
density function.

problem2.f90,
is a user written file, containing the 5 functions required
to define problem 2.
List of Routines:

MAIN is the main program for DREAM.

CHAIN_INIT starts Markov chains from a prior distribution.

CHAIN_INIT_PRINT prints the initial values for Markov chains.

CHAIN_OUTLIERS identifies and modifies outlier chains during burnin.

CHAIN_WRITE writes samples of each chain to separate files.

CR_DIS_UPDATE updates the CR distance.

CR_INDEX_CHOOSE chooses a CR value.

CR_INIT initializes the crossover probability values.

CR_PROB_UPDATE updates the CR probabilities.

DIFF_COMPUTE computes the differential evolution.

DREAM_ALGM gets a candidate parameter sample.

FILENAME_INC increments a partially numeric filename.

GET_UNIT returns a free FORTRAN unit number.

GR_COMPUTE computes the Gelman Rubin statistics R used to check convergence.

GR_INIT initializes GelmanRubin variables.

GR_WRITE writes the GelmanRubin R statistics into a file.

I4MAT_PRINT prints an I4MAT.

I4MAT_PRINT_SOME prints some of an I4MAT.

I4VEC_TRANSPOSE_PRINT prints an I4VEC "transposed".

INPUT_PRINT prints the data from the input file.

JUMPRATE_CHOOSE chooses a jump rate from the jump rate table.

JUMPRATE_TABLE_INIT initializes the jump rate table.

JUMPRATE_TABLE_PRINT prints the jump rate table.

R8_ROUND_I4 sets an R8 to the nearest integral value, returning an I4

R8VEC_COPY copies an R8VEC.

R8VEC_HEAP_D reorders an R8VEC into an descending heap.

R8VEC_SORT_HEAP_A ascending sorts an R8VEC using heap sort.

R8VEC_TRANSPOSE_PRINT prints an R8VEC "transposed".

RESTART_READ reads parameter sample data from a restart file.

RESTART_WRITE writes a restart file.

SAMPLE_CANDIDATE generates candidate parameter samples.

SAMPLE_LIMITS enforces limits on a sample variable.

STD_COMPUTE computes the current standard deviations, for each parameter.

TIMESTAMP prints the current YMDHMS date as a time stamp.
You can go up one level to
the FORTRAN90 source codes.
Last revised on 09 June 2013.