vsmc.h

Go to the documentation of this file.

/*============================================================================
 * vSMC/include/vsmc/vsmc.h
 *----------------------------------------------------------------------------
 *                         vSMC: Scalable Monte Carlo
 *----------------------------------------------------------------------------
 * Copyright (c) 2013-2016, Yan Zhou
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 *   Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *==========================================================================*/

#ifndef VSMC_VSMC_H
#define VSMC_VSMC_H

#include <stddef.h>

#ifdef __cplusplus
extern "C" {
#endif



typedef struct {
    int state[64];
} vsmc_rng;

int vsmc_rng_size();

void vsmc_rng_init(vsmc_rng *rng_ptr, int seed);

void vsmc_rng_seed(vsmc_rng *rng_ptr, int seed);

void vsmc_rng_get_key(const vsmc_rng *rng_ptr, int n, int *key);

void vsmc_rng_set_key(vsmc_rng *rng_ptr, int n, const int *key);

void vsmc_rng_get_ctr(const vsmc_rng *rng_ptr, int n, int *ctr);

void vsmc_rng_set_ctr(vsmc_rng *rng_ptr, int n, const int *ctr);

void vsmc_rng_rand(vsmc_rng *rng_ptr, int n, int *r);

void vsmc_rng_u01_sorted(int n, const double *u01, double *u01seq);

void vsmc_rng_u01_stratified(int n, const double *u01, double *u01seq);

void vsmc_rng_u01_systematic(int n, double u01, double *u01seq);

void vsmc_rng_discrete(vsmc_rng *rng_ptr, int n, int *r, int m,
    const double *weight, int normalized);

void vsmc_rng_uniform_int(vsmc_rng *rng_ptr, int n, int *r, int a, int b);

void vsmc_rng_bernoulli(vsmc_rng *rng_ptr, int n, int *r, double p);

void vsmc_rng_binomial(vsmc_rng *rng_ptr, int n, int *r, int t, double p);

void vsmc_rng_negative_binomial(
    vsmc_rng *rng_ptr, int n, int *r, int k, double p);

void vsmc_rng_geometric(vsmc_rng *rng_ptr, int n, int *r, double p);

void vsmc_rng_poisson(vsmc_rng *rng_ptr, int n, int *r, double mean);

void vsmc_rng_beta(
    vsmc_rng *rng_ptr, int n, double *r, double alpha, double beta);

void vsmc_rng_cauchy(vsmc_rng *rng_ptr, int n, double *r, double a, double b);

void vsmc_rng_chi_squared(vsmc_rng *rng_ptr, int n, double *r, double df);

void vsmc_rng_exponential(vsmc_rng *rng_ptr, int n, double *r, double lambda);

void vsmc_rng_extreme_value(
    vsmc_rng *rng_ptr, int n, double *r, double a, double b);

void vsmc_rng_fisher_f(
    vsmc_rng *rng_ptr, int n, double *r, double df1, double df2);

void vsmc_rng_gamma(
    vsmc_rng *rng_ptr, int n, double *r, double alpha, double beta);

void vsmc_rng_laplace(vsmc_rng *rng_ptr, int n, double *r, double a, double b);

void vsmc_rng_levy(vsmc_rng *rng_ptr, int n, double *r, double a, double b);

void vsmc_rng_logistic(
    vsmc_rng *rng_ptr, int n, double *r, double a, double b);

void vsmc_rng_lognormal(
    vsmc_rng *rng_ptr, int n, double *r, double m, double s);

void vsmc_rng_normal(
    vsmc_rng *rng_ptr, int n, double *r, double mean, double stddev);

void vsmc_rng_normal_mv(vsmc_rng *rng_ptr, int n, double *r, int dim,
    const double *mean, const double *chol);

void vsmc_rng_pareto(vsmc_rng *rng_ptr, int n, double *r, double a, double b);

void vsmc_rng_rayleigh(vsmc_rng *rng_ptr, int n, double *r, double b);

void vsmc_rng_student_t(vsmc_rng *rng_ptr, int n, double *r, double df);

void vsmc_rng_u01(vsmc_rng *rng_ptr, int n, double *r);

void vsmc_rng_uniform_real(
    vsmc_rng *rng_ptr, int n, double *r, double a, double b);

void vsmc_rng_weibull(vsmc_rng *rng_ptr, int n, double *r, double a, double b);



int vsmc_mkl_brng_mt19937(void);
int vsmc_mkl_brng_minstd_rand0(void);
int vsmc_mkl_brng_minstd_rand(void);
int vsmc_mkl_brng_mt19937_64(void);
int vsmc_mkl_brng_ranlux24_base(void);
int vsmc_mkl_brng_ranlux48_base(void);
int vsmc_mkl_brng_ranlux24(void);
int vsmc_mkl_brng_ranlux48(void);
int vsmc_mkl_brng_knuth_b(void);
int vsmc_mkl_brng_philox2x32(void);
int vsmc_mkl_brng_philox4x32(void);
int vsmc_mkl_brng_philox2x64(void);
int vsmc_mkl_brng_philox4x64(void);
int vsmc_mkl_brng_threefry2x32(void);
int vsmc_mkl_brng_threefry4x32(void);
int vsmc_mkl_brng_threefry2x64(void);
int vsmc_mkl_brng_threefry4x64(void);
int vsmc_mkl_brng_threefry2x32avx2(void);
int vsmc_mkl_brng_threefry4x32avx2(void);
int vsmc_mkl_brng_threefry2x64avx2(void);
int vsmc_mkl_brng_threefry4x64avx2(void);
int vsmc_mkl_brng_threefry2x32sse2(void);
int vsmc_mkl_brng_threefry4x32sse2(void);
int vsmc_mkl_brng_threefry2x64sse2(void);
int vsmc_mkl_brng_threefry4x64sse2(void);
int vsmc_mkl_brng_aes128_1x32(void);
int vsmc_mkl_brng_aes128_2x32(void);
int vsmc_mkl_brng_aes128_4x32(void);
int vsmc_mkl_brng_aes128_8x32(void);
int vsmc_mkl_brng_aes128_1x64(void);
int vsmc_mkl_brng_aes128_2x64(void);
int vsmc_mkl_brng_aes128_4x64(void);
int vsmc_mkl_brng_aes128_8x64(void);
int vsmc_mkl_brng_aes192_1x32(void);
int vsmc_mkl_brng_aes192_2x32(void);
int vsmc_mkl_brng_aes192_4x32(void);
int vsmc_mkl_brng_aes192_8x32(void);
int vsmc_mkl_brng_aes192_1x64(void);
int vsmc_mkl_brng_aes192_2x64(void);
int vsmc_mkl_brng_aes192_4x64(void);
int vsmc_mkl_brng_aes192_8x64(void);
int vsmc_mkl_brng_aes256_1x32(void);
int vsmc_mkl_brng_aes256_2x32(void);
int vsmc_mkl_brng_aes256_4x32(void);
int vsmc_mkl_brng_aes256_8x32(void);
int vsmc_mkl_brng_aes256_1x64(void);
int vsmc_mkl_brng_aes256_2x64(void);
int vsmc_mkl_brng_aes256_4x64(void);
int vsmc_mkl_brng_aes256_8x64(void);
int vsmc_mkl_brng_ars_1x32(void);
int vsmc_mkl_brng_ars_2x32(void);
int vsmc_mkl_brng_ars_4x32(void);
int vsmc_mkl_brng_ars_8x32(void);
int vsmc_mkl_brng_ars_1x64(void);
int vsmc_mkl_brng_ars_2x64(void);
int vsmc_mkl_brng_ars_4x64(void);
int vsmc_mkl_brng_ars_8x64(void);
int vsmc_mkl_brng_rdrand16(void);
int vsmc_mkl_brng_rdrand32(void);
int vsmc_mkl_brng_rdrand64(void);



int vsmc_random_walk(vsmc_rng *rng_ptr, int dim, double *x, double *ltx,
    double (*log_target)(int, const double *),
    double (*proposal)(vsmc_rng *, int, const double *, double *));

int vsmc_random_walk_g(vsmc_rng *rng_ptr, int dim_x, int dim_g, double *x,
    double *ltx, double *g,
    double (*log_target)(int, int, const double *, double *),
    double (*proposal)(vsmc_rng *, int, const double *, double *));

double vsmc_normal_proposal(vsmc_rng *rng_ptr, int, const double *x, double *y,
    double stddev, double a, double b);

double vsmc_normal_mv_proposal(vsmc_rng *rng_ptr, int dim, const double *x,
    double *y, const double *chol, const double *a, const double *b);



void *vsmc_malloc(size_t n, int alignment);
void vsmc_free(void *ptr);



typedef enum {
    VSMC_RESAMPLE_MULTINOMIAL,
    VSMC_RESAMPLE_STRATIFIED,
    VSMC_RESAMPLE_SYSTEMATIC,
    VSMC_RESAMPLE_RESIDUAL,
    VSMC_RESAMPLE_RESIDUAL_STRATIFIED,
    VSMC_RESAMPLE_RESIDUAL_SYSTEMATIC
} vsmc_resample_scheme;

void vsmc_resample_trans_u01_rep(
    int m, int n, const double *weight, const double *u01, int *replication);
void vsmc_resample_trans_u01_index(
    int m, int n, const double *weight, const double *u01, int *index);
void vsmc_resample_trans_rep_index(
    int m, int n, const int *replication, int *index);
void vsmc_resample_trans_index_rep(
    int m, int n, const int *index, int *replication);
int vsmc_resample_trans_residual(
    int m, int n, const double *weight, double *resid, int *integ);

void vsmc_resample_multinomial(
    int m, int n, vsmc_rng *rng_ptr, const double *weight, int *replication);
void vsmc_resample_stratified(
    int m, int n, vsmc_rng *rng_ptr, const double *weight, int *replication);
void vsmc_resample_systematic(
    int m, int n, vsmc_rng *rng_ptr, const double *weight, int *replication);
void vsmc_resample_residual(
    int m, int n, vsmc_rng *rng_ptr, const double *weight, int *replication);
void vsmc_resample_residual_stratified(
    int m, int n, vsmc_rng *rng_ptr, const double *weight, int *replication);
void vsmc_resample_residual_systematic(
    int m, int n, vsmc_rng *rng_ptr, const double *weight, int *replication);
void vsmc_resample(int m, int n, vsmc_rng *rng_ptr, const double *weight,
    int *replication, vsmc_resample_scheme scheme);



#ifdef __cplusplus
} // extern "C"
#endif

#endif // VSMC_VSMC_H