adaptive_sampler.hpp

Go to the documentation of this file.

#ifndef __STAN__MCMC__ADAPTIVE_SAMPLER_HPP__
#define __STAN__MCMC__ADAPTIVE_SAMPLER_HPP__
 
#include <stan/mcmc/sampler.hpp>
#include <iostream>
 
namespace stan {
 
  namespace mcmc {
 
    class adaptive_sampler {
 
    protected: 
      bool _adapt;
      unsigned int _n_steps;
      int _n_adapt_steps;
      unsigned int _nfevals;
      double _mean_stat;
      std::ostream* _error_msgs;
      std::ostream* _output_msgs;
 
    public:
 
      adaptive_sampler(bool adapt,
                       std::ostream* error_msgs = 0,
                       std::ostream* output_msgs = 0)
        : _adapt(adapt), 
          _n_steps(0), 
          _n_adapt_steps(0), 
          _nfevals(0),
          _mean_stat(0),
          _error_msgs(error_msgs),
          _output_msgs(output_msgs) {
      }
 
      virtual ~adaptive_sampler() { 
      }
 
      void set_error_stream(std::ostream& error_msgs) {
        _error_msgs = &error_msgs;
      }
 
      void unset_error_stream() {
        _error_msgs = 0;
      }
 
 
      void set_output_stream(std::ostream& output_msgs) {
        _output_msgs = &output_msgs;
      }
 
      void unset_output_stream() {
        _output_msgs = 0;
      }
 
 
      virtual void set_params(const std::vector<double>& x, 
                              const std::vector<int>& z) = 0;
 
      sample next() {
        ++_n_steps;
        if (adapting())
          ++_n_adapt_steps;
        return next_impl();
      }
 
      virtual sample next_impl() = 0;
 
      virtual void find_reasonable_parameters() {
      };
 
      virtual void get_parameters(std::vector<double>& params) { 
        params.resize(0);
      }
 
      inline double mean_stat() { 
        return _mean_stat; 
      }
      
      inline void set_mean_stat(double v) {
        _mean_stat = v;
      }
 
      inline void update_mean_stat(double avg_eta, 
                                   double adapt_stat) {
        _mean_stat = avg_eta * adapt_stat + (1 - avg_eta) * _mean_stat;
      }
 
      inline unsigned int nfevals() { 
        return _nfevals; 
      }
 
      inline void nfevals_plus_eq(int n) {
        _nfevals += n;
      }
 
      inline int n_steps() {
        return _n_steps;
      }
 
      inline int n_adapt_steps() { 
        return _n_adapt_steps; 
      }
 
      virtual void adapt_on() { 
        _adapt = true; 
      }
 
      virtual void adapt_off() { 
        _adapt = false; 
      }
 
      inline bool adapting() { 
        return _adapt;
      }
 
      virtual void write_sampler_params(std::ostream& o) { 
      }
 
      virtual void write_adaptation_params(std::ostream& o) {
      }
 
      virtual void write_sampler_param_names(std::ostream& o) {
      }
 
      virtual void get_sampler_param_names(std::vector<std::string>& names) {
      }
                                
      virtual void get_sampler_params(std::vector<double>& values) {
      }
 
    };
 
  }
 
}
 
#endif