apply_scalar_binary.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUNCTOR_APPLY_SCALAR_BINARY_HPP
#define STAN_MATH_PRIM_FUNCTOR_APPLY_SCALAR_BINARY_HPP
 
#include <stan/math/prim/fun/as_column_vector_or_scalar.hpp>
#include <stan/math/prim/meta/is_stan_scalar.hpp>
#include <stan/math/prim/meta/is_container.hpp>
#include <stan/math/prim/meta/is_eigen.hpp>
#include <stan/math/prim/meta/require_generics.hpp>
#include <stan/math/prim/err/check_matching_dims.hpp>
#include <stan/math/prim/err/check_matching_sizes.hpp>
#include <stan/math/prim/fun/num_elements.hpp>
#include <vector>
 
namespace stan {
namespace math {
 
template <typename F, typename T1, typename T2,
          require_all_stan_scalar_t<T1, T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  return std::forward<F>(f)(std::forward<T1>(x), std::forward<T2>(y));
}
 
template <typename F, typename T1, typename T2,
          require_all_eigen_t<T1, T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  check_matching_dims("Binary function", "x", x, "y", y);
  return make_holder(
      [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
        return std::forward<decltype(x_inner)>(x_inner).binaryExpr(
            std::forward<decltype(y_inner)>(y_inner),
            std::forward<decltype(f_inner)>(f_inner));
      },
      std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
}
 
template <typename F, typename T1, typename T2,
          require_eigen_vector_vt<is_stan_scalar, T1>* = nullptr,
          require_std_vector_vt<std::is_integral, T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  check_matching_sizes("Binary function", "x", x, "y", y);
  return make_holder(
      [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
        using int_vec_t = promote_scalar_t<value_type_t<decltype(y_inner)>,
                                           plain_type_t<decltype(x_inner)>>;
        auto y_map = make_holder(
            [](auto&& y_inner_) {
              return Eigen::Map<const int_vec_t>(y_inner_.data(),
                                                 y_inner_.size());
            },
            std::forward<decltype(y_inner)>(y_inner));
        return std::forward<decltype(x_inner)>(x_inner).binaryExpr(
            y_map, std::forward<decltype(f_inner)>(f_inner));
      },
      std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
}
 
template <typename F, typename T1, typename T2,
          require_std_vector_vt<std::is_integral, T1>* = nullptr,
          require_eigen_vector_vt<is_stan_scalar, T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  check_matching_sizes("Binary function", "x", x, "y", y);
  return make_holder(
      [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
        using int_vec_t = promote_scalar_t<value_type_t<decltype(x_inner)>,
                                           plain_type_t<decltype(y_inner)>>;
        auto x_map = make_holder(
            [](auto&& x_inner_) {
              return Eigen::Map<const int_vec_t>(x_inner_.data(),
                                                 x_inner_.size());
            },
            std::forward<decltype(x_inner)>(x_inner));
        return x_map.binaryExpr(std::forward<decltype(y_inner)>(y_inner),
                                std::forward<decltype(f_inner)>(f_inner));
      },
      std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
}
 
template <typename F, typename T1, typename T2,
          require_eigen_matrix_dynamic_vt<is_stan_scalar, T1>* = nullptr,
          require_std_vector_vt<is_std_vector, T2>* = nullptr,
          require_std_vector_st<std::is_integral, T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  if (num_elements(x) != num_elements(y)) {
    std::ostringstream msg;
    msg << "Inputs to vectorized binary function must match in"
        << " size if one is not a scalar";
    throw std::invalid_argument(msg.str());
  }
  using return_st = decltype(f(x(0), y[0][0]));
  Eigen::Matrix<return_st, Eigen::Dynamic, Eigen::Dynamic> result(x.rows(),
                                                                  x.cols());
  for (size_t i = 0; i < y.size(); ++i) {
    result.row(i) = apply_scalar_binary(f, x.row(i).transpose(),
                                        as_column_vector_or_scalar(y[i]));
  }
  return result;
}
 
template <typename F, typename T1, typename T2,
          require_std_vector_vt<is_std_vector, T1>* = nullptr,
          require_std_vector_st<std::is_integral, T1>* = nullptr,
          require_eigen_matrix_dynamic_vt<is_stan_scalar, T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  if (num_elements(x) != num_elements(y)) {
    std::ostringstream msg;
    msg << "Inputs to vectorized binary function must match in"
        << " size if one is not a scalar";
    throw std::invalid_argument(msg.str());
  }
  using return_st = decltype(f(x[0][0], y(0)));
  Eigen::Matrix<return_st, Eigen::Dynamic, Eigen::Dynamic> result(y.rows(),
                                                                  y.cols());
  for (size_t i = 0; i < x.size(); ++i) {
    result.row(i) = apply_scalar_binary(f, as_column_vector_or_scalar(x[i]),
                                        y.row(i).transpose());
  }
  return result;
}
 
