multiply.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUN_MULTIPLY_HPP
#define STAN_MATH_PRIM_FUN_MULTIPLY_HPP
 
#include <stan/math/prim/meta.hpp>
#include <stan/math/prim/err.hpp>
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/prim/fun/dot_product.hpp>
#include <stan/math/prim/fun/to_ref.hpp>
#include <type_traits>
 
namespace stan {
namespace math {
 
template <typename Mat, typename Scal, require_stan_scalar_t<Scal>* = nullptr,
          require_eigen_t<Mat>* = nullptr,
          require_all_not_st_var<Scal, Mat>* = nullptr,
          require_all_not_complex_t<Scal, value_type_t<Mat>>* = nullptr>
inline auto multiply(Mat&& m, Scal c) {
  auto&& m_ref = to_ref(std::forward<Mat>(m));
  return make_holder(
      [c](auto&& m_) { return c * std::forward<decltype(m_)>(m_); },
      std::forward<decltype(m_ref)>(m_ref));
}
 
template <typename Mat, typename Scal,
          require_any_complex_t<value_type_t<Mat>, Scal>* = nullptr,
          require_eigen_t<Mat>* = nullptr, require_not_eigen_t<Scal>* = nullptr>
inline auto multiply(Mat&& m, Scal c) {
  auto&& m_ref = to_ref(std::forward<Mat>(m));
  return make_holder(
      [c](auto&& m_) { return c * std::forward<decltype(m_)>(m_); },
      std::forward<decltype(m_ref)>(m_ref));
}
 
template <typename Mat, typename Scal,
          require_any_complex_t<value_type_t<Mat>, Scal>* = nullptr,
          require_eigen_t<Mat>* = nullptr, require_not_eigen_t<Scal>* = nullptr>
inline auto multiply(const Scal& m, Mat&& c) {
  auto&& c_ref = to_ref(std::forward<Mat>(c));
  return make_holder(
      [m](auto&& c_) { return m * std::forward<decltype(c_)>(c_); },
      std::forward<decltype(c_ref)>(c_ref));
}
 
template <typename Scal, typename Mat, require_stan_scalar_t<Scal>* = nullptr,
          require_eigen_t<Mat>* = nullptr,
          require_all_not_st_var<Scal, Mat>* = nullptr,
          require_all_not_complex_t<Scal, value_type_t<Mat>>* = nullptr>
inline auto multiply(Scal c, Mat&& m) {
  auto&& m_ref = to_ref(std::forward<Mat>(m));
  return make_holder(
      [c](auto&& m_) { return c * std::forward<decltype(m_)>(m_); },
      std::forward<decltype(m_ref)>(m_ref));
}
 
template <typename Mat1, typename Mat2,
          require_all_eigen_vt<std::is_arithmetic, Mat1, Mat2>* = nullptr,
          require_not_eigen_row_and_col_t<Mat1, Mat2>* = nullptr>
inline auto multiply(Mat1&& m1, Mat2&& m2) {
  auto&& m1_ref = to_ref(std::forward<Mat1>(m1));
  auto&& m2_ref = to_ref(std::forward<Mat2>(m2));
  check_size_match("multiply", "Columns of m1", m1_ref.cols(), "Rows of m2",
                   m2_ref.rows());
  return make_holder(
      [](auto&& m1_, auto&& m2_) {
        return std::forward<decltype(m1_)>(m1_)
               * std::forward<decltype(m2_)>(m2_);
      },
      std::forward<decltype(m1_ref)>(m1_ref),
      std::forward<decltype(m2_ref)>(m2_ref));
}
 
template <typename Mat1, typename Mat2,
          require_all_eigen_t<Mat1, Mat2>* = nullptr,
          require_t<is_complex<return_type_t<Mat1, Mat2>>>* = nullptr,
          require_not_eigen_row_and_col_t<Mat1, Mat2>* = nullptr>
inline auto multiply(Mat1&& m1, Mat2&& m2) {
  auto&& m1_ref = to_ref(std::forward<Mat1>(m1));
  auto&& m2_ref = to_ref(std::forward<Mat2>(m2));
  check_size_match("multiply", "Columns of m1", m1_ref.cols(), "Rows of m2",
                   m2_ref.rows());
  return make_holder(
      [](auto&& m1_, auto&& m2_) {
        return std::forward<decltype(m1_)>(m1_).lazyProduct(
            std::forward<decltype(m2_)>(m2_));
      },
      std::forward<decltype(m1_ref)>(m1_ref),
      std::forward<decltype(m2_ref)>(m2_ref));
}
 
template <typename RowVec, typename ColVec,
          require_not_var_t<return_type_t<RowVec, ColVec>>* = nullptr,
          require_eigen_row_and_col_t<RowVec, ColVec>* = nullptr>
inline auto multiply(RowVec&& rv, ColVec&& v) {
  check_multiplicable("multiply", "rv", rv, "v", v);
  return dot_product(std::forward<RowVec>(rv), std::forward<ColVec>(v));
}
 
template <typename Scalar1, typename Scalar2,
          require_all_stan_scalar_t<Scalar1, Scalar2>* = nullptr>
inline return_type_t<Scalar1, Scalar2> multiply(Scalar1 m, Scalar2 c) {
  return c * m;
}
 
}  // namespace math
}  // namespace stan
 
#endif