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 <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(const Mat& m, Scal c) {
  return c * m;
}
 
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 Mat& m, Scal c) {
  return m * c;
}
 
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, const Mat& c) {
  return m * c;
}
 
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, const Mat& m) {
  return c * m;
}
 
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(const Mat1& m1, const Mat2& m2) {
  check_size_match("multiply", "Columns of m1", m1.cols(), "Rows of m2",
                   m2.rows());
  return m1 * m2;
}
 
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(const Mat1& m1, const Mat2& m2) {
  check_size_match("multiply", "Columns of m1", m1.cols(), "Rows of m2",
                   m2.rows());
  return m1.lazyProduct(m2).eval();
}
 
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(const RowVec& rv, const ColVec& v) {
  check_multiplicable("multiply", "rv", rv, "v", v);
  return dot_product(rv, 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