template <typename F, typename T1, typename T2, require_eigen_t<T1>* = nullptr,
          require_stan_scalar_t<T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  return make_holder(
      [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
        return std::forward<decltype(x_inner)>(x_inner).unaryExpr(
            [f_inner_ = std::forward<decltype(f_inner)>(f_inner),
             y_inner](auto&& v) { return f_inner_(v, y_inner); });
      },
      std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
}
 
template <typename F, typename T1, typename T2,
          require_stan_scalar_t<T1>* = nullptr, require_eigen_t<T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  return make_holder(
      [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
        return std::forward<decltype(y_inner)>(y_inner).unaryExpr(
            [f_inner_ = std::forward<decltype(f_inner)>(f_inner),
             x_inner](auto&& v) {
              return f_inner_(x_inner, std::forward<decltype(v)>(v));
            });
      },
      std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
}
 
template <typename F, typename T1, typename T2,
          require_all_std_vector_vt<is_stan_scalar, T1, T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  check_matching_sizes("Binary function", "x", x, "y", y);
  using T_return = std::decay_t<decltype(f(x[0], y[0]))>;
  decltype(auto) x_vec = as_column_vector_or_scalar(std::forward<T1>(x));
  decltype(auto) y_vec = as_column_vector_or_scalar(std::forward<T2>(y));
  std::vector<T_return> result(x_vec.size());
  Eigen::Map<Eigen::Matrix<T_return, -1, 1>>(result.data(), result.size())
      = x_vec.binaryExpr(y_vec, std::forward<F>(f));
  return result;
}
 
template <typename F, typename T1, typename T2,
          require_std_vector_vt<is_stan_scalar, T1>* = nullptr,
          require_stan_scalar_t<T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  decltype(auto) x_vec = as_column_vector_or_scalar(std::forward<T1>(x));
  using T_return = std::decay_t<decltype(f(x[0], y))>;
  std::vector<T_return> result(x_vec.size());
  Eigen::Map<Eigen::Matrix<T_return, -1, 1>>(result.data(), result.size())
      = x_vec.unaryExpr(
          [f_ = std::forward<F>(f), y](auto&& v) { return f_(v, y); });
  return result;
}
 
template <typename F, typename T1, typename T2,
          require_stan_scalar_t<T1>* = nullptr,
          require_std_vector_vt<is_stan_scalar, T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  using T_return = std::decay_t<decltype(f(x, y[0]))>;
  decltype(auto) y_vec = as_column_vector_or_scalar(std::forward<T2>(y));
  std::vector<T_return> result(y_vec.size());
  Eigen::Map<Eigen::Matrix<T_return, -1, 1>>(result.data(), result.size())
      = y_vec.unaryExpr(
          [f_ = std::forward<F>(f), x](auto&& v) { return f_(x, v); });
  return result;
}
 
template <
    typename F, typename T1, typename T2,
    require_all_std_vector_vt<is_container_or_var_matrix, T1, T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  check_matching_sizes("Binary function", "x", x, "y", y);
  using T_return = plain_type_t<decltype(apply_scalar_binary(f, x[0], y[0]))>;
  size_t y_size = y.size();
  std::vector<T_return> result(y_size);
  for (size_t i = 0; i < y_size; ++i) {
    result[i] = apply_scalar_binary(f, x[i], y[i]);
  }
  return result;
}
 
template <typename F, typename T1, typename T2,
          require_std_vector_vt<is_container_or_var_matrix, T1>* = nullptr,
          require_stan_scalar_t<T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  using T_return = plain_type_t<decltype(apply_scalar_binary(f, x[0], y))>;
  size_t x_size = x.size();
  std::vector<T_return> result(x_size);
  for (size_t i = 0; i < x_size; ++i) {
    result[i] = apply_scalar_binary(f, x[i], y);
  }
  return result;
}
 
template <typename F, typename T1, typename T2,
          require_stan_scalar_t<T1>* = nullptr,
          require_std_vector_vt<is_container_or_var_matrix, T2>* = nullptr>
inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  using T_return = plain_type_t<decltype(apply_scalar_binary(f, x, y[0]))>;
  size_t y_size = y.size();
  std::vector<T_return> result(y_size);
  for (size_t i = 0; i < y_size; ++i) {
    result[i] = apply_scalar_binary(f, x, y[i]);
  }
  return result;
}
 
}  // namespace math
}  // namespace stan
#endif