sample_real.h

Go to the documentation of this file.

/* $Id: sample_real.h 17393 2014-08-23 20:19:14Z predoehl $ */
/* =========================================================================== *
   |
   |  Copyright (c) 1994-2010 by Kobus Barnard (author)
   |
   |  Personal and educational use of this code is granted, provided that this
   |  header is kept intact, and that the authorship is not misrepresented, that
   |  its use is acknowledged in publications, and relevant papers are cited.
   |
   |  For other use contact the author (kobus AT cs DOT arizona DOT edu).
   |
   |  Please note that the code in this file has not necessarily been adequately
   |  tested. Naturally, there is no guarantee of performance, support, or fitness
   |  for any particular task. Nonetheless, I am interested in hearing about
   |  problems that you encounter.
   |
   |  Author:  Ernesto Brau
 * =========================================================================== */

#ifndef SAMPLE_REAL_H_INCLUDED
#define SAMPLE_REAL_H_INCLUDED

#include "sample_cpp/sample_step.h"
#include "sample_cpp/sample_default.h"
#include "l/l_sys_lib.h"

template<class Model>
inline
double get_real_model_parameter(const Model& m, int i)
{
    using namespace kjb_c;
    ASSERT(i == 0);
    return m;
}

template<class Model>
inline
void set_real_model_parameter(Model& m, int i, double x)
{
    using namespace kjb_c;
    ASSERT(i == 0);
    m = x;
}

template<class Model>
inline
void move_real_model_parameter(Model& m, int i, double x)
{
    Move_model_parameter_as_plus<Model> mmpap(set_real_model_parameter<Model>,
                                              get_real_model_parameter<Model>);
    mmpap(m, i, x);
}


template<class Model>
inline
int get_real_model_dimension(const Model& /*m*/)
{
    return 1;
}

template<typename Model>
class Real_numerical_gradient : public Numerical_gradient<Model>
{
public:
    typedef Numerical_gradient<Model> Parent;

    typedef typename Parent::Target_distribution Target_distribution;
    typedef typename Parent::Get_neighborhood Get_neighborhood;

    Real_numerical_gradient
    (
        const Target_distribution& log_target,
        const Get_neighborhood&    get_neighborhood
    ) :
        Parent
        (
            log_target,
            move_real_model_parameter<Model>,
            get_neighborhood,
            get_real_model_dimension<Model>
        )
    {}
    Real_numerical_gradient
    (
        const Target_distribution& log_target,
        double                     neighborhood
    ) :
        Parent
        (
            log_target,
            move_real_model_parameter<Model>,
            Constant_parameter_evaluator<Model>(kjb::Vector(1, neighborhood)),
            get_real_model_dimension<Model>
        )
    {}
};

template<typename Model,
         bool CONSTRAINED_TARGET = false,
         bool INCLUDE_ACCEPT_STEP = true,
         bool REVERSIBLE = true>
class Real_hmc_step : public Basic_hmc_step<Model, CONSTRAINED_TARGET, INCLUDE_ACCEPT_STEP, REVERSIBLE>
{
public:
    typedef Basic_hmc_step<Model, CONSTRAINED_TARGET, INCLUDE_ACCEPT_STEP, REVERSIBLE> Parent;

    typedef typename Parent::Target_distribution Target_distribution;
    typedef typename Parent::Gradient Gradient;
    typedef typename Parent::Get_step_size Get_step_size;
    typedef typename Parent::Get_lower_bounds Get_lower_bounds;
    typedef typename Parent::Get_upper_bounds Get_upper_bounds;

    Real_hmc_step
    (
        const Target_distribution& log_target, 
        int                        num_dynamics_steps,
        const Gradient&            gradient,
        const Get_step_size&       get_step_size,
        double                     alpha = 0.0
    ) :
        Parent(log_target,
               num_dynamics_steps,
               gradient,
               move_real_model_parameter<Model>, 
               get_step_size,
               get_real_model_dimension<Model>,
               alpha)
    {}

    Real_hmc_step
    (
        const Target_distribution& log_target, 
        int                        num_dynamics_steps,
        const Gradient&            gradient,
        double                     step_size,
        double                     alpha = 0.0
    ) :
        Parent(log_target,
               num_dynamics_steps,
               gradient,
               move_real_model_parameter<Model>, 
               Constant_parameter_evaluator<Model>(kjb::Vector(1, step_size)),
               get_real_model_dimension<Model>,
               alpha)
    {}

    Real_hmc_step
    (
        const Target_distribution& log_target, 
        int                        num_dynamics_steps,
        const Gradient&            gradient,
        double                     step_size,
        double                     lower_bound,
        double                     upper_bound,
        double                     alpha = 0.0
    ) :
        Parent(log_target,
               num_dynamics_steps,
               gradient,
               move_real_model_parameter<Model>, 
               Constant_parameter_evaluator<Model>(kjb::Vector(1, step_size)),
               get_real_model_dimension<Model>,
               get_real_model_parameter<Model>,
               Constant_parameter_evaluator<Model>(kjb::Vector(1, lower_bound)),
               Constant_parameter_evaluator<Model>(kjb::Vector(1, upper_bound)),
               alpha)
    {}

    virtual ~Real_hmc_step()
    {}
};

template<class Model, bool REVERSIBLE = true>
struct Real_sd_step
{
    typedef Real_hmc_step<Model, false, REVERSIBLE> Type;
};

#endif /*SAMPLE_REAL_H_INCLUDED */