algorithm.hpp

Go to the documentation of this file.

#ifndef VMCMC_ALGORITHM_H_
#define VMCMC_ALGORITHM_H_

#include <vmcmc/parameter.hpp>
#include <vmcmc/chain.hpp>
#include <vmcmc/typetraits.hpp>

#include <functional>
#include <vector>
#include <cmath>

namespace vmcmc
{

class Writer;

class Algorithm
{
public:
    using DefaultCallable = std::function<double (const std::vector<double>&)>;

public:
    Algorithm();
    virtual ~Algorithm();

    void SetParameterConfig(const ParameterConfig& paramConfig);
    const ParameterConfig& GetParameterConfig() const { return fParameterConfig; }

    void SetPrior(DefaultCallable prior);
    template <size_t NParams, typename CallableT>
    void SetPrior(CallableT prior);

    void SetLikelihood(DefaultCallable likelihood);
    template <size_t NParams, typename CallableT>
    void SetLikelihood(CallableT likelihood);

    void SetNegLogLikelihood(DefaultCallable negLoglikelihood);
    template <size_t NParams, typename CallableT>
    void SetNegLogLikelihood(CallableT negLoglikelihood);

    void SetTotalLength(size_t length) { fTotalLength = length; }
    size_t GetTotalLength() const { return fTotalLength; }

    template <typename WriterT, typename... ArgsT>
    void AddWriter(ArgsT&&... args);
    void AddWriter(std::shared_ptr<Writer> writer) { fWriters.push_back( writer ); }

    double EvaluatePrior(const std::vector<double>& paramValues) const;

    double EvaluateLikelihood(const std::vector<double>& paramValues) const;

    double EvaluateNegLogLikelihood(const std::vector<double>& paramValues) const;

    bool Evaluate(Sample& sample) const;

    void Run();

    virtual void Initialize();

    virtual void Advance(size_t nSteps = 1) = 0;

    virtual void Finalize();

    virtual size_t NumberOfChains() = 0;
    virtual const Chain& GetChain(size_t cIndex = 0) = 0;

    ChainSetStatistics& GetStatistics() { return fStatistics; }
    const ChainSetStatistics& GetStatistics() const { return fStatistics; }

protected:
    ParameterConfig fParameterConfig;
    DefaultCallable fPrior;

    DefaultCallable fLikelihood;
    DefaultCallable fNegLogLikelihood;

    size_t fTotalLength;
    size_t fCycleLength;

    std::vector<std::shared_ptr<Writer>> fWriters;

    ChainSetStatistics fStatistics;
};

namespace detail
{

template <size_t NParams, typename C, typename... Ts>
typename std::enable_if<NParams == sizeof...(Ts), double>::type
inline apply_first_n(C f, const std::vector<double> &v, Ts&&... ts)
{
    return f(std::forward<Ts>(ts)...);
}

template <size_t NParams, typename C, typename... Ts>
typename std::enable_if<NParams != sizeof...(Ts), double>::type
inline apply_first_n(C f, const std::vector<double> &v, Ts&&... ts)
{
    constexpr ptrdiff_t index = NParams - sizeof...(Ts) - 1;
    static_assert(index >= 0, "invalid number of function parameters");
    return apply_first_n<NParams>(f, v, *(std::begin(v) + index), std::forward<Ts>(ts)...);
}

} /* namespace detail */

inline void Algorithm::SetPrior(DefaultCallable prior)
{
    fPrior = prior;
}

template <size_t NParams, typename CallableT>
inline void Algorithm::SetPrior(CallableT f)
{
    fPrior = [=](const std::vector<double>& v) {
        return detail::apply_first_n<NParams>(f, v);
    };
}

inline void Algorithm::SetLikelihood(DefaultCallable likelihood)
{
    fLikelihood = likelihood;
    fNegLogLikelihood = nullptr;
}

template <size_t NParams, typename CallableT>
inline void Algorithm::SetLikelihood(CallableT f)
{
    fLikelihood = [=](const std::vector<double>& v) {
        return detail::apply_first_n<NParams>(f, v);
    };
    fNegLogLikelihood = nullptr;
}

inline void Algorithm::SetNegLogLikelihood(DefaultCallable negLoglikelihood)
{
    fLikelihood = nullptr;
    fNegLogLikelihood = negLoglikelihood;
}

template <size_t NParams, typename CallableT>
inline void Algorithm::SetNegLogLikelihood(CallableT f)
{
    fLikelihood = nullptr;
    fNegLogLikelihood = [=](const std::vector<double>& v) {
        return detail::apply_first_n<NParams>(f, v);
    };
}

template <typename WriterT, typename... ArgsT>
inline void Algorithm::AddWriter(ArgsT&&... args)
{
    fWriters.emplace_back( std::make_shared<WriterT>(std::forward<ArgsT>(args)...) );
}

} /* namespace vmcmc */

#endif /* VMCMC_ALGORITHM_H_ */