hierarchical.hpp

Go to the documentation of this file.

#ifndef SSMPACK_PROCESS_HIERARCHICAL_HPP
#define SSMPACK_PROCESS_HIERARCHICAL_HPP

#include "ssmkit/process/base_process.hpp"
#include "ssmkit/process/traits.hpp"
#include "ssmkit/process/hierarchical_detail.hpp"

#include <utility>
#include <tuple>

namespace ssmkit {
namespace process {

template <class... Args>
class Hierarchical : public BaseProcess<Hierarchical<Args...>> {
  // check if all argument are process types! (can C++17 concepts used instead) 
  static_assert(AreProcesses<Args...>::value, "");

 private:
  using TArities = std::tuple<typename ProcessTraits<Args>::TArity...>;
  static constexpr size_t depth = sizeof...(Args)-1;

 public:
  using TRandomVAR = std::tuple<typename ProcessTraits<Args>::TRandomVAR...>;

 private:
  std::tuple<Args...> processes_;

 public:
  Hierarchical(Args... processes) : processes_{std::move(processes)...} {}

  TRandomVAR initialize() {
    TRandomVAR rvs;
    detail::GetInitialized<depth>::apply(rvs, processes_);
    return rvs;
  }
  template <class... TVARs>
  TRandomVAR random(const TVARs &... args) {
    // what if args are more than what actually required?

    /* we make a variable and pass its reference to the GetRandom class member
     * apply which takes random variable of level 0 and recursively passes the
     * same reference to the GetRandom of other levels until reaches depth.
     */
    TRandomVAR rvs;
    constexpr size_t arity = std::tuple_element<0, TArities>::type::value;
    detail::GetRandom<0, arity, depth, TArities>::apply(
        std::make_index_sequence<arity>(), rvs, processes_,
        std::make_tuple(args...));
    return rvs;
  }

  template <class... TArgs>
  double likelihood(const TRandomVAR &rvs, const TArgs &... args) {
    double lik;
    constexpr size_t arity = std::tuple_element<0, TArities>::type::value;
    detail::GetLikelihood<0, arity, depth, TArities>::apply(
        tao::seq::make_index_range<0, arity>(), lik, rvs, processes_,
        std::make_tuple(args...));
    return lik;
  }

  template<size_t L>
  typename std::tuple_element<L, std::tuple<Args...>>::type &
  getProcess() {return std::get<L>(processes_); }
};

template <class... TArgs>
Hierarchical<TArgs...> makeHierarchical(TArgs... args) {
  return Hierarchical<TArgs...>(args...);
}

} // namespace process
} // namespace ssmkit

#endif // SSMPACK_PROCESS_HIERARCHICAL_HPP