map_rect.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUNCTOR_MAP_RECT_HPP
#define STAN_MATH_PRIM_FUNCTOR_MAP_RECT_HPP
 
#include <stan/math/prim/meta.hpp>
#include <stan/math/prim/err.hpp>
#include <stan/math/prim/fun/dims.hpp>
#include <stan/math/prim/fun/typedefs.hpp>
 
#define STAN_REGISTER_MAP_RECT(CALLID, FUNCTOR)
 
#ifdef STAN_MPI
#include <stan/math/prim/functor/map_rect_mpi.hpp>
#else
#include <stan/math/prim/functor/map_rect_concurrent.hpp>
#endif
 
#include <vector>
 
namespace stan {
namespace math {
 
template <int call_id, typename F, typename T_shared_param,
          typename T_job_param,
          require_eigen_col_vector_t<T_shared_param>* = nullptr>
inline Eigen::Matrix<return_type_t<T_shared_param, T_job_param>, Eigen::Dynamic,
                     1>
map_rect(const T_shared_param& shared_params,
         const std::vector<Eigen::Matrix<T_job_param, Eigen::Dynamic, 1>>&
             job_params,
         const std::vector<std::vector<double>>& x_r,
         const std::vector<std::vector<int>>& x_i,
         std::ostream* msgs = nullptr) {
  static constexpr const char* function = "map_rect";
  using return_t = Eigen::Matrix<return_type_t<T_shared_param, T_job_param>,
                                 Eigen::Dynamic, 1>;
 
  check_matching_sizes(function, "job parameters", job_params, "real data",
                       x_r);
  check_matching_sizes(function, "job parameters", job_params, "int data", x_i);
 
  // check size consistency of inputs per job
  const std::vector<int> job_params_dims = dims(job_params);
 
  if (job_params_dims[0] == 0) {
    return return_t();
  }
 
  const int size_job_params = job_params_dims[1];
  const int size_x_r = dims(x_r)[1];
  const int size_x_i = dims(x_i)[1];
  for (int i = 1; i < job_params_dims[0]; i++) {
    check_size_match(function,
                     "Size of one of the vectors of "
                     "the job specific parameters",
                     job_params[i].size(),
                     "size of another vector of the "
                     "job specific parameters",
                     size_job_params);
    check_size_match(function,
                     "Size of one of the arrays of "
                     "the job specific real data",
                     x_r[i].size(),
                     "size of another array of the "
                     "job specific real data",
                     size_x_r);
    check_size_match(function,
                     "Size of one of the arrays of "
                     "the job specific int data",
                     x_i[i].size(),
                     "size of another array of the "
                     "job specific int data",
                     size_x_i);
  }
 
#ifdef STAN_MPI
  using T_plain_shared_param = plain_type_t<T_shared_param>;
  T_plain_shared_param shared_params_eval = shared_params;
  return internal::map_rect_mpi<call_id, F, T_plain_shared_param, T_job_param>(
      shared_params_eval, job_params, x_r, x_i, msgs);
#else
  using T_shared_param_ref = ref_type_t<T_shared_param>;
  T_shared_param_ref shared_params_ref = shared_params;
  return internal::map_rect_concurrent<call_id, F, T_shared_param_ref,
                                       T_job_param>(shared_params_ref,
                                                    job_params, x_r, x_i, msgs);
#endif
}
 
}  // namespace math
}  // namespace stan
 
#endif