laplace_marginal_bernoulli_logit_lpmf.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_BERNOULLI_LOGIT_LPMF_HPP
#define STAN_MATH_MIX_PROB_LAPLACE_MARGINAL_BERNOULLI_LOGIT_LPMF_HPP
 
#include <stan/math/mix/meta.hpp>
#include <stan/math/mix/functor/laplace_likelihood.hpp>
#include <stan/math/mix/functor/laplace_marginal_density.hpp>
#include <stan/math/rev/fun/elt_multiply.hpp>
#include <stan/math/rev/fun/exp.hpp>
#include <stan/math/fwd/fun/exp.hpp>
#include <stan/math/rev/fun/log.hpp>
#include <stan/math/fwd/fun/log.hpp>
#include <stan/math/rev/fun/log1p_exp.hpp>
#include <stan/math/fwd/fun/log1p_exp.hpp>
#include <stan/math/rev/fun/multiply.hpp>
#include <stan/math/fwd/fun/multiply.hpp>
#include <stan/math/rev/fun/lgamma.hpp>
#include <stan/math/fwd/fun/lgamma.hpp>
#include <stan/math/rev/fun/sum.hpp>
#include <stan/math/fwd/fun/sum.hpp>
#include <stan/math/prim/fun/binomial_coefficient_log.hpp>
#include <stan/math/rev/fun/to_vector.hpp>
#include <stan/math/prim/fun/to_vector.hpp>
 
namespace stan {
namespace math {
 
struct bernoulli_logit_likelihood {
  template <typename ThetaVec, typename YVec, typename Mean>
  inline auto operator()(const ThetaVec& theta, const YVec& y,
                         const std::vector<int>& y_index, Mean&& mean,
                         std::ostream* msgs) const {
    Eigen::VectorXd counts_per_group = Eigen::VectorXd::Zero(theta.size());
    Eigen::VectorXd n_per_group = Eigen::VectorXd::Zero(theta.size());
 
    for (int i = 0; i < theta.size(); i++) {
      counts_per_group(y_index[i] - 1) += y[i];
      n_per_group(y_index[i] - 1) += 1;
    }
 
    auto theta_offset = to_ref(add(theta, mean));
 
    return sum(elt_multiply(theta_offset, counts_per_group)
               - elt_multiply(to_vector(n_per_group), log1p_exp(theta_offset)));
  }
};
 
template <bool propto = false, typename Mean, typename CovarFun,
          typename CovarArgs, typename OpsTuple>
inline auto laplace_marginal_tol_bernoulli_logit_lpmf(
    const std::vector<int>& y, const std::vector<int>& y_index, Mean&& mean,
    int hessian_block_size, CovarFun&& covariance_function,
    CovarArgs&& covar_args, OpsTuple&& ops, std::ostream* msgs) {
  auto options
      = internal::tuple_to_laplace_options(std::forward<OpsTuple>(ops));
  options.hessian_block_size = hessian_block_size;
  return laplace_marginal_density(
      bernoulli_logit_likelihood{},
      std::forward_as_tuple(to_vector(y), y_index, std::forward<Mean>(mean)),
      std::forward<CovarFun>(covariance_function),
      std::forward<CovarArgs>(covar_args), std::move(options), msgs);
}
 
template <bool propto = false, typename Mean, typename CovarFun,
          typename CovarArgs>
inline auto laplace_marginal_bernoulli_logit_lpmf(
    const std::vector<int>& y, const std::vector<int>& y_index, Mean&& mean,
    int hessian_block_size, CovarFun&& covariance_function,
    CovarArgs&& covar_args, std::ostream* msgs) {
  auto options = laplace_options_default{hessian_block_size};
  return laplace_marginal_density(
      bernoulli_logit_likelihood{},
      std::forward_as_tuple(to_vector(y), y_index, std::forward<Mean>(mean)),
      std::forward<CovarFun>(covariance_function),
      std::forward<CovarArgs>(covar_args), options, msgs);
}
 
}  // namespace math
}  // namespace stan
 
#endif