core.h

Go to the documentation of this file.

//============================================================================
// vSMC/include/vsmc/core/core.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_CORE_CORE_H
#define VSMC_CORE_CORE_H

#include <vsmc/internal/common.h>

#ifdef __cplusplus
extern "C" {
#endif


vsmc_weight vsmc_weight_new(size_t n);

void vsmc_weight_delete(vsmc_weight *weight_ptr);

void vsmc_weight_assign(vsmc_weight weight, vsmc_weight other);

size_t vsmc_weight_size(vsmc_weight weight);

void vsmc_weight_resize(vsmc_weight weight, size_t n);

void vsmc_weight_reserve(vsmc_weight weight, size_t n);

void vsmc_weight_shrink_to_fit(vsmc_weight weight);

double vsmc_weight_ess(vsmc_weight weight);

void vsmc_weight_read_weight(vsmc_weight weight, double *first, int stride);

const double *vsmc_weight_data(vsmc_weight weight);

void vsmc_weight_set_equal(vsmc_weight weight);

void vsmc_weight_set(vsmc_weight weight, const double *first, int stride);

void vsmc_weight_mul(vsmc_weight weight, const double *first, int stride);

void vsmc_weight_set_log(vsmc_weight weight, const double *first, int stride);

void vsmc_weight_add_log(vsmc_weight weight, const double *first, int stride);

size_t vsmc_weight_draw(vsmc_weight weight, vsmc_rng rng);



vsmc_state_matrix vsmc_state_matrix_new(size_t n, size_t dim);

void vsmc_state_matrix_delete(vsmc_state_matrix *state_matrix_ptr);

void vsm_state_matrix_assign(
    vsmc_state_matrix state_matrix, vsmc_state_matrix other);

size_t vsmc_state_matrix_size(vsmc_state_matrix state_matrix);

size_t vsmc_state_matrix_dim(vsmc_state_matrix state_matrix);

void vsmc_state_matrix_resize(
    vsmc_state_matrix state_matrix, size_t n, size_t dim);

void vsmc_state_matrix_reserve(
    vsmc_state_matrix state_matrix, size_t n, size_t dim);

void vsmc_state_matrix_shrink_to_fit(vsmc_state_matrix state_matrix);

double vsmc_state_matrix_get(
    vsmc_state_matrix state_matrix, size_t id, size_t pos);

void vsmc_state_matrix_set(
    vsmc_state_matrix state_matrix, size_t id, size_t pos, double s);

double *vsmc_state_matrix_data(vsmc_state_matrix state_matrix);

double *vsmc_state_matrix_row_data(vsmc_state_matrix state_matrix, size_t id);

double *state_matrix_row_data(vsmc_state_matrix state_matrix, size_t id);

void vsmc_state_matrix_read_state(
    vsmc_state_matrix state_matrix, size_t pos, double *first);

void vsmc_state_matrix_read_state_matrix(
    vsmc_state_matrix state_matrix, vSMCMatrixLayout layout, double *first);

void vsmc_state_matrix_select(
    vsmc_state_matrix state_matrix, size_t n, const size_t *index);

void vsmc_state_matrix_duplicate(
    vsmc_state_matrix state_matrix, size_t src, size_t dst);



vsmc_particle vsmc_particle_new(size_t n, size_t dim);

void vsmc_particle_delete(vsmc_particle *particle_ptr);

void vsmc_particle_assign(vsmc_particle particle, vsmc_particle other);

vsmc_particle vsmc_particle_clone(vsmc_particle particle);

size_t vsmc_particle_size(vsmc_particle particle);

void vsmc_particle_resize_by_index(
    vsmc_particle particle, size_t n, const size_t *index);

void vsmc_particle_resize_by_resample(
    vsmc_particle particle, size_t n, vSMCResampleScheme scheme);

void vsmc_particle_resize_by_uniform(vsmc_particle particle, size_t n);

vsmc_state_matrix vsmc_particle_state(vsmc_particle particle);

vsmc_weight vsmc_particle_weight(vsmc_particle particle);

vsmc_rng vsmc_particle_rng(vsmc_particle particle, size_t id);

vsmc_single_particle vsmc_particle_sp(vsmc_particle particle, size_t id);



vsmc_monitor vsmc_monitor_new(size_t dim, vsmc_monitor_eval_type eval,
    int record_only, vSMCMonitorStage stage);

void vsmc_monitor_delete(vsmc_monitor *monitor_ptr);

void vsmc_monitor_assign(vsmc_monitor monitor, vsmc_monitor other);

size_t vsmc_monitor_dim(vsmc_monitor monitor);

int vsmc_monitor_record_only(vsmc_monitor monitor);

vSMCMonitorStage vsmc_monitor_stage(vsmc_monitor monitor);

size_t vsmc_monitor_iter_size(vsmc_monitor monitor);

void vsmc_monitor_reserve(vsmc_monitor monitor, size_t num);

int vsmc_monitor_empty(vsmc_monitor monitor);

void vsmc_monitor_set_name(vsmc_monitor monitor, size_t id, const char *name);

size_t vsmc_monitor_get_name(vsmc_monitor monitor, size_t id, char *name);

size_t vsmc_monitor_index(vsmc_monitor monitor, size_t iter);

void vsmc_monitor_read_index(vsmc_monitor monitor, size_t *fist);

double vsmc_monitor_record(vsmc_monitor monitor, size_t id, size_t iter);

void vsmc_monitor_read_record(vsmc_monitor monitor, size_t id, double *first);

void vsmc_monitor_read_record_matrix(
    vsmc_monitor monitor, vSMCMatrixLayout layout, double *first);

void vsmc_monitor_eval(vsmc_monitor monitor, vsmc_monitor_eval_type new_eval,
    int record_only, vSMCMonitorStage stage);

void vsmc_monitor_compute(vsmc_monitor monitor, size_t iter,
    vsmc_particle particle, vSMCMonitorStage stage);

void vsmc_monitor_clear(vsmc_monitor monitor);



vsmc_sampler vsmc_sampler_new(size_t n, size_t dim);

void vsmc_sampler_delete(vsmc_sampler *sampler_ptr);

void vsmc_sampler_assign(vsmc_sampler sampler, vsmc_sampler other);

vsmc_sampler vsmc_sampler_clone(vsmc_sampler sampler);

size_t vsmc_sampler_size(vsmc_sampler sampler);

void vsmc_sampler_reserve(vsmc_sampler sampler, size_t num);

size_t vsmc_sampler_iter_size(vsmc_sampler sampler);

size_t vsmc_sampler_iter_num(vsmc_sampler sampler);

void vsmc_sampler_eval(vsmc_sampler sampler, vsmc_sampler_eval_type new_eval,
    vSMCSamplerStage stage, int append);

void vsmc_sampler_resample_scheme(
    vsmc_sampler sampler, vSMCResampleScheme scheme, double threshold);

void vsmc_sampler_resample_eval(
    vsmc_sampler sampler, vsmc_sampler_eval_type res_move, double threshold);

double vsmc_sampler_get_threshold(vsmc_sampler sampler);

void vsmc_sampler_set_threshold(vsmc_sampler sampler, double threshold);

double vsmc_sampler_resample_threshold_never(void);

double vsmc_sampler_resample_threshold_always(void);

void vsmc_sampler_set_monitor(
    vsmc_sampler sampler, const char *name, vsmc_monitor mon);

vsmc_monitor vsmc_sampler_get_monitor(vsmc_sampler sampler, const char *name);

int vsmc_sampler_monitor_clear(vsmc_sampler sampler, const char *name);

void vsmc_sampler_monitor_clear_all(vsmc_sampler sampler);

void vsmc_sampler_initialize(vsmc_sampler sampler);

void vsmc_sampler_iterate(vsmc_sampler sampler, size_t num);

vsmc_particle vsmc_sampler_particle(vsmc_sampler sampler);

size_t vsmc_sampler_size_history(vsmc_sampler sampler, size_t iter);

void vsmc_sampler_read_size_history(vsmc_sampler sampler, size_t *first);

double vsmc_sampler_ess_history(vsmc_sampler sampler, size_t iter);

void vsmc_sampler_read_ess_history(vsmc_sampler sampler, double *first);

int vsmc_sampler_resampled_history(vsmc_sampler sampler, size_t iter);

void vsmc_sampler_read_resampled_history(vsmc_sampler sampler, int *first);

size_t vsmc_sampler_status_history(
    vsmc_sampler sampler, size_t iter, size_t id);

size_t vsmc_sampler_print(vsmc_sampler sampler, char *buf, char sepchar);

void vsmc_sampler_print_f(
    vsmc_sampler sampler, const char *filename, char sepchar);


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

#endif // VSMC_CORE_CORE_H